JDK8 stream操作

/** * java.util.Stream表示了某一种元素的序列，在这些元素上可以进行各种操作。Stream 操作可以是中 * 间操作，也可以是完结操作。完 结操作会返回一个某种类型的值，而中间操作会返回流对象本身，并且你 * 可以通过多次调用 StringBuffer 的append方法一样）。Stream是在一个源的基础上创建出来的，例如java.util.Collection中的list或者 set * （map不能作为Stream的源）。Stream 操作往往可以通过顺序或者并行两种方式来执行。  * @author wind * */public class Streams {   static List<String> lists = new ArrayList<>();   static {      lists.add("1");      lists.add("2");      lists.add("3");      lists.add("3");      lists.add("follow");      lists.add("wind");      lists.add("followwwind");   }      /**    * 数组，集合等数据源转换成stream    */   public static void baseStream() {      System.err.println("----------------------------SourceData 转换Stream-----------------------------");      // 1. Individual values      Stream<String> s = Stream.of("a", "b", "c");      // 2. Arrays      String [] strArray = new String[] {"a", "b", "c"};      Stream<String> arrs = Stream.of(strArray);      // 3. Collections      List<String> list = Arrays.asList(strArray);      Stream<String> lists = list.stream();      System.out.println(s);      System.out.println(arrs);      System.out.println(lists);      // 4. iterate       Stream.iterate(0, n -> n + 3).limit(10).forEach(x -> System.out.print(x + " "));  // 0 3 6 9 12 15 18 21 24 27      System.out.println();      // 5. generate      //String[] strArr = Stream.generate(() -> "test").limit(10).toArray(String[]::new);      String joinStr = Stream.generate(() -> "test").limit(10).collect(Collectors.joining(","));      System.out.println(joinStr);      // 6. From Popular APIs      String sentence = "Program creek is a Java site.";        Stream<String> wordStream = Pattern.compile("\\W").splitAsStream(sentence);        String[] wordArr = wordStream.toArray(String[]::new);        System.out.println(Arrays.toString(wordArr));      System.err.println("----------------------------SourceData 转换Stream-----------------------------");   }      /**    * 中间操作(Intermediate) 转换Stream    */   public static void middleStream(){      System.err.println("----------------------------中间操作 转换Stream-----------------------------");            //去除重复 distinct      lists.stream().distinct().forEach(p -> System.out.print(p + "\t"));  //1   2  3  follow wind   followwwind      System.out.println();            //过滤元素 filter      lists.stream().filter(p -> p.length() > 1).forEach(p -> System.out.print(p + "\t")); //follow  wind   followwwind      System.out.println();            // sorted 流排序,中间操作返回流本身      lists.stream().filter(str -> str.contains("w"))      .sorted((str1, str2) -> {         if (str1.length() == str2.length()) {            return 0;           } else if (str1.length() > str2.length()) {            return 1;         } else {            return -1;         }      }).forEach(System.out::println);  //wind follow followwwind                //limit 对一个Stream进行截断操作，获取其前N个元素，如果原Stream中包含的元素个数小于N，那就获取其所有的元素；      lists.stream().limit(5).forEach(p -> System.out.print(p + "\t")); //1  2  3  3  follow       System.out.println();            //skip 返回一个丢弃原Stream的前N个元素后剩下元素组成的新Stream，如果原Stream中包含的元素个数小于N，那么返回空Stream；      lists.stream().skip(5).forEach(p -> System.out.print(p + "\t")); //wind    followwwind      System.out.println();            //peek 生成一个包含原Stream的所有元素的新Stream，同时会提供一个消费函数（Consumer实例），新Stream每个元素被消费的时候都会执行给定的消费函数；      lists.stream().peek(p -> {p = p.toUpperCase(); System.out.println(p);}).forEach(System.out::println);       System.out.println();            //转换元素 map      lists.stream().map(p -> p + "-->").forEach(System.out::print); // 1-->2-->3-->3-->follow-->wind-->followwwind-->      System.out.println("end");      lists.stream().map(p -> p.split(" ")).map(p -> p[0] + "\t").forEach(System.out::print);//1 2  3  3  follow wind   followwwind      System.out.println();      lists.stream().map(p -> p.split("")).map(p -> {         String tmp = "";         if(p.length > 1){            tmp = p[1];         }else{            tmp = p[0];         }         return tmp + "\t";      }).forEach(System.out::print); //1 2  3  3  o  i  o      System.out.println();      lists.stream().filter(p -> p.matches("\\d+")).mapToInt(p -> Integer.valueOf(p)).forEach(p -> System.out.print(p + "\t"));//1   2  3  3      System.out.println();            // flatMap 和map类似，不同的是其每个元素转换得到的是Stream对象，会把子Stream中的元素压缩到父集合中      lists.stream().flatMap(p -> Stream.of(p.split("www"))).forEach(p -> System.out.print(p + "\t"));      //1     2 3  3  follow wind   follo  ind      Stream<List<Integer>> inputStream = Stream.of(          Arrays.asList(1),          Arrays.asList(2, 3),          Arrays.asList(4, 5, 6)       );      System.out.println();      Stream<Integer> outputStream = inputStream.      flatMap((childList) -> childList.stream());      outputStream.forEach(p -> System.out.print(p + "\t")); //1 2  3  4  5  6      System.out.println();      System.err.println("----------------------------中间操作 转换Stream-----------------------------");   }      /**    * 终端操作(Terminal) Stream    */   public static void endStream(){      System.err.println("----------------------------终端操作 Terminal Stream-----------------------------");      //forEach      lists.stream().forEach(System.out::print);      System.out.println();      //match 流匹配,终结操作      System.out.println(lists.stream().allMatch(str -> str.length() == 3));// false      System.out.println(lists.stream().anyMatch(str -> str.length() > 5));// true      System.out.println(lists.stream().noneMatch(str -> str.length() > 5));// false      //count      System.out.println(lists.stream().count());  //7      //reduce      Optional<String> reOptional = lists.stream().reduce((str, str2) -> str + "-->" + str2);      reOptional.ifPresent(System.out::println); //1-->2-->3-->3-->follow-->wind-->followwwind      lists.stream().filter(p -> p.matches("\\d+")).mapToInt(p -> Integer.valueOf(p)).reduce(Integer::sum).ifPresent(System.out::println);            //collect      List<String> ll = lists.stream().collect(Collectors.toList());      System.out.println(ll);  //[1, 2, 3, 3, follow, wind, followwwind]      lists.stream().collect(Collectors.maxBy((p1, p2) -> p1.compareTo(p2))).ifPresent(System.out::println); //wind      lists.stream().collect(Collectors.minBy((p1, p2) -> p1.compareTo(p2))).ifPresent(System.out::println); //1      int s = lists.stream().filter(p -> p.matches("\\d+")).collect(Collectors.summingInt(p -> Integer.valueOf(p)));      System.out.println(s);  //9      String liString = lists.stream().collect(Collectors.joining(","));       System.out.println(liString);  //1,2,3,3,follow,wind,followwwind      //sum      int sum = lists.stream().filter(p -> p.matches("\\d+")).mapToInt(p -> Integer.valueOf(p)).sum(); //9      System.out.println(sum);      //findFirst      Optional<String> firstOptional = lists.stream().findFirst();      firstOptional.ifPresent(System.out::println);  //1      Stream.of().findFirst().ifPresent(System.out::println); //不返回任何值      //findAny 不一定返回第一个，而是返回任意一个,在并行流式处理中使用findAny的性能要比findFirst好      lists.stream().findAny().ifPresent(System.out::println);      //lists.stream().filter(p -> "3".equals(p));      System.err.println("----------------------------终端操作 Terminal Stream-----------------------------");   }   public static void main(String[] args) {      baseStream();      //middleStream();      //endStream();   }}