Raggruppa per più nomi di campo in java 8

95

Ho trovato il codice per raggruppare gli oggetti in base a un nome di campo da POJO. Di seguito è riportato il codice per questo:

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("Person{name='%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);
    }
}

E l'output è (che è corretto):

{24=[Person{name='Paul', age=24, salary=20000}], 28=[Person{name='Will', age=28, salary=28000}, Person{name='William', age=28, salary=28000}], 30=[Person{name='Mark', age=30, salary=30000}]}

Ma cosa succede se voglio raggruppare per più campi? Ovviamente posso passare un po 'di POJO nel groupingBy()metodo dopo aver implementato il equals()metodo in quel POJO ma c'è qualche altra opzione come posso raggruppare per più di un campo dal POJO dato?

Ad esempio, qui nel mio caso, voglio raggruppare per nome ed età.

java  java-8 
— Mital Pritmani
fonte
1
Un trucco è generare solo una stringa univoca da tutti i campi.
— Marko Topolnik
3
BTW mappingcome raccoglitore a valle è ridondante nel codice che hai pubblicato.
— Marko Topolnik
8
La soluzione rapida e sporca è people.collect(groupingBy(p -> Arrays.asList(p.name, p.age))).
— Misha

Risposte:

170

Hai alcune opzioni qui. Il più semplice è incatenare i tuoi collezionisti:

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

Quindi per ottenere un elenco di persone di 18 anni di nome Fred dovresti usare:

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

Una seconda opzione è definire una classe che rappresenti il ​​raggruppamento. Questo può essere all'interno di Persona. Questo codice utilizza un recordma potrebbe essere altrettanto facilmente una classe (con equalse hashCodedefinita) nelle versioni di Java prima dell'aggiunta di JEP 359:

class Person {
    record NameAge(String name, int age) { }

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

Quindi puoi usare:

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

e cerca con

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

Infine, se non vuoi implementare il tuo record di gruppo, molti dei framework Java in giro hanno una pairclasse progettata per questo tipo di cose. Ad esempio: apache commons pair Se usi una di queste librerie, puoi rendere la chiave della mappa una coppia del nome e dell'età:

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

e recupera con:

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

Personalmente non vedo molto valore nelle tuple generiche ora che i record sono disponibili nella lingua poiché i record mostrano meglio l'intento e richiedono pochissimo codice.

— velocista
fonte
5
Function<T,U>nasconde anche gli intenti in questo senso --- ma non vedrai nessuno dichiarare la propria interfaccia funzionale per ogni passaggio di mappatura; l'intento è già presente nel corpo lambda. Lo stesso con le tuple: sono ottimi come tipi di colla tra i componenti API. Le classi di casi di BTW Scala sono IMHO una grande vittoria in termini sia di concisione che di esposizione degli intenti.
— Marko Topolnik
1
Sì, capisco il tuo punto. Immagino (come sempre) dipenda da come vengono utilizzati. L'esempio che ho fornito sopra - usando una coppia come chiave di una mappa - è un buon esempio di come non farlo. Non ho molta familiarità con Scala - dovrò iniziare ad impararlo quando sentirò cose buone.
— velocista
1
Provate a immaginare di essere in grado di dichiarare NameAgecome un one-liner: case class NameAge { val name: String; val age: Int }--- e si ottiene equals, hashCodee toString!
— Marko Topolnik
1
Bello: un altro elemento inserito nella mia coda "da fare". Purtroppo è FIFO!
— velocista
@sprinter Il tipo nel primo snippet di codice non è corretto e dovrebbe essere cambiato inMap<String, Map<Integer, List<Person>>> map
— kasur
39

Qui guarda il codice:

Puoi semplicemente creare una Funzione e lasciare che faccia il lavoro per te, una specie di Stile funzionale!

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

Ora puoi usarlo come mappa:

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

Saluti!

— Deepesh Rehi
fonte
2
Ho usato questa soluzione ma diversa. Funzione <Person, String> compositeKey = personRecord -> StringUtils.join (personRecord.getName (), personRecord.getAge ());
— bpedroso
8

Il groupingBymetodo ha il primo parametro Function<T,K>dove:

@param <T>il tipo di elementi di input

@param <K>il tipo di chiavi

Se sostituiamo lambda con la classe anonima nel tuo codice, possiamo vedere una sorta di questo:

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

Solo ora cambia il parametro di output <K>. In questo caso, ad esempio, ho usato una classe di coppia da org.apache.commons.lang3.tuple per raggruppare per nome ed età, ma puoi creare la tua classe per filtrare i gruppi di cui hai bisogno.

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

Infine, dopo aver sostituito con lambda back, il codice ha questo aspetto:

Map<Pair<Integer,String>, List<Person>> peopleByAgeAndName = people.collect(Collectors.groupingBy(p -> Pair.of(person.getAge(), person.getName()), Collectors.mapping((Person p) -> p, toList())));
— Andrei Smirnov
fonte
Che ne dici dell'utilizzo List<String>?
— Alex78191
7

Ciao Puoi semplicemente concatenare il tuo groupingByKeycome

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();
}
— Amandeep
fonte
2

