Java provides a new method forEach() to iterate the elements. It is defined in Iterable and Stream interface. It is a default method defined in the Iterable interface. Collection classes which extends Iterable interface can use forEach loop to iterate elements.
This method takes a single parameter which is a functional interface. So, you can pass lambda expression as an argument.

Table of Contents

forEach() Signature in Iterable Interface

1. default void forEach(Consumer<super T>action)

Java 8 forEach() example 1

1. import java.util.ArrayList; 
2. import java.util.List; 
3. public class ForEachExample { 
4. public static void main(String[] args) { 
5. List<String> gamesList = new ArrayList<String>(); 
6. gamesList.add("Football"); 
7. gamesList.add("Cricket"); 
8. gamesList.add("Chess"); 
9. gamesList.add("Hocky"); 
10. System.out.println("------------Iterating by passing lambda expression--------------"); 
11. gamesList.forEach(games -> System.out.println(games)); 
12. 
13. } 
14. }

Output:
————Iterating by passing lambda expression————–
Football
Cricket
Chess
Hocky

Java 8 forEach() example 2

1. import java.util.ArrayList; 
2. import java.util.List; 
3. public class ForEachExample { 
4. public static void main(String[] args) { 
5. List<String> gamesList = new ArrayList<String>(); 
6. gamesList.add("Football"); 
7. gamesList.add("Cricket"); 
8. gamesList.add("Chess"); 
9. gamesList.add("Hocky"); 
10. System.out.println("------------Iterating by passing method reference---------------"); 
11. gamesList.forEach(System.out::println); 
12. } 
13. }

Output:
————Iterating by passing method reference—————
Football
Cricket
Chess
Hocky

Java Stream forEachOrdered() Method

Along with forEach() method, Java provides one more method forEachOrdered(). It is used to iterate elements in the order specified by the stream.

Singnature:

1. void forEachOrdered(Consumer<? super T> action)

Java Stream forEachOrdered() Method Example

1. import java.util.ArrayList; 
2. import java.util.List; 
3. public class ForEachOrderedExample { 
4. public static void main(String[] args) { 
5. List<String> gamesList = new ArrayList<String>(); 
6. gamesList.add("Football"); 
7. gamesList.add("Cricket"); 
8. gamesList.add("Chess"); 
9. gamesList.add("Hocky"); 
10. System.out.println("------------Iterating by passing lambda expression---------------"); 
11. gamesList.stream().forEachOrdered(games -> System.out.println(games)); 
12. System.out.println("------------Iterating by passing method reference---------------"); 
13. gamesList.stream().forEachOrdered(System.out::println); 
14. } 
15. 
16. }

Output:
————Iterating by passing lambda expression—————
Football
Cricket
Chess
Hocky
————Iterating by passing method reference—————
Football
Cricket
Chess
Hocky

Java Collectors

Collectors is a final class that extends Object class. It provides reduction operations, such as accumulating elements into collections, summarizing elements according to various criteria, etc.
Java Collectors class provides various methods to deal with elements

