JAVA8 Lambda表达式 高级集合类&收集器

lambda表达式提供了很多的集合类和收集器来简化编程，使之更加方便和美观，所以这里介绍一些常用的集合类和收集器来处理繁杂的代码。

github的demo地址:  https://github.com/BradenLei/lambda

1、方法引用：形如 User::getName，TreeSet::new 等价于user.getName(), new TreeSet<>();

可以引用静态方法、实例对象方法、构造方法等。

    /**
     * 方法引用
     */
    @Test
    public void refTest() {
        List<String> collect = list.stream().map(u -> u.getName()).collect(Collectors.toList());
        System.out.println(collect);
        // 等价于 User::getName
        System.out.println(list.stream().map(User::getName).collect(Collectors.toList()));

        // TreeSet::new
        Stream<Integer> integerStream = Stream.of(1, 2, 3);
        TreeSet<Integer> integerTreeSet = integerStream.collect(Collectors.toCollection(TreeSet::new));
        System.out.println(integerTreeSet);
    }

2、流中元素的顺序，如果集合本身无序，则转换的流仍然无序，如HashSet(进入顺序)

    /**
     * 方法引用
     */
    @Test
    public void refTest() {
        List<String> collect = list.stream().map(u -> u.getName()).collect(Collectors.toList());
        System.out.println(collect);
        // 等价于 User::getName
        System.out.println(list.stream().map(User::getName).collect(Collectors.toList()));

        // TreeSet::new
        Stream<Integer> integerStream = Stream.of(1, 2, 3);
        TreeSet<Integer> integerTreeSet = integerStream.collect(Collectors.toCollection(TreeSet::new));
        System.out.println(integerTreeSet);
    }

3、maxBy(比较器),minBy(..), 找出最大最小值

    /**
     * 转换成值
     */
    @Test
    public void biggestGroupTest() {
        Optional<Artist> optional = biggestGroup(artists.stream());
        System.out.println(optional.get().getName());  // -> ace
    }
    public Optional<Artist> biggestGroup(Stream<Artist> artists) {
        Function<Artist, Long> getCount = artist -> artist.getMembers().count();
        return artists.collect(maxBy(comparing(getCount))); // 找出最大成员数目
    }

4、averagingDouble()，求平均值

    /**
     * 找出一组专辑上曲目的平均数
     */
    @Test
    public void test() {
        System.out.println(averageNumberOfTracks(albums));
    }
    public double averageNumberOfTracks(List<Album> albums) {
        return albums.stream().collect(averagingDouble(album -> album.getTrackList().size()));
    }

5、数据分块 partitioningBy，根据true, false分成两块数据

    /**
     * 数据分块 partitioningBy, true or false值划分, 分成true or false 两部分
     */
    @Test
    public void partitioningByTest() {
        Map<Boolean, List<Artist>> booleanListMap = partitioningByNationality(artists.stream());
        List<Artist> trueList = booleanListMap.get(true);
        System.out.println(trueList);  // out -> each
        List<Artist> falseList = booleanListMap.get(false);
        System.out.println(falseList); // out -> ace
    }
    public Map<Boolean, List<Artist>> partitioningByNationality(Stream<Artist> artists) {
        // 将国籍分成中国和其他两组
        return artists.collect(Collectors.partitioningBy(artist -> "china".equals(artist.getNationality())));
    }

6、数据分组 groupingBy()，可以根据任意值进行分组

    /**
     * 数据分组 groupingBy, 任意值划分, 分成true or false 两部分
     */
    @Test
    public void groupingByTest() {
        Map<String, List<Artist>> stringListMap = groupingByNationality(artists.stream());
        List<Artist> list = stringListMap.get("china");  // out -> each
        System.out.println(list);
        List<Artist> list1 = stringListMap.get("US");  // out -> ace
        System.out.println(list1);

        Map<Artist, List<Album>> streamListMap = groupingByArtist(albums.stream());
        System.out.println(streamListMap.get(artist1));  // 专辑1, 专辑2
    }
    public Map<String, List<Artist>> groupingByNationality(Stream<Artist> artists) {
        // 按照国籍分组
        return artists.collect(Collectors.groupingBy(artist -> artist.getNationality()));
    }
    /** 按照主唱分组 */
    public Map<Artist, List<Album>> groupingByArtist(Stream<Album> albums) {
        return albums.collect(groupingBy(album -> album.getMainMusician()));
    }

