Java学习(尚硅谷)StreamAPI学习

package com.atguigu.java2;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.IntStream;
import java.util.stream.Stream;


public class StreamAPITest {
    //创建Stream方式一：通过集合
    @Test
    public void test1(){
        ArrayList list=new ArrayList<>();
        //default Stream stream():返回一个顺序流:顺序取数据
        Stream stream = list.stream();

        //default Stream parallelStream():返回一个并行流：并行取数据
        Stream parallelStream = list.parallelStream();

    }
    //创建Stream方式二：通过数组
    @Test
    public void test2(){
        int[] arr=new int[]{1,2,3,4,5,6};
        //调用Arrays类 的static Stream stream(T[] array):返回一个流
        IntStream stream = Arrays.stream(arr);

    }
    //创建Stream方式三：通过Stream的of()
    @Test
    public void test3(){
        Stream stream = Stream.of(1, 2, 3, 4, 5, 6);
    }
    //创建Stream方式四：创建无限流
    @Test
    public void test4(){
        //迭代
        //public static Stream iterate(final T seed,final UnaryOperator f)
        //遍历前十个偶数
        Stream.iterate(0,t->t+2).limit(10).forEach(System.out::println);


        //生成
        //public static Stream generate(Supplier s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }

}

package com.atguigu.java2;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import java.util.stream.Stream;


public class StreamAPITest1 {
    //1.筛选与切片
     @Test
    public void test1(){
         ArrayList list=new ArrayList<>();
         //filter(Predicate p) 接收Lambda，从流中排除某些元素
         Stream stream = list.stream();
//        stream.filter(e->e.getSalary()>7000).forEach(System.out::println);

         //limit(n):截断流，使其元素不超过给定数量
         list.stream().limit(3).forEach(System.out::println);

         //skip(n):跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流，
         list.stream().skip(3).forEach(System.out::println);

         //distinct():筛选，通过流所生成元素的hashCode()和equals()去除重复元素
         list.stream().distinct().forEach(System.out::println);
     }

     //2.映射
     @Test
    public void test2(){
         //map(Function f)
         List list = Arrays.asList("AA", "BB", "CC");
         list.stream().map(str->str.toLowerCase(Locale.ROOT)).forEach(System.out::println);

         //练习：
         Stream> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);

         streamStream.forEach(s->{
             s.forEach(System.out::println);
                 }

                 );

         //flatMap(Function f):接收一个函数作为参数，将流中的每一个值都换成另一个流，然后把所有的流连成一个流
         System.out.println();
         Stream characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
         characterStream.forEach(System.out::println);
     }

     //将字符串中多个字符构成的集合转换为对应的Stream的实例
     public static Stream fromStringToStream(String str){
         ArrayList list=new ArrayList<>();
         for (Character c:str.toCharArray()){
             list.add(c);
         }
        return list.stream();
     }

     //3.排序
    @Test
    public void test3(){
         //sorted():自然排序

        List list = Arrays.asList(12, 45, 78, 9, 87, 32);
        list.stream().sorted().forEach(System.out::println);
        //sorted(Comparator com):定制排序
        List list1 = Arrays.asList(12, 45, 78, 9, 87, 32);
        //按照年龄排序
//        list1.stream().sorted((e1,e2)->Integer.compare(e1.getAge,e2.getAge)).forEach(System.out::println);

    }
}

package com.atguigu.java2;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;


public class StreamAPITest2 {

    //1.匹配与查找
    @Test
    public void test(){
        //allMatch(Predicate p) 所有符合返回true
        ArrayList list=new ArrayList<>();
//        boolean allMatch = list.stream().allMatch(e -> e.getAge() > 18);
        //anyMatch(Predicate p) 任意一个符合返回true
//        list.stream().anyMatch(e->e.getSalary()>10000);
        //noneMatch(Predicate p) 没有符合的返回true
//        boolean noneMatch = list.stream().noneMatch(e -> e.getName.startWith("雷"));

        //findFirst:返回第一个元素
        Optional first = list.stream().findFirst();

        //findAny():返回任意一个元素
        Optional any = list.stream().findAny();

        //count:返回流中元素的总个数
        long count = list.stream().count();

        //max(Comparator c)：返回流中最大值
//        Stream