java8中Stream块粗解

集合stream流的基本使用：
1、构造流的常用方法
// 1. Individual values
Stream stream = Stream.of(“a”, “b”, “c”);
// 2. Arrays
String [] strArray = new String[] {“a”, “b”, “c”};
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
// 3. Collections
List list = Arrays.asList(strArray);
stream = list.stream();

**数值流的构造**
IntStream.of(new int[]{1, 2, 3}).forEach(System.out::println);
把新的数组放在数值流中，用forEach进行循环
IntStream.range(1, 3).forEach(System.out::println);
range是有2个参数（开始值，结束值），生成的数值流中不包括结束值
IntStream.rangeClosed(1, 3).forEach(System.out::println);
rangeClosed和range相似，但生成的数值流包括结束值

**流转换成其他数据类型**
字符串数组：
String [] strArray = new String[] {"a", "b", "c"};
Stream<String> stream  = Arrays.stream(strArray);
String[] strArray1 = stream.toArray(String[]::new);
System.out.println(strArray1.length);
stram必须是固定数据类型的，因为toArray返回的是object类型的

**字符串list：**
List<String> list1 = stream.collect(Collectors.toList());
List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
set：
Set set1 = stream.collect(Collectors.toSet());
Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));

**字符串：**
String str = stream.collect(Collectors.joining()).toString();
把集合顺序拼接起来赋值给字符串

对集合中元素进行处理（例子为转大写）：
List<String> wordList = new ArrayList();
wordList.add("k");
wordList.add("e");
String output = wordList.stream().map(String::toUpperCase).collect(Collectors.joining());
List<String> output = wordList.stream().map(String::toUpperCase).collect(Collectors.toList();
stream的map方法可以对集合进行遍历，参数（类::方法）


filter是stream块中起到过滤作用的api：
Integer[] sixNums = {1, 2, 3, 4, 5, 6};
Integer[] evens = Stream.of(sixNums).filter(n -> n%2 == 0).toArray(Integer[]::new);


**forEach是对元素的遍历**
// Java 8
roster.stream()
 .filter(p -> p.getGender() == Person.Sex.MALE)
 .forEach(p -> System.out.println(p.getName()));
 
 findFirst：它总是返回 Stream 的第一个元素，或者空。
 
 redure作用是把stream元素组合起来：
 // 字符串连接，concat = "ABCD"
String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat); 
// 求最小值，minValue = -3.0
double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min); 
// 求和，sumValue = 10, 有起始值
int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
// 求和，sumValue = 10, 无起始值
sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
// 过滤，字符串连接，concat = "ace"
concat = Stream.of("a", "B", "c", "D", "e", "F"). filter(x -> x.compareTo("Z") > 0). reduce("", String::concat);


limit/skip：limit 返回 Stream 的前面 n 个元素；skip 则是扔掉前 n 个元素


**sorted排序：**
List<Person> persons = new ArrayList();
for (int i = 5; i >= 0; i--) {
 Person person = new Person(i, "name" );
 persons.add(person);
 }
List<Person> personList2 = persons.stream().limit(2).sorted((p1, p2) -> p1.getName().compareTo(p2.getName())).collect(Collectors.toList());
System.out.println(personList2.toString());
.compareTo是比较2个字符串的ASCII码


**min/max/distinct：**
int longest = br.lines().
mapToInt(String::length).
max().
getAsInt();
distinct 来找出不重复


**Match：**
allMatch：Stream 中全部元素符合传入的 predicate，返回 true
anyMatch：Stream 中只要有一个元素符合传入的 predicate，返回 true
noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true

List<Person> persons = new ArrayList();
persons.add(new Person(1, "name" + 1, 10));
persons.add(new Person(2, "name" + 2, 21));
persons.add(new Person(3, "name" + 3, 34));
persons.add(new Person(4, "name" + 4, 6));
persons.add(new Person(5, "name" + 5, 55));
boolean isAllAdult = persons.stream().
 allMatch(p -> p.getAge() > 18);
System.out.println("All are adult? " + isAllAdult);
boolean isThereAnyChild = persons.stream().
 anyMatch(p -> p.getAge() < 12);
System.out.println("Any child? " + isThereAnyChild);


**留白:Stream.generate自己生成流**
Random seed = new Random();
Supplier<Integer> random = seed::nextInt;
Stream.generate(random).limit(10).forEach(System.out::println);