7、字符串拼装  Collectors.joining, 按照指定的格式拼装字符串

    /**
     * 输出字符串
     */
    @Test
    public void joiningTest() {
        String joiningName = joiningName(artists.stream());
        System.out.println(joiningName);  // out -> [ace,each]
    }
    public String joiningName(Stream<Artist> artists) {
        return artists.map(Artist::getName).collect(Collectors.joining(",", "[", "]"));
    }

8、单一的收集器已经能实现很多基础的功能，组合方式更显强大

    // 组合收集器

    /** ===== 下游收集器: 例子中用到的第二个收集器, 用来收集最终结果的一个子集 ===== */

    /**
     * 统计某个艺术家专辑数量
     */
    @Test
    public void combineTest() {
        long braden = numberOfAlbums(albums.stream(), "bradenlei");
        System.out.println(braden);
    }
    public long numberOfAlbums(Stream<Album> albums, String artistName) {
        return albums.map(album -> album.getMusicians())
                .filter(musicians -> musicians.filter(musician -> artistName.equals(musician.getName())).count() > 0)
                .count();
    }

    /**
     * 计算每个艺术家的专辑数(counting)
     */
    @Test
    public void combineTest2() {
        Map<Artist, Long> count = count(albums.stream());
        System.out.println(count.get(artist1)); // out -> 2
    }
    public Map<Artist, Long> count(Stream<Album> albums) {
        return albums.collect(groupingBy(album -> album.getMainMusician(), counting()));
    }

    /**
     * 收集每个艺术家的专辑名称 (mapping)
     */
    @Test
    public void combineTest3() {
        Map<Artist, List<String>> artistListMap = collectName(albums.stream());
        System.out.println(artistListMap.get(artist1)); // out -> [专辑1, 专辑2]
    }
    public Map<Artist, List<String>> collectName(Stream<Album> alubms) {
        return alubms.collect(groupingBy(Album::getMainMusician, mapping(Album::getName, toList())));
    }

9、有些时候现有的收集器不能满足我们的开发需求，当然也就可以重构和定制收集器了

    /** =====重构和定制收集器===== */

    /**
     * 使用除joining之外的方法拼接字符串
     *
     * 获取艺术家姓名 (初步)
     */
    @Test
    public void jointTest() {
        StringBuilder reduced = artists.stream()
                .map(Artist::getName)
                .reduce(new StringBuilder(), (builder, name) -> {
                    if (builder.length() > 0) builder.append(", ");

                    return builder.append(name);
                }, (left, right) -> left.append(right));
        reduced.insert(0, "[");
        reduced.append("]");
        String result = reduced.toString();

        System.out.println(result); // out -> [ace, each]
    }
    /**
     * 优化(自定义StringCombiner)
     */
    @Test
    public void jointTest2() {
        StringCombiner reduced = artists.stream()
                .map(Artist::getName)
                .reduce(new StringCombiner(", ", "[", "]"),
                        StringCombiner::add,
                        StringCombiner::merge); // 这里实际没有调用merge
        String string = reduced.toString();
        System.out.println(string);  // out -> [ace, each]
    }

    /***
     * 进一步优化(使用定制收集器StringCollector收集)
     */
     @Test
    public void jointTest3() {
         String collect = artists.stream()
                 .map(Artist::getName)
                 .collect(new StringCollector(", ", "[", "]"));
         System.out.println(collect); // out -> [ace, each]
     }

    /**
     * 用reducing代替自定义收集器
     */
    @Test
    public void jointtTest4() {
        // 这种方法的缺点是第二个参数每次都需要new一个对象
        StringCombiner collect = artists.stream()
                .map(Artist::getName)
                .collect(Collectors.reducing(
                        new StringCombiner(", ", "[", "]"),
                        name -> new StringCombiner(", ", "[", "]").add(name),
                        StringCombiner::merge));  // 这里会调用merge, 每次都是两个StringCombiner对象合并, 所以修改StringCombiner.add即可得到正确格式[ace, each]
        String s = collect.toString();
        System.out.println(s);  // out -> [ace[each]
    }

