Styjun

I found the code for grouping the objects by some field name from POJO. Below is the code for that:

public class Temp 

 static class Person 

 private String name;
 private int age;
 private long salary;

 Person(String name, int age, long salary) 

 this.name = name;
 this.age = age;
 this.salary = salary;
 

 @Override
 public String toString() 
 return String.format("Personname='%s', age=%d, salary=%d", name, age, salary);
 
 

 public static void main(String[] args) 
 Stream<Person> people = Stream.of(new Person("Paul", 24, 20000),
 new Person("Mark", 30, 30000),
 new Person("Will", 28, 28000),
 new Person("William", 28, 28000));
 Map<Integer, List<Person>> peopleByAge;
 peopleByAge = people
 .collect(Collectors.groupingBy(p -> p.age, Collectors.mapping((Person p) -> p, toList())));
 System.out.println(peopleByAge);
 

And the output is (which is correct):

24=[Personname='Paul', age=24, salary=20000], 28=[Personname='Will', age=28, salary=28000, Personname='William', age=28, salary=28000], 30=[Personname='Mark', age=30, salary=30000]

But what if I want to group by multiple fields? I can obviously pass some POJO in groupingBy() method after implementing equals() method in that POJO but is there any other option like I can group by more than one fields from the given POJO?

E.g. here in my case, I want to group by name and age.

You have a few options here. The simplest is to chain your collectors:

Map<String, Map<Integer, List<Person>>> map = people
 .collect(Collectors.groupingBy(Person::getName,
 Collectors.groupingBy(Person::getAge));

Then to get a list of 18 year old people called Fred you would use:

map.get("Fred").get(18);

A second option is to define a class that represents the grouping. This can be inside Person:

class Person 
 public static class NameAge 
 public NameAge(String name, int age) 
 ...
 

 // must implement equals and hash function
 

 public NameAge getNameAge() 
 return new NameAge(name, age);
 

Then you can use:

Map<NameAge, List<Person>> map = people.collect(Collectors.groupingBy(Person::getNameAge));

and search with

map.get(new NameAge("Fred", 18));

Finally if you don't want to implement your own group class then many of the Java frameworks around have a pair class designed for exactly this type of thing. For example: apache commons pair If you use one of these libraries then you can make the key to the map a pair of the name and age:

Map<Pair<String, Integer>, List<Person>> map =
 people.collect(Collectors.groupingBy(p -> Pair.of(p.getName(), p.getAge())));

and retrieve with:

map.get(Pair.of("Fred", 18));

Personally I really dislike these tuple libraries. They seem to be the exact opposite of good OO design: they hide intent instead of exposing it.

Having said that you can combine the second two options by defining your own grouping class but implementing it by just extending Pair - that saves you a lot of the work involved in defining equals etc and hides the use of the tuple as just a convenient implementation detail like any other collection.

Good luck.

Here look at the code:

You can simply create a Function and let it do the work for you, kind of functional Style!

Function<Person, List<Object>> compositeKey = personRecord ->
 Arrays.<Object>asList(personRecord.getName(), personRecord.getAge());

Now you can use it as a map:

Map<Object, List<Person>> map =
people.collect(Collectors.groupingBy(compositeKey, Collectors.toList()));

Cheers!

Hi You can simply concatenate your groupingByKey such as

Map<String, List<Person>> peopleBySomeKey = people
 .collect(Collectors.groupingBy(p -> getGroupingByKey(p), Collectors.mapping((Person p) -> p, toList())));



//write getGroupingByKey() function
private String getGroupingByKey(Person p)
return p.getAge()+"-"+p.getName();

The groupingBy method has the first parameter is Function<T,K> where:

@param <T> the type of the input elements

@param <K> the type of the keys

If we replace lambda with the anonymous class in your code, we can see some kind of that:

people.stream().collect(Collectors.groupingBy(new Function<Person, int>() 
 @Override
 public int apply(Person person) 
 return person.getAge();
 
 ));

Just now change output parameter<K>. In this case, for example, I used a pair class from org.apache.commons.lang3.tuple for grouping by name and age, but you may create your own class for filtering groups as you need.

people.stream().collect(Collectors.groupingBy(new Function<Person, Pair<Integer, String>>() 
 @Override
 public YourFilter apply(Person person) 
 return Pair.of(person.getAge(), person.getName());
 
 ));

Finally, after replacing with lambda back, code looks like that:

Map<Pair<Integer,String>, List<Person>> peopleByAgeAndName = people.collect(Collectors.groupingBy(p -> Pair.of(person.getAge(), person.getName()), Collectors.mapping((Person p) -> p, toList())));

Define a class for key definition in your group.

class KeyObj 

 ArrayList<Object> keys;

 public KeyObj( Object... objs ) 
 keys = new ArrayList<Object>();

 for (int i = 0; i < objs.length; i++) 
 keys.add( objs[i] );
 
 

 // Add appropriate isEqual() ... you IDE should generate this

Now in your code,

peopleByManyParams = people
 .collect(Collectors.groupingBy(p -> new KeyObj( p.age, p.other1, p.other2 ), Collectors.mapping((Person p) -> p, toList())));