Java流操作总结

Java流(Stream)操作自Java 8引入，通过Stream操作可以简化代码编写，提高代码执行效率。流整体操作分为创建(Supplier)、转换、约简和收集几个操作。

创建流

创建流最常见的方式是调用Collection.stream()方法，将集合数据转换为流，也可以通过generate方法创建流。如下所示：

    public static void main(String[] args) {
        //从Collection中产生流
        ArrayList<String> strings = new ArrayList<>();
        for (int i = 0; i < 20; ++i) {
            strings.add("string" + i);
        }

        Stream<String> stringStream = strings.stream();
        show("stringStream", stringStream);

        //使用generate产生流
        Stream<Integer> integerStream = Stream.generate(() -> (int) (Math.random() * 100));
        show("integerStream", integerStream);
        //使用iterate产生序列
        Stream<Integer> integerStream1 = Stream.iterate(0, n -> n + 1);
        show("integerStream1", integerStream1);

        //使用of方法创建流
        Stream<String> stringStream1 = Stream.of("Bob", "Mark", "Alice", "Edd");
        show("stringStream1", stringStream1);

        //正则表达式产生流
        String sentences = "I had a dog whose name was Bingo. B, I, N, G, O, Bingo was his name, Oh!";
        Stream<String> words = Pattern.compile("\\PL+").splitAsStream(sentences);
        show("PatterStream", words);
    }

    public static<T> void show(String title, Stream<T> stream) {
        final int size = 10;
        List<T> array = stream.limit(size).collect(Collectors.toList());
        System.out.println(title + ": ");
        for (int i = 0; i < array.size(); ++i) {
            if (i > 0) {
                System.out.print(", ");
            }
            if (i < array.size()) {
                System.out.print(array.get(i));
            } else {
                System.out.print("...");
            }
        }
        System.out.println();
    }

流的转换

流的转换即将一个给定的流通过流的方法转换为另一个流，常见的方法有filter，map，distinct, sorted，reverse等方法。

filter方法保留满足filter方法中的条件表达式的元素；
map方法可以对流中的元素进行一个转换操作；
distinct方法将流中重复的元素去除
sorted按给定的比较方法进行排序

String sentences = "I had a dog whose name was Bingo. B, I, N, G, O, Bingo was his name, Oh!";
//保留长度大于2的单词
Stream<String> words1 = Pattern.compile("\\PL+").splitAsStream(sentences).filter(s -> s.length() > 2);
show("PatterStream1", words1);

//将单词转换为大写
Stream<String> words2 = Pattern.compile("\\PL+").splitAsStream(sentences).map(String::toUpperCase);
show("PatterStream2", words2);

//去除重复的单词
Stream<String> words3 = Pattern.compile("\\PL+").splitAsStream(sentences).distinct();
show("PatterStream3", words3);

//按长度对单词进行排序
Stream<String> words4 = Pattern.compile("\\PL+").splitAsStream(sentences).sorted(Comparator.comparing(String::length));
show("PatterStream4", words4);

 //按长度对单词进行排序后反序
 Stream<String> words5 = Pattern.compile("\\PL+").splitAsStream(sentences).sorted(Comparator.comparing(String::length).reversed());
 show("PatterStream4", words5);

流的约减（Reduce）

流经过处理后，提供了一系列方法从流中抽取数据。抽取数据是一种终结操作，常用的方法如下：

count方法：获取流中满足条件的元素个数
min、max方法：按照给定的比较方法获取最小最大值，注意该方法返回的是一个Optional<T>的包装类，这是因为流可能为空。
find查找方法：包括findFirst，findAny等。
match方法：根据条件查找是否有匹配条件的元素，有anyMatch，allMatch和noneMatch，返回的是boolean类型。
消费流：通过方法消费流中的元素，例如使用forEach迭代，传递方法处理流中的每个元素。
转换为Collection或数组：通过collect方法传递Collectors类提供的toCollection方法可以转换为Collection或者调用toArray方法转换为数组。
拼接：使用Collectors.join方法可以拼接流.
统计，使用IntSummaryStatistics、DoubleSummaryStatistics和LongSummaryStatistics方法构造统计对象，获取总数，平均值，最大值，最小值。需要注意调用Collectors.summarizing{Int,Double, Long}方法需要传递一个lambda表达式，确定统计的内容。

//获取单词的数量
long wordsCount = Pattern.compile("\\PL+").splitAsStream(sentences).filter(s -> s.length() > 2).count();
System.out.println("Number of words length greater than 2: " + wordsCount);