Definisci una classe per la definizione della chiave nel tuo gruppo.

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

}

Ora nel tuo codice

peopleByManyParams = people
            .collect(Collectors.groupingBy(p -> new KeyObj( p.age, p.other1, p.other2 ), Collectors.mapping((Person p) -> p, toList())));
— sarveshseri
fonte
3
Questo è solo reinventare Ararys.asList()--- che è comunque un'ottima scelta per il caso di OP.
— Marko Topolnik
E anche simile Pairall'esempio menzionato nell'altro esempio, ma senza limite di argomenti.
— Benny Bottema
Inoltre è necessario renderlo immutabile. (e calcola il hashCode) una volta)
— RobAu
2

Puoi utilizzare List come classificatore per molti campi, ma devi racchiudere valori null in Opzionale: 

Function<String, List> classifier = (item) -> List.of(
    item.getFieldA(),
    item.getFieldB(),
    Optional.ofNullable(item.getFieldC())
);

Map<List, List<Item>> grouped = items.stream()
    .collect(Collectors.groupingBy(classifier));
— vinga
fonte
1

Avevo bisogno di fare un rapporto per un'azienda di catering che serve pranzi per vari clienti. In altre parole, il catering può avere su o più aziende che prendono ordini dal catering, e deve sapere quanti pranzi deve produrre ogni giorno per tutti i suoi clienti!

Solo per notare, non ho usato l'ordinamento, per non complicare eccessivamente questo esempio.

Questo è il mio codice: 

@Test
public void test_2() throws Exception {
    Firm catering = DS.firm().get(1);
    LocalDateTime ldtFrom = LocalDateTime.of(2017, Month.JANUARY, 1, 0, 0);
    LocalDateTime ldtTo = LocalDateTime.of(2017, Month.MAY, 2, 0, 0);
    Date dFrom = Date.from(ldtFrom.atZone(ZoneId.systemDefault()).toInstant());
    Date dTo = Date.from(ldtTo.atZone(ZoneId.systemDefault()).toInstant());

    List<PersonOrders> LON = DS.firm().getAllOrders(catering, dFrom, dTo, false);
    Map<Object, Long> M = LON.stream().collect(
            Collectors.groupingBy(p
                    -> Arrays.asList(p.getDatum(), p.getPerson().getIdfirm(), p.getIdProduct()),
                    Collectors.counting()));

    for (Map.Entry<Object, Long> e : M.entrySet()) {
        Object key = e.getKey();
        Long value = e.getValue();
        System.err.println(String.format("Client firm :%s, total: %d", key, value));
    }
}
— dobrivoje
fonte
0

