【java8】streamのcollectメソッドの使い方

Copy
// 構文
    collect(Collector collector)

    // Collectorsクラス利用
    // Listに変換
    ~.collect(Collectors.toList())
    // Mapに変換
    ~.collect(Collectors.toMap(Person::getName,Person::getWeight ,(e1,e2)->e1,LinkedHashMap::new));

    // 独自Collectorクラス(sampleCollector)利用
    ~.collect(sampleCollector)

    // 独自Collectorインターフェースのofメソッドの利用
    ~.collect(Collector.of(~))

Copy
// 構文
    collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner)

    // Mapにする可変リダクション処理
    ~.collect(
            // 中間コンテナを生成
            // 最初の1回だけ実行
            ()->new HashMap<>(),
            // 中間コンテナに値をセットしていく
            // streamの要素の数だけ実行される
            (Map m,Person p)->{
                m.put(p.getName(),p.getWeight());

            },
            // 中間コンテナ同士をマージする
            // 順次ストリームの場合未実行
            (m,m2)->{
                m.putAll(m2);
            }
        );

Copy
import java.util.*;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) throws Exception {

        class Person {
            private final String name;
            private final int weight;

            Person(String name, int weight) {
                this.name = name;
                this.weight = weight;
            }

            public String getName() {
                return this.name;
            }

            public int getWeight() {
                return this.weight;
            }

        }

        List<Person> personList = Arrays.asList(
             new Person("太郎", 72),
             new Person("二郎", 79),
             new Person("二郎", 99)
        );

        // オブジェクトリストをMapに変換する
        LinkedHashMap<String,Integer>personMap = 
            personList.stream().collect(
                Collectors.toMap(Person::getName,Person::getWeight ,(e1,e2)->e1,LinkedHashMap::new));

        // 変換したMapの中身をループで出力する
        personMap.entrySet().stream().forEach(map->{
            System.out.println(map.getKey()+"のエントリー");
            System.out.println("Mapのkey : " + map.getKey());
            System.out.println("Mapのvalue : " + map.getValue());

        });

    }
}
// 太郎のエントリー
// Mapのkey : 太郎
// Mapのvalue : 72
// 二郎のエントリー
// Mapのkey : 二郎
// Mapのvalue : 79

Copy
import java.util.*;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) throws Exception {

        class Person {
            private final String name;
            private final int weight;

            Person(String name, int weight) {
                this.name = name;
                this.weight = weight;
            }

            public String getName() {
                return this.name;
            }

            public int getWeight() {
                return this.weight;
            }

        }

        List<Person> personList = Arrays.asList(
             new Person("太郎", 72),
             new Person("二郎", 79),
             new Person("二郎", 99)
        );

        // オブジェクトリストを名前だけのList変換する
        List<String>nameList = 
            personList.stream().
            map(obj->obj.getName()).
            collect(Collectors.toList());

        // 変換したListの中身をループで出力する
        nameList.stream().forEach(n->{
            System.out.println(n);

        });

    }
}
// 太郎
// 二郎
// 二郎

Copy
import java.util.*;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) throws Exception {

        class Person {
            private String name;
            private String weight;

            Person(String name, String weight) {
                this.name = name;
                this.weight = weight;
            }

            public String getName() {
                return this.name;
            }

            public String getWeight() {
                return this.weight;
            }

            public void setWeight(String weight) {
                this.weight = weight;
            }

        }

        List<Person> personList = Arrays.asList(
             new Person("太郎", null),
             new Person("二郎", "79"),
             new Person("三郎", "99")
        );

        // オブジェクトリストをMapに変換する
        Map<String,String>personMap = 
            personList.stream().collect(
                // supplier
                // 中間コンテナを生成
                // 最初の1回だけ実行
                ()->{
                    System.out.println("supplier");
                    return new HashMap<>();

                },
                // accumulator
                // 中間コンテナに値をセットしていく
                // stermの要素の数だけ実行される
                (Map m,Person p)->{
                    System.out.println("accumulator");
                    m.put(p.getName(),p.getWeight());

                },
                // 中間コンテナをマージする関数
                // 順次ストリームの場合は実行されない
                (m,m2)->{
                    m.putAll(m2);
                    System.out.println("combiner");
                }
                );

        // 変換したMapの中身をループで出力する
        personMap.entrySet().stream().forEach(map->{
            System.out.println(map.getKey()+"のエントリー");
            System.out.println("Mapのkey : " + map.getKey());
            System.out.println("Mapのvalue : " + map.getValue());

        });
    }
}
// 実行結果
// supplier
// accumulator
// accumulator
// accumulator
// 二郎のエントリー
// Mapのkey : 二郎
// Mapのvalue : 79
// 太郎のエントリー
// Mapのkey : 太郎
// Mapのvalue : null
// 三郎のエントリー
// Mapのkey : 三郎
// Mapのvalue : 99

