Java——Stream简单使用

转换

将字符串，数组，集合转换为Stream

       //字符串        Stream s1 = Stream.of("s","b","b");        //数组        String [] strArray = new String[] {"s", "b", "c"};        Stream s2 = Arrays.stream(strArray);        //集合         List<String> list =new ArrayList<>();        list.add("s");        list.add("d");        Stream s3 = list.stream();        //通过文件        Stream<String> stream = Files.lines(Paths.get("text.txt"), Charset.defaultCharset());

数值流
对于值都是，int，long，double的可以直接转换成IntStream、LongStream、DoubleStream；
数值流有更多的方法

        //数值流的构造        IntStream  s4= IntStream.of(new int[]{1, 2, 3});        //不包括右边值        IntStream s5= IntStream.range(1, 3);        //包括        LongStream s6= LongStream.rangeClosed(1, 3);

流转换为其它数据结构

 //转化为字符串      String cs= (String)s1.collect(Collectors.joining());      //转化为数组      s2.toArray();      //转化为集合      s3.collect(Collectors.toList());

常用的方法

在中间的操作：调用之后会产生新的Stream，可以继续使用
map—– (mapToInt, flatMap（形成新的流） )等将流中的元素映射成另外的值
filter—-（过滤，相当于if）
distinct-（去重）
sorted–（将流中的元素按照自然排序方式进行排序）
peek—-（对每个元素执行操作并返回一个新的 Stream）
limit，skip–limit 返回 Stream 的前面 n 个元素；skip 则是扔掉前 n 个元素 ,对 sorted 后的运行次数无影响
parallel
sequential
unordered
在终点的操作：即调用这些方法后不会产生新的Stream,也不能继续调用方法
forEach———-（forEach 方法接收一个 Lambda 表达式，然后在 Stream 的每一个元素上执行该表达式）
forEachOrdered
reduce———-把 Stream 元素组合起来，字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce
min、 max、 count、
findFirst、 findAny、
iterator—-跟 reduce 操作很像，接受一个种子值，和一个 UnaryOperator（例如 f）。然后种子值成为 Stream 的第一个元素，f(seed) 为第二个，f(f(seed)) 第三个，以此类推。
最少运算：
allMatch：Stream 中全部元素符合传入的 predicate，返回 true
anyMatch：Stream 中只要有一个元素符合传入的 predicate，返回 true
noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true

Collectors 类

java.util.stream.Collectors 类的主要作用就是辅助进行各类有用的 reduction 操作。
可以转变输出为 Collection，把 Stream 元素进行归组。

使用场景

过滤和排序

Stream.of(1, 8, 5, 2, 1, 0, 9, 2, 0, 4, 8)    .filter(n -> n > 2)     // 对元素过滤，保留大于2的元素    .distinct()             // 去重，类似于SQL语句中的DISTINCT    .skip(1)                // 跳过前面1个元素    .limit(2)               // 返回开头2个元素，类似于SQL语句中的SELECT TOP    .sorted()               // 对结果排序    .forEach(System.out::println);

查找和匹配

// 检查流中的任意元素是否包含字符串"Java"boolean hasMatch = Stream.of("Java", "C#", "PHP", "C++", "Python")        .anyMatch(s -> s.equals("Java"));// 检查流中的所有元素是否都包含字符串"#"boolean hasAllMatch = Stream.of("Java", "C#", "PHP", "C++", "Python")        .allMatch(s -> s.contains("#"));// 检查流中的任意元素是否没有以"C"开头的字符串boolean hasNoneMatch = Stream.of("Java", "C#", "PHP", "C++", "Python")        .noneMatch(s -> s.startsWith("C"));// 查找元素Optional<String> element = Stream.of("Java", "C#", "PHP", "C++", "Python")        .filter(s -> s.contains("C"))        // .findFirst()     // 查找第一个元素        .findAny();         // 查找任意元素

归约

// 获取流List<Book> books = Arrays.asList(       new Book("Java编程思想", "Bruce Eckel", "机械工业出版社", 108.00D),       new Book("Java 8实战", "Mario Fusco", "人民邮电出版社", 79.00D),       new Book("MongoDB权威指南（第2版）", "Kristina Chodorow", "人民邮电出版社", 69.00D));// 计算所有图书的总价Optional<Double> totalPrice = books.stream()       .map(Book::getPrice)       .reduce((n, m) -> n + m);// 价格最高的图书Optional<Book> expensive = books.stream().max(Comparator.comparing(Book::getPrice));// 价格最低的图书Optional<Book> cheapest = books.stream().min(Comparator.comparing(Book::getPrice));// 计算总数long count = books.stream().count()

//打印集合元素list.stream().forEach(System.out::println);`

//转换成大写List<String> output = wordList.stream().map(String::toUpperCase).collect(Collectors.toList());

// 留下偶数Integer[] sixNums = {1, 2, 3, 4, 5, 6};Integer[] evens =Stream.of(sixNums).filter(n -> n%2 == 0).toArray(Integer[]::new);

// 字符串连接，concat = "ABCD"String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat); // 求最小值，minValue = -3.0double 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);

//按照年龄归组Map<Integer, List<Person>> personGroups = Stream.generate(new PersonSupplier()). limit(100). collect(Collectors.groupingBy(Person::getAge));Iterator it = personGroups.entrySet().iterator();while (it.hasNext()) { Map.Entry<Integer, List<Person>> persons = (Map.Entry) it.next(); System.out.println("Age " + persons.getKey() + " = " + persons.getValue().size());}

//iterate生成等差数列Stream.iterate(0, n -> n + 3).limit(10). forEach(x -> System.out.print(x + " "));.

//找出全文的单词，转小写，并排序List<String> words = br.lines(). flatMap(line -> Stream.of(line.split(" "))). filter(word -> word.length() > 0). map(String::toLowerCase). distinct(). sorted(). collect(Collectors.toList());br.close();System.out.println(words);

标题

参考：https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/