È così che ho raggruppato per più campi branchCode e prdId, semplicemente pubblicandolo per qualcuno nel bisogno

    import java.math.BigDecimal;
    import java.math.BigInteger;
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Map;
    import java.util.stream.Collectors;

    /**
     *
     * @author charudatta.joshi
     */
    public class Product1 {

        public BigInteger branchCode;
        public BigInteger prdId;
        public String accountCode;
        public BigDecimal actualBalance;
        public BigDecimal sumActBal;
        public BigInteger countOfAccts;

        public Product1() {
        }

        public Product1(BigInteger branchCode, BigInteger prdId, String accountCode, BigDecimal actualBalance) {
            this.branchCode = branchCode;
            this.prdId = prdId;
            this.accountCode = accountCode;
            this.actualBalance = actualBalance;
        }

        public BigInteger getCountOfAccts() {
            return countOfAccts;
        }

        public void setCountOfAccts(BigInteger countOfAccts) {
            this.countOfAccts = countOfAccts;
        }

        public BigDecimal getSumActBal() {
            return sumActBal;
        }

        public void setSumActBal(BigDecimal sumActBal) {
            this.sumActBal = sumActBal;
        }

        public BigInteger getBranchCode() {
            return branchCode;
        }

        public void setBranchCode(BigInteger branchCode) {
            this.branchCode = branchCode;
        }

        public BigInteger getPrdId() {
            return prdId;
        }

        public void setPrdId(BigInteger prdId) {
            this.prdId = prdId;
        }

        public String getAccountCode() {
            return accountCode;
        }

        public void setAccountCode(String accountCode) {
            this.accountCode = accountCode;
        }

        public BigDecimal getActualBalance() {
            return actualBalance;
        }

        public void setActualBalance(BigDecimal actualBalance) {
            this.actualBalance = actualBalance;
        }

        @Override
        public String toString() {
            return "Product{" + "branchCode:" + branchCode + ", prdId:" + prdId + ", accountCode:" + accountCode + ", actualBalance:" + actualBalance + ", sumActBal:" + sumActBal + ", countOfAccts:" + countOfAccts + '}';
        }

        public static void main(String[] args) {
            List<Product1> al = new ArrayList<Product1>();
            System.out.println(al);
            al.add(new Product1(new BigInteger("01"), new BigInteger("11"), "001", new BigDecimal("10")));
            al.add(new Product1(new BigInteger("01"), new BigInteger("11"), "002", new BigDecimal("10")));
            al.add(new Product1(new BigInteger("01"), new BigInteger("12"), "003", new BigDecimal("10")));
            al.add(new Product1(new BigInteger("01"), new BigInteger("12"), "004", new BigDecimal("10")));
            al.add(new Product1(new BigInteger("01"), new BigInteger("12"), "005", new BigDecimal("10")));
            al.add(new Product1(new BigInteger("01"), new BigInteger("13"), "006", new BigDecimal("10")));
            al.add(new Product1(new BigInteger("02"), new BigInteger("11"), "007", new BigDecimal("10")));
            al.add(new Product1(new BigInteger("02"), new BigInteger("11"), "008", new BigDecimal("10")));
            al.add(new Product1(new BigInteger("02"), new BigInteger("12"), "009", new BigDecimal("10")));
            al.add(new Product1(new BigInteger("02"), new BigInteger("12"), "010", new BigDecimal("10")));
            al.add(new Product1(new BigInteger("02"), new BigInteger("12"), "011", new BigDecimal("10")));
            al.add(new Product1(new BigInteger("02"), new BigInteger("13"), "012", new BigDecimal("10")));
            //Map<BigInteger, Long> counting = al.stream().collect(Collectors.groupingBy(Product1::getBranchCode, Collectors.counting()));
            // System.out.println(counting);

            //group by branch code
            Map<BigInteger, List<Product1>> groupByBrCd = al.stream().collect(Collectors.groupingBy(Product1::getBranchCode, Collectors.toList()));
            System.out.println("\n\n\n" + groupByBrCd);

             Map<BigInteger, List<Product1>> groupByPrId = null;
              // Create a final List to show for output containing one element of each group
            List<Product> finalOutputList = new LinkedList<Product>();
            Product newPrd = null;
            // Iterate over resultant  Map Of List
            Iterator<BigInteger> brItr = groupByBrCd.keySet().iterator();
            Iterator<BigInteger> prdidItr = null;    



            BigInteger brCode = null;
            BigInteger prdId = null;

            Map<BigInteger, List<Product>> tempMap = null;
            List<Product1> accListPerBr = null;
            List<Product1> accListPerBrPerPrd = null;

            Product1 tempPrd = null;
            Double sum = null;
            while (brItr.hasNext()) {
                brCode = brItr.next();
                //get  list per branch
                accListPerBr = groupByBrCd.get(brCode);

                // group by br wise product wise
                groupByPrId=accListPerBr.stream().collect(Collectors.groupingBy(Product1::getPrdId, Collectors.toList()));

                System.out.println("====================");
                System.out.println(groupByPrId);

                prdidItr = groupByPrId.keySet().iterator();
                while(prdidItr.hasNext()){
                    prdId=prdidItr.next();
                    // get list per brcode+product code
                    accListPerBrPerPrd=groupByPrId.get(prdId);
                    newPrd = new Product();
                     // Extract zeroth element to put in Output List to represent this group
                    tempPrd = accListPerBrPerPrd.get(0);
                    newPrd.setBranchCode(tempPrd.getBranchCode());
                    newPrd.setPrdId(tempPrd.getPrdId());

                    //Set accCOunt by using size of list of our group
                    newPrd.setCountOfAccts(BigInteger.valueOf(accListPerBrPerPrd.size()));
                    //Sum actual balance of our  of list of our group 
                    sum = accListPerBrPerPrd.stream().filter(o -> o.getActualBalance() != null).mapToDouble(o -> o.getActualBalance().doubleValue()).sum();
                    newPrd.setSumActBal(BigDecimal.valueOf(sum));
                    // Add product element in final output list

                    finalOutputList.add(newPrd);

                }

            }

            System.out.println("+++++++++++++++++++++++");
            System.out.println(finalOutputList);

        }
    }