自定义类：

public class StringCombiner {
    // 前缀
    private String prefix;
    // 分隔符
    private String delim;
    // 后缀
    private String suffix;

    private StringBuilder builder;

    public StringCombiner(String delim, String prefix, String suffix) {
        this.delim = delim;
        this.prefix = prefix;
        this.suffix = suffix;
        builder = new StringBuilder();
    }

    public StringCombiner add(String element) {
        if(builder.length() > 0) {
            builder.append(delim);
        } else {
            builder.insert(0, prefix);
        }
            builder.append(element);
        return this;
    }

    public StringCombiner merge(StringCombiner combiner) {
        builder.append(combiner.builder);
        return this;
    }

    @Override
    public String toString() {
        if ("".equals(suffix)) {
            return builder.toString();
        } else {
            int tmp = builder.length();
            String result = builder.append(suffix).toString();
            builder.setLength(tmp);
            return result;
        }
    }
}

其中：StringCombiner功能仿制java提供的StringJoiner

/**
 * String 待收集的元素字符串
 * StringCombiner 累加器类型
 * String 最终结果类型
 */
public class StringCollector implements Collector<String, StringCombiner, String> {
    // 前缀
    private String prefix;
    // 分隔符
    private String delim;
    // 后缀
    private String suffix;

    public StringCollector(String delim, String prefix, String suffix) {
        this.delim = delim;
        this.prefix = prefix;
        this.suffix = suffix;
    }
    @Override
    public Supplier<StringCombiner> supplier() {
        return () -> new StringCombiner(delim, prefix, suffix);
    }

    @Override
    public BiConsumer<StringCombiner, String> accumulator() {
        return StringCombiner::add;
    }

    @Override
    public BinaryOperator<StringCombiner> combiner() {
        return StringCombiner::merge;
    }

    @Override
    public Function<StringCombiner, String> finisher() {
        return StringCombiner::toString;
    }

    @Override
    public Set<Characteristics> characteristics() {
        Set<Collector.Characteristics> emptySet = Collections.emptySet();
        return emptySet;
    }
}

10、完整demo:

public class CollectorDemo {
    private static User user;
    private static List<User> list;

    @Before
    public void init() {
        if (user == null) {
            user = new User("张三", 11001);
        }
        if (list == null) {
            list = new ArrayList<>();
            list.add(new User("李四", 11002));
            list.add(new User("王五", 11003));
            list.add(new User("周庄", 11004));
        }
    }

    /**
     * 方法引用
     */
    @Test
    public void refTest() {
        List<String> collect = list.stream().map(u -> u.getName()).collect(Collectors.toList());
        System.out.println(collect);
        // 等价于 User::getName
        System.out.println(list.stream().map(User::getName).collect(Collectors.toList()));

        // TreeSet::new
        Stream<Integer> integerStream = Stream.of(1, 2, 3);
        TreeSet<Integer> integerTreeSet = integerStream.collect(Collectors.toCollection(TreeSet::new));
        System.out.println(integerTreeSet);
    }

