java8之流

package com.lyzx.concurrent.java8.stream;
 
import org.junit.Test;
import javax.sound.midi.Soundbank;
import javax.swing.plaf.synth.SynthOptionPaneUI;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;
 
public class Day01 {
    private static List<String> data = Arrays.asList("A","B","C","AA","BB","CC","a","b","c","aa","bb","cc");
    private static List<String> data2 = Arrays.asList("E","F","G","EE","FF","GG","e","f","g","ee","ff","gg");
    private static List<String> data3 = Arrays.asList("E1 E2 E3 E4 E5","F F","G G","e e","f f ","g g","A A");
 
    /**
     * filter  过滤
     * forEach 遍历
     */
    @Test
    public void streamTest1(){
        data.stream()
                .filter(x->x.length()>1)
//                .forEach(x-> System.out.println(x))
                .forEach(System.out  :: println);
    }
 
 
    /**
     * 1、一个流只能别使用一次!
     * 2、每次调用一次stream()返回的流不是同一个
     * 3、流不改变原始数据
     */
    @Test
    public void streamTest2(){
        Stream<String> s1 = data.stream();
        Stream<String> s2 = data.stream();
        Stream<String> s3 = data.stream();
        System.out.println(s1 == s2);
        System.out.println(data);
        //表示是否全部匹配
        boolean b1 = s1.allMatch(x -> x.length() > 1);
        //表示是否有一个匹配
        boolean b2 = s2.anyMatch(x -> x.length() > 1);
        boolean b3 = s3.noneMatch(x -> x.length() > 2);
        System.out.println(b1 +" "+b2+"  "+b3);
    }

    /**
     * 1、Stream.concat(s1,s2) 连接某两个流
     * 2、count返回当前流中含有的记录的条数
     */
    @Test
    public void streamTest3(){
        Stream.concat(data.stream(),data2.stream())
                .filter(x->x.length()>1)
                .forEach(System.out::println);
 
 
        long count = Stream.concat(data.stream(),data2.stream()).filter(x->x.length()>1).count();
        System.out.println(count);
    }
 
    @Test
    public void streamTest4(){
        for(int i=0;i<50;i++){
            Optional<String> op = data.stream().parallel().findAny();
            if(op.isPresent())
                System.out.println(op.get());
        }
    }
 
    /**
     * 1、flatMap把一个元素可以转换为多个元素,把最后的结果压扁了放在一个流中,其中间结果是Stream
     * 2、map把一个元素E转换为多个元素C(E)，这多个元素就在一个迭代器中，即有多少个E元素就有多少个迭代器
     * ("E1 E2 E3 E4 E5","F F","G G","e e","f f ","g g");
     */
    @Test
    public void streamTest5(){
        data3.stream()
                .flatMap(x->Arrays.asList(x.split(" ")).stream())
                .forEach(x-> System.out.print(x+"  "));
 
 
        System.out.println("===================");
        data3.stream().mapToInt(x->x.length()).forEach(x-> System.out.print(x+"  "));
    }
 
    /**
     * forEachOrdered 顺序遍历
     * forEach  并行遍历
     */
    @Test
    public void streamTest6(){
        List<String> data4 = Arrays.asList("K","J","I","H","G","F","E","D","C", "B", "A");
        data4.stream().parallel().forEachOrdered(x-> System.out.print("  "+x));
        System.out.println();
        data4.stream().parallel().forEach(x-> System.out.print("  "+x));
    }
 
    /**
     * 1、limit 截断N个元素
     * 2、noneMatch表示是否没有元素匹配
     */
    @Test
    public void streamTest7(){
        data2.stream().filter(x->x.length()>1)
                .limit(2).forEach(System.out :: println);
    }
 
    /**
     * 1、sorted按照自然顺序排序
     * 2、skip(N) 跳过前N个，如果N大于元素的总长度则返回空流
     */
    @Test
    public void streamTest8(){
        Stream.of("C","B","A")
                .sorted()
                .forEach(System.out :: println);
 
        System.out.println("====================");
        Stream.of("1","2","3","4","5","6","7","8","9","10")
                .skip(40)
                .forEach(System.out :: println);
    }
 
    @Test
    public void streamTest9(){
        List<Integer> data4 = Arrays.asList(1,2,3);
 
 
        Optional<Integer> op = data4.stream().reduce((x, y) -> x + y);
        if(op.isPresent())
            System.out.println(op.get());
        else
            System.out.println("nothing....");
 
        Integer r2 = data4.stream().reduce(100,(x, y) -> x + y);
        System.out.println(r2);
 
        Integer r3 = data4.stream()
//                .map(x->x+10)
                .reduce(0,(x,y)->x+y,(x,y)->x*y);
        System.out.println(r3);
    }
}