stream用法

public class MarchTest {
    public static void main(String[] args) {
        // 顺序list是一直的，set顺序不保证
        // of 使用一组初始值生成新的stream
        // collection 收集器
        List<String> collected = Stream.of("a", "b", "c").collect(Collectors.toList());
 
        // map
        List<String> collected1 = Stream.of("a", "b", "c").map(e -> e.toUpperCase()).collect(Collectors.toList());
 
        //flatMap 连接stream [2, 3, 4, 5]
        List<Integer> together = Stream.of(asList(2, 3), asList(4, 5)).flatMap(numbers -> Arrays.stream(numbers)).collect(Collectors.toList());
 
        // min max
        Integer x = Stream.of(1, 2, 3).min(Comparator.comparing(e -> e)).get();
        Integer y = Stream.of(1, 2, 3).max(Comparator.comparing(e -> e)).get();
        // System.out.println(x+",,,"+y);
 
        // reduce, count, max, min都是reduce的一种
        //有两个参数：identity:起始值   accumulator：将值acc累加至accumulator
        Integer z = Stream.of(1, 2, 3).reduce(5, (acc, element) -> acc + element);
        // z = 11
        //将accumulator 展开
        BinaryOperator<Integer> accumulator = (acc, element) -> acc + element;
        int count = accumulator.apply(accumulator.apply(accumulator.apply(0, 1), 2), 3);
        // count = 6;
 
        // testGenerate();
 
        // maxBy minBy 取其中最大值，最小值 按照特定顺序
        List<Artist> artists = Stream.generate(Artist::generate).limit(10).collect(Collectors.toList());
        Artist artist = biggestGroup(artists).get();
        // System.out.println(artist.getMembers().size());
 
        // averagingInt
        double average = artists.stream().collect(Collectors.averagingInt(a -> a.ages.size()));
        // System.out.println(average);
 
        // partitioningBy 分块
        Map<Boolean, List<Artist>> map = artists.stream().collect(Collectors.partitioningBy(a -> a.members.size()==2 || a.members.size()==4));
        System.out.println(JSONObject.toJSONString(map));
 
        // 分组 groupingBy
        Map<Integer, List<Artist>> map1 = artists.stream().collect(Collectors.groupingBy(a -> a.members.size()));
        System.out.println(JSONObject.toJSONString(map1));
 
 
 
 
    }
 
    public static void testGenerate() {
        Stream<String> stream3 = Stream.generate(() -> "love").limit(10);
        String[] strArr3 = stream3.toArray(String[]::new);
        System.out.println(Arrays.toString(strArr3));
    }
 
    public static Optional<Artist> biggestGroup(List<Artist> artists) {
        Function<Artist, Long> getCount = artist -> artist.getMembers().stream().count();
        return artists.stream().collect(Collectors.maxBy(Comparator.comparing(getCount)));
    }
 
    // 将一下转化为stream
    public Set<String> findLongTracks(List<Album> albums) {
        Set<String> trackNames = new HashSet<>();
        for (Album album : albums) {
            for (Track track : album.getTrackList()) {
                if (track.getLength() > 60) {
                    String name = track.getName();
                    trackNames.add(name);
                }
            }
        }
        return trackNames;
    }
 
    public Set<String> findLongTracksStream(List<Album> albums) {
        Set<String> trackNames = new HashSet<>();
        albums.stream().flatMap(album -> album.getTrackList().stream()).filter(t -> t.getLength() > 60).map(Track::getName).forEach(name -> trackNames.add(name));
        return trackNames;
    }
 
    static class Artist {
        List<String> members;
        List<Integer> ages;
        public Artist() {
        }
 
        public Artist(int len) {
            members = new ArrayList<>(len);
            ages = new ArrayList<>();
            for (int i = 0; i < len; i++) {
                members.add(String.valueOf(i));
                ages.add(i);
                if(i%2==0){
                    members.add("hello");
                }
            }
        }
 
        public List<String> getMembers() {
            return members;
        }
 
        public void setMembers(List<String> members) {
            this.members = members;
        }
 
        public static Artist generate() {
            int len = new Random().nextInt(10);
            return new Artist(Math.abs(len));
        }
    }
 
    class Album {
        List<Track> trackList = new ArrayList<>();
 
        public List<Track> getTrackList() {
            return trackList;
        }
 
        public void setTrackList(List<Track> trackList) {
            this.trackList = trackList;
        }
    }
 
    class Track {
        String name;
        int length;
 
        public int getLength() {
            return length;
        }
 
        public void setLength(int length) {
            this.length = length;
        }
 
        public String getName() {
            return name;
        }
 
        public void setName(String name) {
            this.name = name;
        }
    }
 
    private static Integer[] asList(Integer... items) {
        if (items != null && items.length > 0) {
            Integer[] r = new Integer[items.length];
            for (int i = 0; i < r.length; i++) {
                r[i] = items[i];
            }
            return r;
        }
        return null;
    }
 
    private static void test() {
        // 判断标准：返回是否为Stream
        // 惰性求值，不打印
        Stream.of("tom", "jerry", "harry").filter(e -> {
            System.out.println("============");
            return e.equals("jerry");
        });
 
        // 及早求值，打印
        long count = Stream.of("tom", "jerry", "harry").filter(e -> {
            System.out.println("xxxxxxxxxxxxxxxxxxxxxx");
            return e.equals("jerry");
        }).count();
    }
 
}