关于java:一文入门Java-Stream流太强了

两个星期以前，就有读者强烈要求我写一篇 Java Stream 流的文章，我说市面上不是曾经有很多了吗，后果你猜他怎么说：“就想看你写的啊！”你看你看，如许红润的喜爱啊。那就“勉为其难”写一篇吧，嘻嘻。

单从“Stream”这个单词上来看，它仿佛和 java.io 包下的 InputStream 和 OutputStream 有些关系。实际上呢，没毛关系。Java 8 新增的 Stream 是为了解放程序员操作汇合（Collection）时的生产力，之所以能解放，很大一部分起因能够归功于同时呈现的 Lambda 表达式——极大的进步了编程效率和程序可读性。

Stream 到底是什么呢？

Stream 就如同一个高级的迭代器，但只能遍历一次，就如同一江春水向东流；在流的过程中，对流中的元素执行一些操作，比方“过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等。

要想操作流，首先须要有一个数据源，能够是数组或者汇合。每次操作都会返回一个新的流对象，不便进行链式操作，但原有的流对象会放弃不变。

流的操作能够分为两种类型：

1）两头操作，能够有多个，每次返回一个新的流，可进行链式操作。

2）终端操作，只能有一个，每次执行完，这个流也就用光光了，无奈执行下一个操作，因而只能放在最初。

来举个例子。

List<String> list = new ArrayList<>();
list.add("武汉加油");
list.add("中国加油");
list.add("世界加油");
list.add("世界加油");

long count = list.stream().distinct().count();
System.out.println(count);

distinct() 办法是一个两头操作（去重），它会返回一个新的流（没有独特元素）。

Stream<T> distinct();

count() 办法是一个终端操作，返回流中的元素个数。

long count();

两头操作不会立刻执行，只有等到终端操作的时候，流才开始真正地遍历，用于映射、过滤等。艰深点说，就是一次遍历执行多个操作，性能就大大提高了。

实践局部就扯这么多，上面间接进入实战局部。

01、创立流

如果是数组的话，能够应用 Arrays.stream() 或者 Stream.of() 创立流；如果是汇合的话，能够间接应用 stream() 办法创立流，因为该办法曾经增加到 Collection 接口中。

public class CreateStreamDemo {public static void main(String[] args) {String[] arr = new String[]{"武汉加油", "中国加油", "世界加油"};
        Stream<String> stream = Arrays.stream(arr);

        stream = Stream.of("武汉加油", "中国加油", "世界加油");

        List<String> list = new ArrayList<>();
        list.add("武汉加油");
        list.add("中国加油");
        list.add("世界加油");
        stream = list.stream();}
}

查看 Stream 源码的话，你会发现 of() 办法外部其实调用了 Arrays.stream() 办法。

public static<T> Stream<T> of(T... values) {return Arrays.stream(values);
}

另外，汇合还能够调用 parallelStream() 办法创立并发流，默认应用的是 ForkJoinPool.commonPool()线程池。

List<Long> aList = new ArrayList<>();
Stream<Long> parallelStream = aList.parallelStream();

02、操作流

Stream 类提供了很多有用的操作流的办法，我来挑一些罕用的给你介绍一下。

1）过滤

通过 filter() 办法能够从流中筛选出咱们想要的元素。

public class FilterStreamDemo {public static void main(String[] args) {List<String> list = new ArrayList<>();
        list.add("周杰伦");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");
        Stream<String> stream = list.stream().filter(element -> element.contains("王"));
        stream.forEach(System.out::println);
    }
}

filter() 办法接管的是一个 Predicate（Java 8 新增的一个函数式接口，承受一个输出参数返回一个布尔值后果）类型的参数，因而，咱们能够间接将一个 Lambda 表达式传递给该办法，比如说 element -> element.contains("王") 就是筛选出带有“王”的字符串。

forEach() 办法接管的是一个 Consumer（Java 8 新增的一个函数式接口，承受一个输出参数并且无返回的操作）类型的参数，类名 :: 办法名 是 Java 8 引入的新语法，System.out 返回 PrintStream 类，println 办法你应该晓得是打印的。

stream.forEach(System.out::println); 相当于在 for 循环中打印，相似于上面的代码：

for (String s : strs) {System.out.println(s);
}

很显著，一行代码看起来更简洁一些。来看一下程序的输入后果：

王力宏

2）映射

如果想通过某种操作把一个流中的元素转化成新的流中的元素，能够应用 map() 办法。

public class MapStreamDemo {public static void main(String[] args) {List<String> list = new ArrayList<>();
        list.add("周杰伦");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");
        Stream<Integer> stream = list.stream().map(String::length);
        stream.forEach(System.out::println);
    }
}

map() 办法接管的是一个 Function（Java 8 新增的一个函数式接口，承受一个输出参数 T，返回一个后果 R）类型的参数，此时参数 为 String 类的 length 办法，也就是把 Stream<String> 的流转成一个 Stream<Integer> 的流。

程序输入的后果如下所示：

3
3
2
3

3）匹配

