Java SE 8 流库（二）

1.3. filter,map,flatMAP方法

流的转换会产生一个新流，它的元素派生出自另一个流中的元素；

Stream<T> filter(Predicate<? super T> predicate) 返回一个包含此流中与某种条件相匹配的流

<R> Stream<R> map(Function<? super T,? extends R> mapper) 返回由将给定函数应用于此流的元素的结果组成的流。

<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper) 返回一个流，该流包含将此流的每个元素替换为通过将所提供的映射函数应用于每个元素而生成的映射流的内容的结果。每个映射流在其内容被放置到这个流之后关闭（如果映射流为空，则使用空流）。

1.3.1. filter方法

Filter转换产生一个新流，它的元素与某种条件相匹配；

 String contents = new String(Files.readAllBytes(Paths.get(filePath)), StandardCharsets.UTF_8);

         List<String> words = Arrays.asList(contents.split("\\PL+"));

         //filter转换会产生一个流(值包含长单词的另一个流)

         Stream<String> newStream = words.stream()

                 .filter(w -> w.length() > 6);

1.3.2. map方法

在使用map时，会有一个函数应用到每个元素上，并且其结果包含了应用该函数后所产生的所有结果流；

 String contents = new String(Files.readAllBytes(Paths.get(filePath)), StandardCharsets.UTF_8);

         List<String> words = Arrays.asList(contents.split("\\PL+"));

        //map按照某种方式来转换流中的值

         Stream<String> mapStream = words.stream().map(String::toUpperCase);

         List<String> list = mapStream.limit(10)

                 .collect(Collectors.toList());

         for(int i=0;i<list.size();i++){

             System.out.println(list.get(i));

         }

1.3.3. flatmap方法

 String contents = new String(Files.readAllBytes(Paths.get(filePath)), StandardCharsets.UTF_8);

         List<String> words = Arrays.asList(contents.split("\\PL+"));

 Stream<String> result = words.stream()

                 .flatMap(w -> letters(w));

 show(result);

 public static Stream<String> letters(String s){

         ArrayList<String> result = new ArrayList<>();

         for(int i=0;i<s.length();i++){

             result.add(s.substring(i,i+1));

         }

         return result.stream();

     }

     public static <T> void show( Stream<T> stream){

         List<T> list = stream.limit(10)

                 .collect(Collectors.toList());

         for(int i=0;i<list.size();i++){

             System.out.println(list.get(i));

         }

     }

1.4. 抽取子流和连接流

Stream<T> limit(long maxSize) 返回由此流的元素组成的流，截断长度不超过maxSize。

Stream<T> skip(long n) 丢弃流的前n个元素之后，返回由该流的其余元素组成的流。如果这个流包含少于n个元素，那么将返回一个空的流。

static <T> Stream<T> concat(Stream<? extends T> a,Stream<? extends T> b) 创建一个延迟连接的流，其元素是第一个流的所有元素，后跟第二个流的所有元素。如果两个输入流都是有序的，则生成的流是有序的;如果任意一个输入流是并行的，则生成的流是并行的。当结果流关闭时，调用两个输入流的关闭处理程序。

 /**

  * Created by Lenovo on 2017/12/18.

  * 抽取子流和链接流

  */

 public class Demo07 {

     private static final String filePath = "G:\\Idea\\src\\com\\itheima05\\Test_JavaSE\\Test_20171214\\word.txt";

     public static void main(String[] args) throws Exception {

         String contents = new String(Files.readAllBytes(Paths.get(filePath)), StandardCharsets.UTF_8);

         List<String> words = Arrays.asList(contents.split("\\PL+"));

         //包含有10个随机数的流

         Stream<Double> random = Stream.generate(Math::random).limit(10);

         show(random);

         //split,丢弃前n个元素

         Stream<String> skip = words.stream().skip(5);

         show(skip);

         //concat将两个流连接起来

         Stream<String> concat = Stream.concat(letters("Hello"), letters("World"));

         show(concat);

     }

     public static <T> void show( Stream<T> stream){

         List<T> list = stream.limit(10)

                 .collect(Collectors.toList());

         for(int i=0;i<list.size();i++){

             System.out.println(list.get(i));

         }

     }

     public static Stream<String> letters(String s){

         ArrayList<String> result = new ArrayList<>();

         for(int i=0;i<s.length();i++){

             result.add(s.substring(i,i+1));

         }

         return result.stream();

     }

 }

1.5. 其他流转换

Stream<T> distinct() 返回由此流的不同元素（根据Object.equals（Object））组成的流。

