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.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);

//按照年龄归组
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/