Methods	Description
public static <T> Collector<T,?,Double> averagingDouble(ToDoubleFunction<? super T> mapper)	It returns a Collector that produces the arithmetic mean of a double-valued function applied to the input elements. If no elements are present, the result is 0.
public static <T> Collector<T,?,T> reducing(T identity, BinaryOperator<T> op)	It returns a Collector which performs a reduction of its input elements under a specified BinaryOperator using the provided identity.
public static <T> Collector<T,?,Optional<T>> reducing(BinaryOperator<T> op)	It returns a Collector which performs a reduction of its input elements under a specified BinaryOperator. The result is described as an Optional<T>.
public static <T,U> Collector<T,?,U> reducing(U identity, Function<? super T,? extends U> mapper, BinaryOperator<U> op)	It returns a Collector which performs a reduction of its input elements under a specified mapping function and BinaryOperator. This is a generalization of reducing(Object, BinaryOperator) which allows a transformation of the elements before reduction.
public static <T,K> Collector<T,?,Map<K,List<T>>> groupingBy(Function<? super T,? extends K> classifier)	It returns a Collector implementing a “group by” operation on input elements of type T, grouping elements according to a classification function, and returning the results in a Map.
public static <T,K,A,D> Collector<T,?,Map<K,D>> groupingBy(Function<? super T,? extends K> classifier, Collector<? Super T,A,D> downstream)	It returns a Collector implementing a cascaded “group by” operation on input elements of type T, grouping elements according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstream Collector.
public static <T,K,D,A,M extends Map<K,D>> Collector<T,?,M> groupingBy(Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream)	It returns a Collector implementing a cascaded “group by” operation on input elements of type T, grouping elements according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstream Collector. The Map produced by the Collector is created with the supplied factory function.
public static <T,K> Collector<T,?,ConcurrentMap<K,List<T>>> groupingByConcurrent(Function<? super T,? extends K> classifier)	It returns a concurrent Collector implementing a “group by” operation on input elements of type T, grouping elements according to a classification function.
public static <T,K,A,D> Collector<T,?,ConcurrentMap<K,D>> groupingByConcurrent(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)	It returns a concurrent Collector implementing a cascaded “group by” operation on input elements of type T, grouping elements according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstream Collector.
public static <T,K,A,D,M extends ConcurrentMap<K,D>> Collector<T,?,M> groupingByConcurrent(Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream)	It returns a concurrent Collector implementing a cascaded “group by” operation on input elements of type T, grouping elements according to a classification function, and then performing a reduction operation on the values associated with a given key using the specified downstream Collector. The ConcurrentMap produced by the Collector is created with the supplied factory function.
public static <T> Collector<T,?,Map<Boolean,List<T>>> partitioningBy(Predicate<? super T> predicate)	It returns a Collector which partitions the input elements according to a Predicate, and organizes them into a Map<Boolean, List<T>>. There are no guarantees on the type, mutability, serializability, or thread-safety of the Map returned.
public static <T,D,A> Collector<T,?,Map<Boolean,D>> partitioningBy(Predicate<? super T> predicate, Collector<? Super T,A,D> downstream)	It returns a Collector which partitions the input elements according to a Predicate, reduces the values in each partition according to another Collector, and organizes them into a Map<Boolean, D> whose values are the result of the downstream reduction.
public static <T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)	It returns a Collector that accumulates elements into a Map whose keys and values are the result of applying the provided mapping functions to the input elements.
public static <T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)	It returns a Collector that accumulates elements into a Map whose keys and values are the result of applying the provided mapping functions to the input elements.
public static <T,K,U,M extends Map<K,U>> Collector<T,?,M> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)	It returns a Collector that accumulates elements into a Map whose keys and values are the result of applying the provided mapping functions to the input elements.
public static <T,K,U> Collector<T,?,ConcurrentMap<K,U>> toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)	It returns a concurrent Collector that accumulates elements into a ConcurrentMap whose keys and values are the result of applying the provided mapping functions to the input elements.
public static <T,K,U> Collector<T,?,ConcurrentMap<K,U>> toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)	It returns a concurrent Collector that accumulates elements into a ConcurrentMap whose keys and values are the result of applying the provided mapping functions to the input elements.
public static <T,K,U,M extends ConcurrentMap<K,U>> Collector<T,?,M> toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)	It returns a concurrent Collector that accumulates elements into a ConcurrentMap whose keys and values are the result of applying the provided mapping functions to the input elements.
public static <T> Collector<T,?,IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper)	It returns a Collector which applies an int-producing mapping function to each input element, and returns summary statistics for the resulting values.
public static <T> Collector<T,?,LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper)	It returns a Collector which applies an long-producing mapping function to each input element, and returns summary statistics for the resulting values.
public static <T> Collector<T,?,DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper)	It returns a Collector which applies an double-producing mapping function to each input element, and returns summary statistics for the resulting values.

Java Collectors Example: Fetching data as a List

1. import java.util.stream.Collectors; 
2. import java.util.List; 
3. import java.util.ArrayList; 
4. class Product{ 
5. int id; 
6. String name; 
7. float price; 
8. 
9. public Product(int id, String name, float price) { 
10. this.id = id; 
11. this.name = name; 
12. this.price = price; 
13. } 
14. } 
15. public class CollectorsExample { 
16. public static void main(String[] args) { 
17. List<Product> productsList = new ArrayList<Product>(); 
18. //Adding Products 
19. productsList.add(new Product(1,"HP Laptop",25000f)); 
20. productsList.add(new Product(2,"Dell Laptop",30000f)); 
21. productsList.add(new Product(3,"Lenevo Laptop",28000f)); 
22. productsList.add(new Product(4,"Sony Laptop",28000f)); 
23. productsList.add(new Product(5,"Apple Laptop",90000f)); 
24. List<Float> productPriceList = 
25. productsList.stream() 
26. .map(x->x.price) // fetching price 
27. .collect(Collectors.toList()); // collecting as list 
28. System.out.println(productPriceList); 
29. } 
30. }

Output:
[25000.0, 30000.0, 28000.0, 28000.0, 90000.0]

Java Collectors Example: Converting Data as a Set

