Java 8 Collectors Examples
November 28, 2014
java.util.stream.Collectors is a java 8 class that implements the java.util.stream.Collector interface. Collectors has various methods to reduce and summarize elements of stream. Here we will discuss most of the methods and examples of Collectors class.
Collectors.averagingDouble
Collectors.averagingDouble calculates the average of stream element as double data type. It returns a Collector instance. The collect method of stream can accept the collector instance and will return the average value calculated by Collectors.averagingDouble.AveragingDoubleExample.java
package com.concretepage.util.stream; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class AveragingDoubleExample { public static void main(String[] args) { List<Integer> list = Arrays.asList(1,2,3,4); Double result = list.stream().collect(Collectors.averagingDouble(d->d*2)); System.out.println(result); } }
Collectors.averagingInt
Collectors.averagingInt calculates average of stream element as integer data type.AveragingIntExample.java
package com.concretepage.util.stream; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class AveragingIntExample { public static void main(String[] args) { List<Integer> list = Arrays.asList(1,2,3,4); Double result = list.stream().collect(Collectors.averagingInt(v->v*2)); System.out.println(result); } }
Collectors.averagingLong
Collectors.averagingLong calculates the average of stream element as long data type.AveragingLongExample.java
package com.concretepage.util.stream; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class AveragingLongExample { public static void main(String[] args) { List<Integer> list = Arrays.asList(1,2,3,4); Double result = list.stream().collect(Collectors.averagingLong(v->v*2)); System.out.println(result); } }
Collectors.collectingAndThen
Collectors.collectingAndThen accepts a collection and a function. In our example first we are calculating average by a calculator and then multiplying to itself by a function.CollectingAndThenExample.java
package com.concretepage.util.stream; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class CollectingAndThenExample { public static void main(String[] args) { List<Integer> list = Arrays.asList(1,2,3,4); Double result = list.stream().collect(Collectors.collectingAndThen(Collectors.averagingLong(v->v*2), s-> s*s)); System.out.println(result); } }
Collectors.counting
Collectors.counting counts the element in the stream.CountingExample.java
package com.concretepage.util.stream; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class CountingExample { public static void main(String[] args) { List<Integer> list = Arrays.asList(1,2,3,4); long result= list.stream().collect(Collectors.counting()); System.out.println(result); } }
Collectors.joining
Collectors.joining joins the stream elements for a given delimiter, prefix and suffix.JoiningExample.java
package com.concretepage.util.stream; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class JoiningExample { public static void main(String[] args) { List<String> list = Arrays.asList("A","B","C","D"); String result= list.stream().collect(Collectors.joining(",","(",")")); System.out.println(result); } }
Collectors.maxBy and Collectors.minBy
Collectors.maxBy collects maximum element in stream for a given comparator. Collectors.minBy collects minimum element of a stream for a given comparator.MaxByMinByExample.java
package com.concretepage.util.stream; import java.util.Arrays; import java.util.Comparator; import java.util.List; import java.util.stream.Collectors; public class MaxByMinByExample { public static void main(String[] args) { List<Integer> list = Arrays.asList(30,10,20,35); //Get Max list.stream().collect(Collectors.maxBy(new MaxByMinByExample().new IntegerComp())) .ifPresent(i->System.out.println(i)); //Get Min list.stream().collect(Collectors.minBy(new MaxByMinByExample().new IntegerComp())) .ifPresent(i->System.out.println(i)); } class IntegerComp implements Comparator<Integer> { @Override public int compare(Integer i1, Integer i2) { if(i1 >=i2 ){ return 1; }else{ return -1; } } } }
35 10
Collectors.summingInt
Collectors.summingInt adds all element of stream for integer data type.SummingIntExample.java
package com.concretepage.util.stream; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class SummingIntExample { public static void main(String[] args) { List<Integer> list = Arrays.asList(30,10,20,35); int result = list.stream().collect(Collectors.summingInt(i->i)); System.out.println(result); } }
Collectors.summingLong
Collectors.summingLong adds all element of stream for long data type.SummingLongExample.java
package com.concretepage.util.stream; import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; public class SummingLongExample { public static void main(String[] args) { List<Long> list = new ArrayList<>(); list.add((long)340); list.add((long)240); list.add((long)360); long result = list.stream().collect(Collectors.summingLong(l->l)); System.out.println(result); } }
Collectors.summingDouble
Collectors.summingDouble adds all element of stream for double data type.SummingDoubleExample.java
package com.concretepage.util.stream; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class SummingDoubleExample { public static void main(String[] args) { List<Double> list = Arrays.asList(340.5,234.56,672.76); Double result = list.stream().collect(Collectors.summingDouble(d->d)); System.out.println(result); } }
Collectors.toList
Collectors.toList collects the stream data as List for the given data type.ToListExample.java
package com.concretepage.util.stream; import java.util.List; import java.util.stream.Collectors; import java.util.stream.Stream; public class ToListExample { public static void main(String[] args) { List<String> list = Stream.of("AA","BB","CC").collect(Collectors.toList()); list.forEach(s->System.out.println(s)); } }
AA BB CC
Collectors.toSet
Collectors.toSet collects the element as set for the given data type.ToSetExample.java
package com.concretepage.util.stream; import java.util.Set; import java.util.stream.Collectors; import java.util.stream.Stream; public class ToSetExample { public static void main(String[] args) { Set<String> set = Stream.of("AA","AA","BB").collect(Collectors.toSet()); set.forEach(s->System.out.println(s)); } }
AA BB
Collectors.toMap
Collectors.toMap collects the stream element as Map. We need to define function to generate key and value for stream input value.ToMapExample.java
package com.concretepage.util.stream; import java.util.Map; import java.util.stream.Collectors; import java.util.stream.Stream; public class ToMapExample { public static void main(String[] args) { Map<String,String> map = Stream.of("AA","BB","CC").collect(Collectors.toMap(k->k, v->v+v)); map.forEach((k,v)->System.out.println("key:"+k +" value:"+v)); } }
key:CC value:CCCC key:BB value:BBBB key:AA value:AAAA
Collectors.mapping
Java doc declaresmapping()
as below.
mapping(Function<? super T,? extends U> mapper, Collector<? super U,A,R> downstream)
Function
and Collector
and the method will return Collector
instance. mapping()
is used in multi-level reduction. Find the example.
MappingDemo.java
package com.concretepage; import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.stream.Collectors; public class MappingDemo { public static void main(String[] args) { List<Person> list = Person.getList(); Map<Integer, String> nameByAge = list.stream().collect(Collectors.groupingBy(Person::getAge, Collectors.mapping(Person::getName, Collectors.joining(",")))); nameByAge.forEach((k,v)->System.out.println("Age:"+k +" Persons: "+v)); } } class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } public static List<Person> getList() { List<Person> list = new ArrayList<>(); list.add(new Person("Ram", 30)); list.add(new Person("Shyam", 20)); list.add(new Person("Shiv", 20)); list.add(new Person("Mahesh", 30)); return list; } }
Age:20 Persons: Shyam,Shiv Age:30 Persons: Ram,Mahesh