Copy
of(Supplier<R> supplier,//中間コンテナを生成する関数
    BiConsumer<R,T> accumulator,//中間コンテナへ値を折り畳む関数
     BinaryOperator<R> combiner,//ふたつの中間コンテナをひとつにマージする関数。
      Collector.Characteristics... characteristics)

Copy
// Collector<T,R,R>
    Collector<Person ,List<String>, List<String>> sampleCollector =
        Collector.of(
                 //  supplier
                 ()->new ArrayList<String>(), 
                 //ArrayList<Person>::new,

                 //accumulator
                 (list, presonObj)->{
                     list.add(presonObj.getName());
                 },
                 //combiner 
                 (list1, list2) -> {
                     list1.addAll(list2);
                     return list1;
                 });

Copy
of(Supplier<A> supplier,//中間コンテナを生成する関数
     BiConsumer<A,T> accumulator,//中間コンテナへ値を折り畳む関数
      BinaryOperator<A> combiner,//ふたつの中間コンテナをひとつにマージする関数。
       Function<A,R> finisher,//中間コンテナから最終的な結果へ変換する関数
        Collector.Characteristics... characteristics)

Copy
// Collector<T,A,R>
    Collector<Person ,List<Person>, Map<String,String>> sample =
        Collector.of(
                // supplier
                ()->new ArrayList<Person>(),     
                // accumulator
                (list, presonObj)->{
                    list.add(presonObj);
                }, 
                // combiner
                (list1, list2) -> {
                    list1.addAll(list2);
                    return list1;
                },
                // finisher 
                (list)->list.stream().collect(Collectors.toMap(e->e.getName(),e->e.getWeight(),(e1,e2)->e1))
            );

Copy
import java.util.*;
import java.util.stream.*;

public class Main {

    public static void main(String[] args) throws Exception {

        class Person {
            private String name;
            private String weight;

            Person(String name, String weight) {
                this.name = name;
                this.weight = weight;
            }

            public String getName() {
                return this.name;
            }

            public String getWeight() {
                return this.weight;
            }

            public void setWeight(String weight) {
                this.weight = weight;
            }

        }

        List<Person> personList = Arrays.asList(
             new Person("太郎", "22"),
             new Person("二郎", "79"),
             new Person("三郎", "99")
        );

        // Collector<T,R,R>
        // 引数が3つのofメソッドでcollectorを作成
        Collector<Person ,List<String>, List<String>> sampleCollector1 =
            Collector.of(
                     //  supplier
                     ()->new ArrayList<String>(), 
                     //ArrayList<Person>::new,

                     //accumulator
                     (list, presonObj)->{
                         list.add(presonObj.getName());
                     },
                     //combiner 
                     (list1, list2) -> {
                         list1.addAll(list2);
                         return list1;
                     });

        // Collector<T,A,R>
        // 引数が4つのofメソッドでcollectorを作成
        Collector<Person ,List<Person>, Map<String,String>> sampleCollector2 =
            Collector.of(
                    // supplier
                    ()->new ArrayList<Person>(),     
                    // accumulator
                    (list, presonObj)->{
                        list.add(presonObj);
                    }, 
                    // combiner
                    (list1, list2) -> {
                        list1.addAll(list2);
                        return list1;
                    },
                    // finisher 
                    (list)->list.stream().collect(Collectors.toMap(e->e.getName(),e->e.getWeight(),(e1,e2)->e1))
                );

        // 実行
        System.out.println("sampleCollector1を使う");
        List<String>sampleList = personList.stream().collect(sampleCollector1);
        sampleList.stream().forEach(name->{
            System.out.println(name);
        });

        System.out.println("sampleCollector2を使う");
        Map<String,String>sampleMap = personList.stream().collect(sampleCollector2);
        sampleMap.entrySet().stream().forEach(entry->{
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        });

        System.out.println("すべてチェーンする");
        // ListからMap(中間コンテナ)を通してSetにする
        personList.stream().collect(
            Collector.of(
                // supplier
                HashMap<String,String>::new,
                // accumulator
                (map,pobj)->map.put(pobj.getName(),pobj.getWeight()),
                // combiner
                (map1,map2)->{
                    map1.putAll(map2);
                    return map1;
                },
                // finisher 
                (map)->{
                    Set<String>res = new HashSet<>();
                    map.entrySet().stream().forEach(key->
                        res.add(key.getKey())
                    );
                    return res;
                }

            )
        ).stream().forEach(val->{
             System.out.println(val);
        });   

    }
}

Copy
// sampleCollector1を使う
// 太郎
// 二郎
// 三郎
// sampleCollector2を使う
// 二郎
// 79
// 三郎
// 99
// 太郎
// 22
// すべてチェーンする
// 二郎
// 太郎
// 三郎

Copy
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;

// Map<String,String>をオブジェクトのリストにするcollector
// Collector<T,A,R>
public class SampleCollector implements Collector<Map.Entry<String, String>, Map<String,String>, List<Person>> {

    // 中間コンテナ生成メソッド
    // Supplier< A> supplier
    @Override
    public Supplier<Map<String,String>> supplier() {
        // 引数なし、戻り値ありの関数を返す
        return () -> new HashMap<>();
    }