1. import java.util.stream.Collectors; 
2. import java.util.Set; 
3. import java.util.List; 
4. import java.util.ArrayList; 
5. classProduct{ 
6. intid; 
7. String name; 
8. floatprice; 
9. 
10. public Product(intid, String name, floatprice) { 
11. this.id = id; 
12. this.name = name; 
13. this.price = price; 
14. } 
15. } 
16. publicclass CollectorsExample { 
17. publicstaticvoid main(String[] args) { 
18. List<Product>productsList = new ArrayList<Product>(); 
19. //Adding Products 
20. productsList.add(newProduct(1,"HP Laptop",25000f)); 
21. productsList.add(newProduct(2,"Dell Laptop",30000f)); 
22. productsList.add(newProduct(3,"Lenevo Laptop",28000f)); 
23. productsList.add(newProduct(4,"Sony Laptop",28000f)); 
24. productsList.add(newProduct(5,"Apple Laptop",90000f)); 
25. Set<Float>productPriceList = 
26. productsList.stream() 
27. .map(x->x.price) // fetching price 
28. .collect(Collectors.toSet()); // collecting as list 
29. System.out.println(productPriceList); 
30. } 
31. }

Output:
[25000.0, 30000.0, 28000.0, 90000.0]

Java Collectors Example: using sum method

1. import java.util.stream.Collectors; 
2. import java.util.List; 
3. import java.util.ArrayList; 
4. class Product{ 
5. int id; 
6. String name; 
7. float price; 
8. 
9. public Product(int id, String name, float price) { 
10. this.id = id; 
11. this.name = name; 
12. this.price = price; 
13. } 
14. } 
15. public class CollectorsExample { 
16. public static void main(String[] args) { 
17. List<Product> productsList = new ArrayList<Product>(); 
18. //Adding Products 
19. productsList.add(new Product(1,"HP Laptop",25000f)); 
20. productsList.add(new Product(2,"Dell Laptop",30000f)); 
21. productsList.add(new Product(3,"Lenevo Laptop",28000f)); 
22. productsList.add(new Product(4,"Sony Laptop",28000f)); 
23. productsList.add(new Product(5,"Apple Laptop",90000f)); 
24. Double sumPrices = 
25. productsList.stream() 
26. .collect(Collectors.summingDouble(x->x.price)); // collecting as list 
27. System.out.println("Sum of prices: "+sumPrices); 
28. Integer sumId = 
29. productsList.stream().collect(Collectors.summingInt(x->x.id)); 
30. System.out.println("Sum of id's: "+sumId); 
31. } 

32. }

Output:
Sum of prices: 201000.0
Sum of id’s: 15

Java Collectors Example: Getting Product Average Price

1. import java.util.stream.Collectors; 
2. import java.util.List; 
3. import java.util.ArrayList; 
4. class Product{ 
5. int id; 
6. String name; 
7. float price; 
8. 
9. public Product(int id, String name, float price) { 
10. this.id = id; 
11. this.name = name; 
12. this.price = price; 
13. } 
14. } 
15. public class CollectorsExample { 
16. public static void main(String[] args) { 
17. List<Product> productsList = new ArrayList<Product>(); 
18. //Adding Products 
19. productsList.add(new Product(1,"HP Laptop",25000f)); 
20. productsList.add(new Product(2,"Dell Laptop",30000f)); 
21. productsList.add(new Product(3,"Lenevo Laptop",28000f)); 
22. productsList.add(new Product(4,"Sony Laptop",28000f)); 
23. productsList.add(new Product(5,"Apple Laptop",90000f)); 
24. Double average = productsList.stream() 
25. .collect(Collectors.averagingDouble(p->p.price)); 
26. System.out.println("Average price is: "+average); 
27. } 
28. }

Output:
Average price is: 40200.0

Java Collectors Example: Counting Elements

1. import java.util.stream.Collectors; 
2. import java.util.List; 
3. import java.util.ArrayList; 
4. class Product{ 
5. intid; 
6. String name; 
7. floatprice; 
8. 
9. public Product(intid, String name, floatprice) { 
10. this.id = id; 
11. this.name = name; 
12. this.price = price; 
13. } 
14. publicint getId() { 
15. returnid; 
16. } 
17. public String getName() { 
18. returnname; 
19. } 
20. publicfloat getPrice() { 
21. returnprice; 
22. } 
23. } 
24. publicclass CollectorsExample { 
25. publicstaticvoid main(String[] args) { 
26. List<Product>productsList = new ArrayList<Product>(); 
27. //Adding Products 
28. productsList.add(new Product(1,"HP Laptop",25000f)); 
29. productsList.add(new Product(2,"Dell Laptop",30000f)); 
30. productsList.add(new Product(3,"Lenevo Laptop",28000f)); 
31. productsList.add(new Product(4,"Sony Laptop",28000f)); 
32. productsList.add(new Product(5,"Apple Laptop",90000f)); 
33. Long noOfElements = productsList.stream() 
34. .collect(Collectors.counting()); 
35. System.out.println("Total elements : "+noOfElements); 
36. } 
37. }

