JAVA8 Stream特性

package com;

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class TestJava8 {

    public static void main(String[] args) {
        /*流的构造与转换 
         *   一个 Stream 只可以使用一次
         *  */
        //Individual values
        Stream stream=Stream.of("a","c","b");
        //Arrays
        String[] strArray=new String[] {"a","c","b"};
        stream=Stream.of(strArray);
        stream.forEach(System.out::println);
        //Collections
        List<String> list=Arrays.asList(strArray);
        stream=list.stream();
        System.out.println("stream-->list:"+stream.map(n->n).collect(Collectors.toList()));
        //数值流的构造
        IntStream.of(new int[] {1,2,3}).forEach(System.out::println);
        System.out.println("-------");
        IntStream.range(1, 3).forEach(System.out::println);
        System.out.println("-------");
        IntStream.rangeClosed(1, 3).forEach(System.out::println);
        System.out.println("-------");
        //流转换为其他数据结构
        //1.Array  一个 Stream 只可以使用一次,否则会报错：stream has already been operated upon or closed
        Stream stream0=Stream.of("w","c","b");
        String[] strArray1=(String[]) stream0.toArray(String[]::new);
        //2.Collection   一个 Stream 只可以使用一次
        Stream stream2=Stream.of("a","c","b");
        List<String> list1=(List<String>) stream2.collect(Collectors.toList());
        //Set set1=(Set) stream0.collect(Collectors.toSet());
        //3.String
        //String str=stream0.collect(Collectors.joining()).toString();
        System.out.println("------->"+list1);
        
        /*转换大写*/
        List<String> wordList=Arrays.asList("a,x,s,q");
        List<String> upperList=wordList.stream().map(String::toUpperCase).collect(Collectors.toList());
        System.out.println(upperList);
        
        List<Integer> output=Arrays.asList(1,2,3,4);
                
        /*平方数   
         * map/flatMap
            我们先来看 map。如果你熟悉 scala 这类函数式语言，对这个方法应该很了解，它的作用就是把 input Stream 的每一个元素，映射成 output Stream 的另外一个元素。*/
        List<Integer> nums=output.stream()
                .map(n->n*n).collect(Collectors.toList());
        
        System.out.println(nums);
        
        /*一对多
         * flatMap把input Stream中的层级结构扁平化,就是将最底层元素抽出来放到一起,最终output的新Stream里面已没有List了,都是直接的数字
         * */
        Stream<List<Integer>> inputStream =Stream.of(
                                            Arrays.asList(1),
                                            Arrays.asList(2,3),
                                            Arrays.asList(4,5,6));
        Stream<Integer> outputStream=inputStream.flatMap((childList)->childList.stream());
        System.out.println("outputStream--->"+outputStream.map(n->n).collect(Collectors.toList()));
        
        //filter 留下偶数
        Integer[] sixNums= {1,2,3,4,5,6};
        Integer[] evens=Stream.of(sixNums).filter(n->n%2==0).toArray(Integer[]::new);
        System.out.println(Stream.of(evens).map(n->n).collect(Collectors.toList()));
        
    }
}