//获取最长的单词
Optional<String> longestWord = Pattern.compile("\\PL+").splitAsStream(sentences).max(Comparator.comparing(String::length));
System.out.println("longestWord: " + longestWord.orElse("null"));

//获取最短的单词
Optional<String> shortestWord = Pattern.compile("\\PL+").splitAsStream(sentences).min(Comparator.comparing(String::length));
System.out.println("shortestWord: " + shortestWord.orElse("null"));

//获取第一个以h开头的单词
Optional<String> firstWordsStartWithH = Pattern.compile("\\PL+").splitAsStream(sentences)
                .filter(s -> s.toLowerCase().startsWith("h")).findFirst();
System.out.println("firstWordsStartWithH: " + firstWordsStartWithH.orElse("Not Found"));

//获取任何一个以h开头的单词
Optional<String> anyWordsStartWithH = Pattern.compile("\\PL+").splitAsStream(sentences)
                .filter(s -> s.toLowerCase().startsWith("h")).findAny();
System.out.println("anyWordsStartWithH: " + anyWordsStartWithH.orElse("Not Found"));

//查找其中是否有was这个单词
boolean hasWas = Pattern.compile("\\PL+").splitAsStream(sentences).anyMatch("was"::equals);
System.out.println("hasWas: " + hasWas);

//查找其中全部是was这个单词
boolean allWas = Pattern.compile("\\PL+").splitAsStream(sentences).allMatch("was"::equals);
System.out.println("allWas: " + allWas);

//使用forEach方法打印全部单词的大写
Pattern.compile("\\PL+").splitAsStream(sentences).map(String::toUpperCase).forEach(System.out::print);

//将流转为Collection
List<String> wordsList = Pattern.compile("\\PL+").splitAsStream(sentences).collect(Collectors.toList());
System.out.println("wordsList: " + wordsList);

//将流转为数组
String[] wordsArray = Pattern.compile("\\PL+").splitAsStream(sentences).toArray(String[]::new);
System.out.println("wordsArray: " + Arrays.toString(wordsArray));

//将流拼接为字符串
String wordsToSentences = Pattern.compile("\\PL+").splitAsStream(sentences).collect(Collectors.joining(", "));
System.out.println("wordsToSentences: " + wordsToSentences);

//数据统计：统计单词的长度
IntSummaryStatistics lengthSummary = Pattern.compile("\\PL+").splitAsStream(sentences).
                collect(Collectors.summarizingInt(String::length));
System.out.println("Longest word length: " + lengthSummary.getMax());
System.out.println("Shortest word length: " + lengthSummary.getMin());
System.out.println("Average word length: " + lengthSummary.getAverage());

收集到Map：使用Collectors.toMap转到Map数据中。
分组：使用groupingBy进行分组

    public static class User {
        private String name;
        private int id;
        //1=male, 0 = female, 2= unknown
        private int sex = 2;

        public User(int id, String name, int sex) {
            this.id = id;
            this.name = name;
            if (sex == 0 || sex == 1) {
                this.sex = sex;
            }
        }

        public int getId() {
            return id;
        }

        public String getName() {
            return name;
        }

        public int getSex() {
            return sex;
        }

        @Override
        public String toString() {
            return "User{id = " + id + ", name = " + name + ", sex = " + sex + "}";
        }
    }

    //省略部分代码...

    public static Stream<User> userStream() {
        return Stream.of(
                new User(1, "Box", 1),
                new User(2, "Succi", 0),
                new User(3, "Lily", 0),
                new User(4, "Sara", 0),
                new User(5, "Mark", 1)
        );
    }
    

    //main方法
    public static void main(String[] args) {
        //...
        //映射为id -> User格式
        Map<Integer, User> userMap = userStream().collect(Collectors.toMap(User::getId, Function.identity()));
        for (Integer key:userMap.keySet()) {
            System.out.println("id " + key + ": " + userMap.get(key));
        }
        
        //映射为id -> User.name格式
        Map<Integer, String> idToNameMap = userStream().collect(Collectors.toMap(User::getId, User::getName));
        System.out.println(idToNameMap);
        
        //按性别分组
        Map<Integer, Set<User>> sexToUserMap = userStream().collect(Collectors.groupingBy(User::getSex, Collectors.toSet()));
        for (Integer key:sexToUserMap.keySet()) {
            Set<User> usersOfSex = sexToUserMap.get(key);
            System.out.println("Sex " + key + ": " + usersOfSex);
        }
    }