Stream 类提供了三个办法可供进行元素匹配，它们别离是：

• anyMatch()，只有有一个元素匹配传入的条件，就返回 true。
• allMatch()，只有有一个元素不匹配传入的条件，就返回 false；如果全副匹配，则返回 true。
• noneMatch()，只有有一个元素匹配传入的条件，就返回 false；如果全副匹配，则返回 true。

public class MatchStreamDemo {public static void main(String[] args) {List<String> list = new ArrayList<>();
        list.add("周杰伦");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");

        boolean  anyMatchFlag = list.stream().anyMatch(element -> element.contains("王"));
        boolean  allMatchFlag = list.stream().allMatch(element -> element.length() > 1);
        boolean  noneMatchFlag = list.stream().noneMatch(element -> element.endsWith("沉"));
        System.out.println(anyMatchFlag);
        System.out.println(allMatchFlag);
        System.out.println(noneMatchFlag);
    }
}

因为“王力宏”以“王”字结尾，所以 anyMatchFlag 应该为 true；因为“周杰伦”、“王力宏”、“陶喆”、“林俊杰”的字符串长度都大于 1，所以 allMatchFlag 为 true；因为 4 个字符串结尾都不是“沉”，所以 noneMatchFlag 为 true。

程序输入的后果如下所示：

true
true
true

4）组合

reduce() 办法的次要作用是把 Stream 中的元素组合起来，它有两种用法：

• Optional<T> reduce(BinaryOperator<T> accumulator)

没有起始值，只有一个参数，就是运算规定，此时返回 [Optional][]。

• T reduce(T identity, BinaryOperator<T> accumulator)

有起始值，有运算规定，两个参数，此时返回的类型和起始值类型统一。

来看上面这个例子。

public class ReduceStreamDemo {public static void main(String[] args) {Integer[] ints = {0, 1, 2, 3};
        List<Integer> list = Arrays.asList(ints);

        Optional<Integer> optional = list.stream().reduce((a, b) -> a + b);
        Optional<Integer> optional1 = list.stream().reduce(Integer::sum);
        System.out.println(optional.orElse(0));
        System.out.println(optional1.orElse(0));

        int reduce = list.stream().reduce(6, (a, b) -> a + b);
        System.out.println(reduce);
        int reduce1 = list.stream().reduce(6, Integer::sum);
        System.out.println(reduce1);
    }
}

运算规定能够是 Lambda 表达式（比方 (a, b) -> a + b），也能够是类名:: 办法名（比方 Integer::sum）。

程序运行的后果如下所示：

6
6
12
12

0、1、2、3 在没有起始值相加的时候后果为 6；有起始值 6 的时候后果为 12。

03、转换流

既然能够把汇合或者数组转成流，那么也应该有对应的办法，将流转换回去——collect() 办法就满足了这种需要。

public class CollectStreamDemo {public static void main(String[] args) {List<String> list = new ArrayList<>();
        list.add("周杰伦");
        list.add("王力宏");
        list.add("陶喆");
        list.add("林俊杰");

        String[] strArray = list.stream().toArray(String[]::new);
        System.out.println(Arrays.toString(strArray));

        List<Integer> list1 = list.stream().map(String::length).collect(Collectors.toList());
        List<String> list2 = list.stream().collect(Collectors.toCollection(ArrayList::new));
        System.out.println(list1);
        System.out.println(list2);

        String str = list.stream().collect(Collectors.joining(",")).toString();
        System.out.println(str);
    }
}

toArray() 办法能够将流转换成数组，你可能比拟好奇的是 String[]::new，它是什么东东呢？来看一下 toArray() 办法的源码。

<A> A[] toArray(IntFunction<A[]> generator);

也就是说 String[]::new 是一个 IntFunction，一个能够产生所需的新数组的函数，能够通过反编译字节码看看它到底是什么：

String[] strArray = (String[])list.stream().toArray((x$0) -> {return new String[x$0];
});
System.out.println(Arrays.toString(strArray));

也就是相当于返回了一个指定长度的字符串数组。

当咱们须要把一个汇合依照某种规定转成另外一个汇合的时候，就能够配套应用 map() 办法和 collect() 办法。

List<Integer> list1 = list.stream().map(String::length).collect(Collectors.toList());

通过 stream() 办法创立汇合的流后，再通过 map(String:length) 将其映射为字符串长度的一个新流，最初通过 collect() 办法将其转换成新的汇合。

Collectors 是一个收集器的工具类，内置了一系列收集器实现，比如说 toList() 办法将元素收集到一个新的 java.util.List 中；比如说 toCollection() 办法将元素收集到一个新的 java.util.ArrayList 中；比如说 joining() 办法将元素收集到一个能够用分隔符指定的字符串中。

来看一下程序的输入后果：

[周杰伦, 王力宏, 陶喆, 林俊杰]
[3, 3, 2, 3]
[周杰伦, 王力宏, 陶喆, 林俊杰]
周杰伦, 王力宏, 陶喆, 林俊杰

原文链接

关注公众号:java 宝典