Stream<T> sorted() 返回由此流的元素组成的流，按照自然顺序排序。如果此流的元素不是Comparable，执行终端操作时可能会抛出java.lang.ClassCastException。

Stream<T> peek(Consumer<? super T> action) 返回由此流的元素组成的流，另外对每个元素执行提供的操作，因为元素将从结果流中消耗。这是一个中间操作。

 /**

  * Created by Lenovo on 2017/12/18.

  * 其他转换流

  */

 public class Demo06 {

     public static void main(String[] args) {

         //将原有的流去重,获取一个新流

         Stream<String> distinct = Stream.of("aaa", "bbb", "ccc", "sss", "aaa").distinct();

         show(distinct);

         //sorted,倒序排序

         Stream<String> sorted = Stream.of("aaa", "aa", "aaaa", "a", "aaaaa")

                 .sorted(Comparator.comparing(String::length).reversed());

         show(sorted);

         //peek

         Object[] peek = Stream.iterate(1.0, p -> p * 2)

                 .peek(e -> System.out.println("fetching" + e))

                 .limit(20).toArray();

         for(int i = 0;i<peek.length;i++){

             System.out.println(peek[i]);

         }

     }

     public static <T> void show(Stream<T> stream){

         List<T> tList = stream.limit(10).collect(Collectors.toList());

         for(int i =0;i<tList.size();i++){

             System.out.println(tList.get(i));

         }

     }

 }

结果输出：

 aaa

 bbb

 ccc

 sss

 aaaaa

 aaaa

 aaa

 aa

 a

 fetching1.0

 fetching2.0

 fetching4.0

 fetching8.0

 fetching16.0

 fetching32.0

 fetching64.0

 fetching128.0

 fetching256.0

 fetching512.0

 fetching1024.0

 fetching2048.0

 fetching4096.0

 fetching8192.0

 fetching16384.0

 fetching32768.0

 fetching65536.0

 fetching131072.0

 fetching262144.0

 fetching524288.0

1.6.简单约简

约简是一种终结操作，它们会将流约简为可以在程序中使用的非流值；

例如：count,max,min都是简单约简，这些返回的是一个数据类型Optional<T>

Optional<T> max(Comparator<? super T> comparator) 根据提供的比较器返回此流的最大元素。

Optional<T> min(Comparator<? super T> comparator) 根据提供的比较器返回此流的最小元素。

Optional<T> findAny() 返回一个描述流的某个元素的可选项，如果流为空，则返回一个空的可选项。

Optional<T> findFirst() 返回描述此流的第一个元素的可选项，如果流为空，则返回一个空的可选项。如果流没有遇到命令，则可以返回任何元素；

noneMatch和allMatch它们分别会在所有元素和没有任何元素匹配断言的情况下返回true

boolean allMatch(Predicate<? super T> predicate)

boolean noneMatch(Predicate<? super T> predicate)

boolean anyMatch(Predicate<? super T> predicate)

 /**

  * Created by Lenovo on 2017/12/20.

  * java.util.Optional<T>

  * public T orElse(T other) 返回值如果存在，否则返回其他。

  * java.lang.String

  * public int compareToIgnoreCase(String str) 按字母顺序比较两个字符串，忽略大小写的差异。

  *

  */

 public class Demo08 {

     private static final String filePath = "G:\\Idea\\src\\com\\itheima05\\Test_JavaSE\\Test_20171214\\word.txt";

     public static void main(String[] args) throws Exception {

         String contents = new String(Files.readAllBytes(Paths.get(filePath)), StandardCharsets.UTF_8);

         List<String> words = Arrays.asList(contents.split("\\PL+"));

         //获取流中的最大值

         Optional<String> largest = words.stream().max(String::compareToIgnoreCase);

         System.out.println("largest:"+largest.orElse(""));

         //显示已字母为"Q"开头的单词

         Optional<String> firstWords = words.stream().filter(s -> s.startsWith("Q")).findFirst();

         System.out.println("firstWords:"+firstWords.orElse(""));

         //显示有字母为"Q"的单词

         Optional<String> anyWords = words.stream().filter(s -> s.startsWith("Q")).findAny();

         System.out.println("anyWords:"+anyWords.orElse(""));

         //判断是否匹配

         boolean anyMatch = words.parallelStream().anyMatch(s -> s.startsWith("Q"));

         System.out.println("anyMatch:"+anyMatch);

         boolean noneMatch = words.parallelStream().noneMatch(s -> s.startsWith("Q"));

         System.out.println("noneMatch:"+noneMatch);

         boolean allMatch = words.parallelStream().allMatch(s -> s.startsWith("Q"));

         System.out.println("allMatch:"+allMatch);

     }

 }