Java8で複数のフィールド名でグループ化する

95

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

しかし、複数のフィールドでグループ化したい場合はどうなりますか？そのPOJOにgroupingBy()メソッドを実装した後、メソッドにPOJOを渡すことはできequals()ますが、特定のPOJOの複数のフィールドでグループ化できるような他のオプションはありますか？

たとえば、私の場合、名前と年齢でグループ化します。

java  java-8 
— Mital Pritmani
ソース
1
秘訣は、すべてのフィールドから一意の文字列を生成することです。
— Marko Topolnik 2015
3
ところでmapping、ダウンストリームコレクターとしてのところで、投稿したコードでは冗長です。
— Marko Topolnik 2015
8
迅速で汚い解決策はpeople.collect(groupingBy(p -> Arrays.asList(p.name, p.age)))です。
— ミシャ2015

回答:

170

ここにはいくつかのオプションがあります。最も簡単なのは、コレクターをチェーンすることです。

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

次に、フレッドと呼ばれる18歳の人々のリストを取得するには、次を使用します。

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

2番目のオプションは、グループ化を表すクラスを定義することです。これはPersonの内部にある可能性があります。このコードは使用していますrecordが、それは同じように簡単に（とクラスかもしれないequalsとhashCodeJEP 359が追加された前のJavaのバージョンで定義されています）：

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 commons pairこれらのライブラリのいずれかを使用する場合は、マップのキーを名前と年齢のペアにすることができます。

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コンポーネント間の接着剤タイプとして最適です。ところで、Scalaのケースクラスは、簡潔さと意図的な露出の両方の点で私見の大きな勝利です。
— Marko Topolnik 2015
1
はい、私はあなたの主張を理解しています。私は（いつものように）それがそれらがどのように使われるかに依存すると思います。上記の例（マップのキーとしてペアを使用）は、それを行わない方法の良い例です。私はScalaにあまり精通していません。良いことを聞いたら、Scalaを学び始める必要があります。
— スプリンター
1
ただ、宣言することができることを想像NameAge：ワンライナーとしてcase class NameAge { val name: String; val age: Int }---そしてあなたが得るequals、hashCodeとtoString！
— Marko Topolnik 2015
1
ニース-別のアイテムが私の「しなければならない」キューにプッシュされました。残念ながらFIFOです！
— スプリンター
@sprinter最初のコードスニペットのタイプが正しくないため、次のように変更する必要がありますMap<String, Map<Integer, List<Person>>> map
— kasur 2016
39

ここでコードを見てください：

関数を作成して、機能的なスタイルのように機能させることができます。

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

乾杯！

— Deepesh Rehi
ソース
2
私はこのソリューションを使用しましたが、異なります。Function <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());
                }
            }));

最後に、ラムダバックに置き換えた後、コードは次のようになります。

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 2018年
7

こんにちはあなたは単にあなたの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();
}
— アマンディープ
ソース
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())));
— sarveshseri
ソース
3
それはただ再発明しているだけですArarys.asList()---ところで、これはOPの場合の良い選択です。
— Marko Topolnik 2015
またPair、他の例で説明した例と同様ですが、引数の制限はありません。
— ベニーボッテマ2016
また、これを不変にする必要があります。（そしてhashCode）1回計算）
— RobAu 2017年
2

多くのフィールドの分類子としてリストを使用できますが、null値をオプションにラップする必要があります。 

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}
]
— チャルダッタジョシ
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.