    // 中間コンテナへ値を折り畳む関数
    // BiConsumer< A,T> accumulator
    @Override
    public BiConsumer<Map<String,String>, Map.Entry<String, String>> accumulator() {
        // 引数が二つ、戻り値なしの関数を返す
        return (acumMap, entry) -> {
            // Integer aa = Integer.parseInt(pObj.getWeight());
            acumMap.put(entry.getKey(),entry.getValue());
            };
    };

    // ふたつの中間コンテナをひとつにマージする関数
    // 順儒ストリームの場合は動かない
    // BinaryOperator< A > combiner
    @Override
    public BinaryOperator<Map<String,String>> combiner() {
        //引数が二つで戻り値ありの関数を返す
        return (returnMap, colletedMap) -> {
            System.out.println("combiner!");
            returnMap.putAll(colletedMap);
            return returnMap;
        };
    }

    // 中間コンテナから最終的な結果へ変換する関数
    // Function< A,R > finisher
    @Override
    public Function<Map<String,String>, List<Person>> finisher() {
        //  一つの引数ありで戻り値ありの関数を返す
        // 戻り値の型を中間コンテナから変更することができる
        return paramMap -> {

            List<Person>pList = new ArrayList<>();
            paramMap.entrySet().stream().forEach(entry->{

                pList.add(new Person(entry.getKey(),Integer.parseInt(entry.getValue())));

            });

            return pList;
        };
    }

    @Override
    public Set<Collector.Characteristics> characteristics() {

        final Set<Collector.Characteristics> returnSet = new HashSet<>();

//      3つの指定ができますが、サンプルではOFFです。
//      returnSet.add(Characteristics.IDENTITY_FINISH);
//      returnSet.add(Characteristics.CONCURRENT);
//      returnSet.add(Characteristics.UNORDERED);

        return returnSet;
    }
}

Copy
import java.util.*;
import java.util.stream.*;

public class Main {

    public static void main(String[] args) throws Exception {

        // mapを作る
        Map<String,String>personMap = new HashMap<String,String>(){
                    { put("森博嗣", "11"); }
                    { put("周期律", "22"); }
                    { put("辻村深月", "33"); }

        };

        // 独自コレクターをインスタンス化
        SampleCollector collector = new SampleCollector();
        // collectを実行
        List<Person>pList =  personMap.entrySet().stream().collect(collector);

        // 実行
        System.out.println("Collector実装クラスを使う");
        pList.stream().forEach(obj->{
            System.out.println(obj.getName());
            System.out.println(obj.getWeight());
        });
    }
}
// 実行結果
// Collector実装クラスを使う
// 森博嗣
// 11
// 辻村深月
// 33
// 周期律
// 22

Copy
import java.util.*;
import java.util.stream.*;

public class Main {

    public static void main(String[] args) throws Exception {

        // mapを作る
         List<Integer> List = Arrays.asList(1,2,3,4,5,6,7,8,9,10);

        // 実行
        List.stream().parallel().forEach(no->{
            System.out.println(no);
        });
    }
}

Copy
import java.util.*;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) throws Exception {

        class Person {
            private String name;
            private String weight;

            Person(String name, String weight) {
                this.name = name;
                this.weight = weight;
            }

            public String getName() {
                return this.name;
            }

            public String getWeight() {
                return this.weight;
            }

            public void setWeight(String weight) {
                this.weight = weight;
            }

        }

        List<Person> personList = Arrays.asList(
             new Person("太郎", null),
             new Person("二郎", "79"),
             new Person("三郎", "99")
        );

        // オブジェクトリストをMapに変換する
        // parallelをつけて並列ストリームにする
        Map<String,String>personMap = 
            personList.stream().parallel().collect(
                // supplier
                // 中間コンテナを生成
                // 最初の1回だけ実行
                ()->{
                    System.out.println("supplier");
                    return new HashMap<>();

                },
                // accumulator
                // 中間コンテナに値をセットしていく
                // stermの要素の数だけ実行される
                (Map m,Person p)->{
                    System.out.println("accumulator");
                    m.put(p.getName(),p.getWeight());

                },
                // 中間コンテナをマージする関数
                // 並列ストリームの場合のみ実行される
                (m,m2)->{
                    System.out.println("combiner");
                    m.putAll(m2);
                }
                );

        // 変換したMapの中身をループで出力する
        personMap.entrySet().stream().forEach(map->{
            System.out.println(map.getKey()+"のエントリー");
            System.out.println("Mapのkey : " + map.getKey());
            System.out.println("Mapのvalue : " + map.getValue());

        });
    }
}
// 実行結果
// supplier
// accumulator
// supplier
// accumulator
// supplier
// accumulator
// combiner
// combiner
// 二郎のエントリー
// Mapのkey : 二郎
// Mapのvalue : 79
// 太郎のエントリー
// Mapのkey : 太郎
// Mapのvalue : null
// 三郎のエントリー
// Mapのkey : 三郎
// Mapのvalue : 99