    /**
     *  元素顺序, 如果集合本身无序, 则转换的流也是无序的如, HashSet
     */
    @Test
    public void orderTest() {
        // 进来的流无序， 则出去的流也是无序
        List<Integer> origin = Arrays.asList(1, 2, 3, 4);
        List<Integer> integerList = origin.stream().collect(Collectors.toList());
        assertEquals(origin, integerList); // ok

        Set<Integer> set = new HashSet<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
        Set<Integer> integerSet = set.stream().collect(Collectors.toSet());
        assertEquals(set, integerSet);  // 不能保证每次通过

        List<Integer> list = Arrays.asList(2, 1, 4, 3);
        List<Integer> collect = list.stream().sorted().collect(Collectors.toList());
        assertEquals(origin, collect); // ok
    }

    private static List<Artist> artists = null;
    private static List<Artist> artists2 = null;
    private static List<Track> tracks = null;
    private static List<Track> tracks2 = null;
    private static List<Album> albums = null;
    private static Artist artist1 = null;
    private static Artist artist2 = null;
    static {
        Artist artist = new Artist("braden", "china");
        artist1 = new Artist("ace", Arrays.asList(artist), "US");
        artist2 = new Artist("each", "china");
        artists = Arrays.asList(artist1, artist2);

        tracks = Arrays.asList(new Track("love you", 3), new Track("Shape of you", 5), new Track("夜上海", 4));
        tracks2 = Arrays.asList(new Track("喜欢你", 4), new Track("不分手的恋爱", 5));

        artists2 = Arrays.asList(new Artist("bradenlei","china"), new Artist("Mr.zhang","UK"));
        albums = Arrays.asList(new Album("专辑1", tracks, artists), new Album("专辑2", tracks2, artists), new Album("专辑3", tracks, artists2));
    }
    /**
     * 转换成值
     */
    @Test
    public void biggestGroupTest() {
        Optional<Artist> optional = biggestGroup(artists.stream());
        System.out.println(optional.get().getName());  // -> ace
    }
    public Optional<Artist> biggestGroup(Stream<Artist> artists) {
        Function<Artist, Long> getCount = artist -> artist.getMembers().count();
        return artists.collect(maxBy(comparing(getCount))); // 找出最大成员数目
    }

    /**
     * 找出一组专辑上曲目的平均数
     */
    @Test
    public void test() {
        System.out.println(averageNumberOfTracks(albums));
    }
    public double averageNumberOfTracks(List<Album> albums) {
        return albums.stream().collect(averagingDouble(album -> album.getTrackList().size()));
    }

    /**
     * 数据分块 partitioningBy, true or false值划分, 分成true or false 两部分
     */
    @Test
    public void partitioningByTest() {
        Map<Boolean, List<Artist>> booleanListMap = partitioningByNationality(artists.stream());
        List<Artist> trueList = booleanListMap.get(true);
        System.out.println(trueList);  // out -> each
        List<Artist> falseList = booleanListMap.get(false);
        System.out.println(falseList); // out -> ace
    }
    public Map<Boolean, List<Artist>> partitioningByNationality(Stream<Artist> artists) {
        // 将国籍分成中国和其他两组
        return artists.collect(Collectors.partitioningBy(artist -> "china".equals(artist.getNationality())));
    }

    /**
     * 数据分组 groupingBy, 任意值划分, 分成true or false 两部分
     */
    @Test
    public void groupingByTest() {
        Map<String, List<Artist>> stringListMap = groupingByNationality(artists.stream());
        List<Artist> list = stringListMap.get("china");  // out -> each
        System.out.println(list);
        List<Artist> list1 = stringListMap.get("US");  // out -> ace
        System.out.println(list1);

        Map<Artist, List<Album>> streamListMap = groupingByArtist(albums.stream());
        System.out.println(streamListMap.get(artist1));  // 专辑1, 专辑2
    }
    public Map<String, List<Artist>> groupingByNationality(Stream<Artist> artists) {
        // 按照国籍分组
        return artists.collect(Collectors.groupingBy(artist -> artist.getNationality()));
    }
    /** 按照主唱分组 */
    public Map<Artist, List<Album>> groupingByArtist(Stream<Album> albums) {
        return albums.collect(groupingBy(album -> album.getMainMusician()));
    }

