Java学习记录14

Stream流是为了解放程序员操作集合（Collection)时的生产力。它类似于一个高级的迭代器，但只能遍历一次。

要想操作流，需要有一个数据源，可以是数组或者集合。每次操作都会返回一个新的流对象，但原有的流对象会保持不变。

流的操作可分为两种类型：

1.中间操作，可以有多个，每次返回一个新的流，可进行链式操作。

2.终端操作，只能有一个，执行完不能执行下一个操作，只能放在最后。

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

stream流中用到了一些接口：

Predicate    （接受一个输入参数返回一个布尔值结果）类型的参数。
Consumer（Java 8 新增的一个函数式接口，接受一个输入参数并且无返回的操作）类型的参数。
Function（Java 8 新增的一个函数式接口，接受一个输入参数 T，返回一个结果 R）类型的参数。
 

Stream流常用方法总结

创建流

如果是数组的话，可以使用Arrays.stream 或Stream.of,集合可以直接使用stream()，因为该方法已经添加到Collection接口中。

String[] arr = new String[]{"长沙","武汉","广东"};
Stream<String> arr1 = Stream.of(arr);
arr1.forEach(System.out::println); //长沙 武汉 广东
Arrays.stream(arr).forEach(System.out::println); //长沙 武汉 广东

具体方法

distinct()

返回由该流的不同元素（根据Object.equals(Object)）组成的流。

ArrayList<String> list = new ArrayList<>();
list.add("武汉");
list.add("广东");
list.add("长沙");
list.add("武汉");
list.stream().distinct().forEach(System.out::println); //武汉 广东 长沙

count()

返回此流中元素的计数。

ArrayList<String> list = new ArrayList<>();
list.add("武汉");
list.add("广东");
list.add("长沙");
list.add("武汉");
System.out.println(list.stream().count()); //4

filter(Predicate<? super T> predicate)

返回一个流，该流由与给定谓词匹配的此流的元素组成。

ArrayList<String> list = new ArrayList<>();
list.add("武汉");
list.add("广东");
list.add("长沙");
list.add("武汉");
list.stream().filter(s -> s.endsWith("汉")).forEach(System.out::println);// 武汉 武汉

forEach(Consumer<? super T> action)

对此流的每个元素执行一个操作。

ArrayList<String> list = new ArrayList<>();
list.add("武汉");
list.add("广东");
list.add("长沙");
list.add("武汉");
list.stream().forEach(System.out::println);

map(Function<? super T, ? extends R> mapper)

返回一个流，该流由将给定函数应用于此流的元素的结果组成。

ArrayList<String> list = new ArrayList<>();
list.add("武汉");
list.add("广东");
list.add("长沙");
list.add("武汉");
list.stream().map(s -> s.length()).forEach(System.out::println);

anyMatch()

返回此流的任何元素是否与提供的谓词匹配。

allMatch()

返回此流的所有元素是否与提供的谓词匹配。

noneMatch()

返回此流中是否没有元素与提供的谓词匹配。

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); //true
System.out.println(allMatchFlag); //true
System.out.println(noneMatchFlag); //true

reduce()

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

Optinal<T> reduce(BinaryOperator<T> accumulator)

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

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

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

Integer[] ints = {0, 1, 2, 3, 4};
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.get()); //10
System.out.println(optional1.get()); //10

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

collect(Collector<? super T,A,R> collector)

使用Collector对此流的元素执行可变减少操作。

String[] strings = new String[] {"武汉","长沙","广东"};
List<String> collect = Arrays.stream(strings).collect(Collectors.toList());
System.out.println(collect.toString()); //[武汉, 长沙, 广东]

List<String> list = Stream.of(strings).toList();
System.out.println(list.toString());    //[武汉, 长沙, 广东]

toArray(IntFunction<A[]> generator)

返回一个包含此流元素的数组，使用提供的generator函数分配返回的数组，以及分区执行或调整大小可能需要的任何其他数组。

List<String> list = new ArrayList<>();
list.add("武汉");
list.add("长沙");
list.add("广东");
String[] array = list.stream().toArray(String[]::new);
System.out.println(Arrays.toString(array)); //[武汉, 长沙, 广东]

sorted(Comparator<? super T> comparator)

返回一个流，该流由该流的元素组成，并按自然顺序排序。

int[] nums = new int[]{7,11,8,10,5};
int[] array = Arrays.stream(nums).sorted().toArray();
System.out.println(Arrays.toString(array)); //[5, 7, 8, 10, 11]

limit(long maxSize)

返回由该流的元素组成的流，截断后的长度不超过maxSize。

int[] nums = new int[]{7,11,8,10,5};
int[] array = Arrays.stream(nums).limit(3).toArray();
System.out.println(Arrays.toString(array)); //[7, 11, 8]