Групувати за кількома назвами полів у Java 8

90

Я знайшов код для групування об’єктів за деяким іменем поля з POJO. Нижче наведено код для цього:

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);
    }
}

І результат (що правильно):

{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}]}

Але що, якщо я хочу згрупувати за кількома полями? Я, очевидно, можу передати деякий groupingBy()метод POJO в методі після реалізації equals()методу в цьому POJO, але чи існує якийсь інший варіант, наприклад, я можу згрупувати більше ніж одне поле з даного POJO?

Наприклад, у моєму випадку я хочу згрупувати за іменем та віком.

java  java-8 
— Мітал Притмані
джерело
1
Фокус полягає у простому створенні унікального рядка з усіх полів.
— Марко Топольник
3
До речі, mappingяк нижчий колектор є надлишковим у коді, який ви розмістили.
— Марко Топольник
8
Швидке і брудне рішення є people.collect(groupingBy(p -> Arrays.asList(p.name, p.age))).
— Міша

Відповіді:

163

Тут у вас є кілька варіантів. Найпростішим є зв’язування колекціонерів:

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

Тоді для отримання списку 18-річних людей під назвою Фред ви б використали:

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

Другий варіант - визначити клас, який представляє групування. Це може бути всередині Person. Цей код використовує, recordале він може так само легко бути класом (з equalsі hashCodeвизначеним) у версіях Java до того, як було додано JEP 359:

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

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

Тоді ви можете використовувати:

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

і шукайте за допомогою

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

Нарешті, якщо ви не хочете реалізовувати свій власний груповий запис, тоді у багатьох фреймворках Java є pairклас, розроблений для цього типу речей. Наприклад: спільна пара apache Якщо ви використовуєте одну з цих бібліотек, то можете зробити ключ до карти парою імені та віку:

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

і отримати за допомогою:

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

Особисто я насправді не бачу великої цінності в загальних кортежах зараз, коли записи доступні мовою, оскільки записи краще відображають намір і вимагають дуже мало коду.

— спринтер
джерело
5
Function<T,U>також приховує намір у цьому сенсі --- але ви не побачите, щоб хтось оголошував свій власний функціональний інтерфейс для кожного кроку зіставлення; намір вже є в лямбда-тілі. Те саме з кортежами: вони чудово підходять як типи клею між компонентами API. BTW Scala класи справи IMHO є великим виграшем як з точки зору стислості, так і наміру.
— Марко Топольник
1
Так, я бачу вашу думку. Думаю (як завжди) це залежить від того, як їх використовують. Приклад, який я навів вище - використання пари як ключа мапи - хороший приклад того, як цього не робити. Я не надто знайомий із Scala - мені доведеться починати її вивчати, коли я чую хороші речі.
— спринтер
1
Просто уявіть , що в змозі оголосити NameAgeяк однострочнікі: case class NameAge { val name: String; val age: Int }--- і ви отримаєте equals, hashCodeі toString!
— Марко Топольник
1
Хороший - ще один предмет, що потрапив до моєї черги “must do”. На жаль, це FIFO!
— спринтер
@sprinter Тип у першому фрагменті коду неправильний і його слід змінити наMap<String, Map<Integer, List<Person>>> map
— kasur
38

Ось подивіться на код:

Ви можете просто створити функцію і дозволити їй виконувати роботу за вас, якийсь функціональний стиль!

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

Тепер ви можете використовувати його як карту:

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

На здоров’я!

— Діпеш Рехі
джерело
2
Я використовував це рішення, але інше. Функція <Person, String> compositeKey = personRecord -> StringUtils.join (personRecord.getName (), personRecord.getAge ());
— bpedroso
8

groupingByМетод перший параметр , Function<T,K>де:

@param <T>тип вхідних елементів

@param <K>тип клавіш

Якщо замінити лямбду на анонімний клас у вашому коді, ми можемо побачити щось таке:

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

Просто змініть вихідний параметр <K>. У цьому випадку, наприклад, я використовував парний клас від org.apache.commons.lang3.tuple для групування за іменем та віком, але ви можете створити власний клас для фільтрації груп, як вам потрібно.

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

Нарешті, після заміни на lambda back код виглядає так:

Map<Pair<Integer,String>, List<Person>> peopleByAgeAndName = people.collect(Collectors.groupingBy(p -> Pair.of(person.getAge(), person.getName()), Collectors.mapping((Person p) -> p, toList())));
— Андрій Смирнов
джерело
А як щодо використання List<String>?
— Alex78191
6

Привіт, Ви можете просто об'єднати свої, groupingByKeyтакі як

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
джерело
2

Визначте клас для визначення ключів у своїй групі.

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

}

Тепер у вашому коді,

peopleByManyParams = people
            .collect(Collectors.groupingBy(p -> new KeyObj( p.age, p.other1, p.other2 ), Collectors.mapping((Person p) -> p, toList())));
— сарвешсері
джерело
3
Це просто винахід Ararys.asList()--- що, до речі, є чудовим вибором для випадку OP.
— Марко Топольник
А також подібний до Pairприкладу, згаданого в іншому прикладі, але без обмеження аргументів.
— Бенні Боттема
Також вам потрібно зробити це незмінним. (і обчислити hashCode) один раз)
— RobAu
2

Ви можете використовувати List як класифікатор для багатьох полів, але вам потрібно обернути нульові значення в необов’язкові: 

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));
— вінга
джерело
1

Мені потрібно було скласти звіт для фірми громадського харчування, яка обслуговує обіди для різних клієнтів. Іншими словами, організація громадського харчування може мати більше або більше фірм, які приймають замовлення від громадського харчування, і воно повинно знати, скільки обідів воно повинно виробляти щодня для всіх своїх клієнтів!

Тільки щоб зауважити, я не використовував сортування, щоб не надто ускладнювати цей приклад.

Це мій код: 

@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
джерело
0

Ось як я зробив групування за кількома полями branchCode та prdId, просто опублікувавши це для когось, хто потребує

    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);

        }
    }

Вихідний результат такий:

+++++++++++++++++++++++
[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}]

Після форматування:

[
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}
]
— Чарудатта Джоші
джерело
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.