    /**
     * 输出字符串
     */
    @Test
    public void joiningTest() {
        String joiningName = joiningName(artists.stream());
        System.out.println(joiningName);  // out -> [ace,each]
    }
    public String joiningName(Stream<Artist> artists) {
        return artists.map(Artist::getName).collect(Collectors.joining(",", "[", "]"));
    }

    // 组合收集器

    /** ===== 下游收集器: 例子中用到的第二个收集器, 用来收集最终结果的一个子集 ===== */

    /**
     * 统计某个艺术家专辑数量
     */
    @Test
    public void combineTest() {
        long braden = numberOfAlbums(albums.stream(), "bradenlei");
        System.out.println(braden);
    }
    public long numberOfAlbums(Stream<Album> albums, String artistName) {
        return albums.map(album -> album.getMusicians())
                .filter(musicians -> musicians.filter(musician -> artistName.equals(musician.getName())).count() > 0)
                .count();
    }

    /**
     * 计算每个艺术家的专辑数(counting)
     */
    @Test
    public void combineTest2() {
        Map<Artist, Long> count = count(albums.stream());
        System.out.println(count.get(artist1)); // out -> 2
    }
    public Map<Artist, Long> count(Stream<Album> albums) {
        return albums.collect(groupingBy(album -> album.getMainMusician(), counting()));
    }

    /**
     * 收集每个艺术家的专辑名称 (mapping)
     */
    @Test
    public void combineTest3() {
        Map<Artist, List<String>> artistListMap = collectName(albums.stream());
        System.out.println(artistListMap.get(artist1)); // out -> [专辑1, 专辑2]
    }
    public Map<Artist, List<String>> collectName(Stream<Album> alubms) {
        return alubms.collect(groupingBy(Album::getMainMusician, mapping(Album::getName, toList())));
    }

    /** =====重构和定制收集器===== */

    /**
     * 使用除joining之外的方法拼接字符串
     *
     * 获取艺术家姓名 (初步)
     */
    @Test
    public void jointTest() {
        StringBuilder reduced = artists.stream()
                .map(Artist::getName)
                .reduce(new StringBuilder(), (builder, name) -> {
                    if (builder.length() > 0) builder.append(", ");

                    return builder.append(name);
                }, (left, right) -> left.append(right));
        reduced.insert(0, "[");
        reduced.append("]");
        String result = reduced.toString();

        System.out.println(result); // out -> [ace, each]
    }
    /**
     * 优化(自定义StringCombiner)
     */
    @Test
    public void jointTest2() {
        StringCombiner reduced = artists.stream()
                .map(Artist::getName)
                .reduce(new StringCombiner(", ", "[", "]"),
                        StringCombiner::add,
                        StringCombiner::merge); // 这里实际没有调用merge
        String string = reduced.toString();
        System.out.println(string);  // out -> [ace, each]
    }

    /***
     * 进一步优化(使用定制收集器StringCollector收集)
     */
     @Test
    public void jointTest3() {
         String collect = artists.stream()
                 .map(Artist::getName)
                 .collect(new StringCollector(", ", "[", "]"));
         System.out.println(collect); // out -> [ace, each]
     }

    /**
     * 用reducing代替自定义收集器
     */
    @Test
    public void jointtTest4() {
        // 这种方法的缺点是第二个参数每次都需要new一个对象
        StringCombiner collect = artists.stream()
                .map(Artist::getName)
                .collect(Collectors.reducing(
                        new StringCombiner(", ", "[", "]"),
                        name -> new StringCombiner(", ", "[", "]").add(name),
                        StringCombiner::merge));  // 这里会调用merge, 每次都是两个StringCombiner对象合并, 所以修改StringCombiner.add即可得到正确格式[ace, each]
        String s = collect.toString();
        System.out.println(s);  // out -> [ace[each]
    }
}