L'output è il seguente:

+++++++++++++++++++++++
[Product{branchCode:1, prdId:11, accountCode:null, actualBalance:null, sumActBal:20.0, countOfAccts:2}, Product{branchCode:1, prdId:12, accountCode:null, actualBalance:null, sumActBal:30.0, countOfAccts:3}, Product{branchCode:1, prdId:13, accountCode:null, actualBalance:null, sumActBal:10.0, countOfAccts:1}, Product{branchCode:2, prdId:11, accountCode:null, actualBalance:null, sumActBal:20.0, countOfAccts:2}, Product{branchCode:2, prdId:12, accountCode:null, actualBalance:null, sumActBal:30.0, countOfAccts:3}, Product{branchCode:2, prdId:13, accountCode:null, actualBalance:null, sumActBal:10.0, countOfAccts:1}]

Dopo averlo formattato:

[
Product{branchCode:1, prdId:11, accountCode:null, actualBalance:null, sumActBal:20.0, countOfAccts:2}, 
Product{branchCode:1, prdId:12, accountCode:null, actualBalance:null, sumActBal:30.0, countOfAccts:3}, 
Product{branchCode:1, prdId:13, accountCode:null, actualBalance:null, sumActBal:10.0, countOfAccts:1}, 
Product{branchCode:2, prdId:11, accountCode:null, actualBalance:null, sumActBal:20.0, countOfAccts:2}, 
Product{branchCode:2, prdId:12, accountCode:null, actualBalance:null, sumActBal:30.0, countOfAccts:3}, 
Product{branchCode:2, prdId:13, accountCode:null, actualBalance:null, sumActBal:10.0, countOfAccts:1}
]
— Charudatta Joshi
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.