Output:
Total elements : 5

So, this brings us to the end of blog. This Tecklearn ‘Java forEach loop and Collectors’ blog helps you with commonly asked questions if you are looking out for a job in Java Programming. If you wish to learn Java and build a career Java Programming domain, then check out our interactive, Java and JEE Training, that comes with 24*7 support to guide you throughout your learning period. Please find the link for course details:

Java and JEE Training

Java and JEE Training

About the Course

Java and JEE Certification Training is designed by professionals as per the industrial requirements and demands. This training encompasses comprehensive knowledge on basic and advanced concepts of core Java & J2EE along with popular frameworks like Hibernate, Spring & SOA. In this course, you will gain expertise in concepts like Java Array, Java OOPs, Java Function, Java Loops, Java Collections, Java Thread, Java Servlet, and Web Services using industry use-cases and this will help you to become a certified Java expert.

Why Should you take Java and JEE Training?

• Java developers are in great demand in the job market. With average pay going between $90,000/- to $120,000/- depending on your experience and the employers.
• Used by more than 10 Million developers worldwide to develop applications for 15 Billion devices.
• Java is one of the most popular programming languages in the software world. Rated #1 in TIOBE Popular programming languages index (15th Consecutive Year)

What you will Learn in this Course?

Introduction to Java

• Java Fundamentals
• Introduction to Java Basics
• Features of Java
• Various components of Java language
• Benefits of Java over other programming languages
• Key Benefits of Java

Installation and IDE’s for Java Programming Language

• Installation of Java
• Setting up of Eclipse IDE
• Components of Java Program
• Editors and IDEs used for Java Programming
• Writing a Simple Java Program

Data Handling and Functions

• Data types, Operations, Compilation process, Class files, Loops, Conditions
• Using Loop Constructs
• Arrays- Single Dimensional and Multi-Dimensional
• Functions
• Functions with Arguments

OOPS in Java: Concept of Object Orientation

• Object Oriented Programming in Java
• Implement classes and objects in Java
• Create Class Constructors
• Overload Constructors
• Inheritance
• Inherit Classes and create sub-classes
• Implement abstract classes and methods
• Use static keyword
• Implement Interfaces and use it

Polymorphism, Packages and String Handling

• Concept of Static and Run time Polymorphism
• Function Overloading
• String Handling –String Class
• Java Packages

Exception Handling and Multi-Threading

• Exception handling
• Various Types of Exception Handling
• Introduction to multi-threading in Java
• Extending the thread class
• Synchronizing the thread

File Handling in Java

• Input Output Streams
• Java.io Package
• File Handling in Java

Java Collections

• Wrapper Classes and Inner Classes: Integer, Character, Boolean, Float etc
• Applet Programs: How to write UI programs with Applet, Java.lang, Java.io, Java.util
• Collections: ArrayList, Vector, HashSet, TreeSet, HashMap, HashTable

Java Database Connectivity (JDBC)

• Introduction to SQL: Connect, Insert, Update, Delete, Select
• Introduction to JDBC and Architecture of JDBC
• Insert/Update/Delete/Select Operations using JDBC
• Batch Processing Transaction
• Management: Commit and Rollback

Java Enterprise Edition – Servlets

• Introduction to J2EE
• Client Server architecture
• URL, Port Number, Request, Response
• Need for servlets
• Servlet fundamentals
• Setting up a web project in Eclipse
• Configuring and running the web app with servlets
• GET and POST request in web application with demo
• Servlet lifecycle
• Servlets Continued
• Session tracking and filter
• Forward and include Servlet request dispatchers

Java Server Pages (JSP)

• Fundamentals of Java Server Page
• Writing a code using JSP
• The architecture of JSP
• JSP Continued
• JSP elements: Scriptlets, expressions, declaration
• JSP standard actions
• JSP directives
• Introduction to JavaBeans
• ServletConfig and ServletContext
• Servlet Chaining
• Cookies Management
• Session Management

Hibernate

• Introduction to Hibernate
• Introduction to ORM
• ORM features
• Hibernate as an ORM framework
• Hibernate features
• Setting up a project with Hibernate framework
• Basic APIs needed to do CRUD operations with Hibernate
• Hibernate Architecture

POJO (Plain Old Java Object)

• POJO (Plain Old Java Object)
• Persistent Objects
• Lifecycle of Persistent Object

Spring

• Introduction to Spring
• Spring Fundamentals
• Advanced Spring

Got a question for us? Please mention it in the comments section and we will get back to you.

448