StreamAPI--中间操作

惰性求值

多个中间操作可以连接起来行程一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”

筛选与切片

filter(Predicate p)—接收lambda，从流中排除某些元素

//filter(Predicate p)----接收Lambda,从流中排除某些元素
//内部迭代：迭代操作由StrameAPI来完成
@Test
public void test2(){
    Stream<Employee> stream = list.stream().filter((e) ->{
        System.out.println("StreamApi的中间操作");
        return e.getAge() > 35;
    });

    //终止操作
    stream.forEach(System.out::println);
}

//外部迭代
@Test
public void test3(){
    Iterator<Employee> iter = list.iterator();

    while (true){
        System.out.println(iter.next());
    }
}

limit—截断流,使其元素不超过给定数量

 //limit----截断流,使其元素不超过给定数量
@Test
public void test4(){
    list.stream().filter((x) -> {
                System.out.println("短路");
                 return x.getSalary()>5000;
             })
            .limit(2)
            .forEach(System.out::println);
    /**
     * 短路
        Employee{name='张三', age=18, salary=9999}
        短路
        Employee{name='李四', age=59, salary=6666}
     */
}

skip—跳过元素,返回一个扔掉了前n个元素的流.若流中元素不满 足n个，则返回空流.与limit(n)互补

//skip----跳过元素,返回一个扔掉了前n个元素的流.若流中元素不满足n个，则返回空流.与limit(n)互补
@Test
public void test5(){
    list.stream().filter((x) -> x.getSalary()>5000)
                 .skip(2)
                 .forEach(System.out::println);
    /**
     * Employee{name='赵六', age=8, salary=7777}
       Employee{name='田七', age=38, salary=5555}
     */
}

distinct—通过流所生成元素的hashcode()和equals()去除重复元素

//distinct----通过流所生成元素的hashcode()和equals()去除重复元素
@Test
public void test6(){
    list.stream().filter((x) -> x.getSalary()>5000)
                 .skip(2)
                 .distinct().forEach(System.out::println);
}

映射

map—接收lambda,将元素转换成其他形式或提取信息.接收另一 个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个 新元素

//map----接收lambda,将元素转换成其他形式或提取信息.接收另一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新元素
@Test
public void test7(){
    List<String> list1 = Arrays.asList("aa","bb","cc","dd");
    list1.stream().map((str) -> str.toUpperCase()).forEach(System.out::println);

    System.out.println("-----------------------------------------");

//        list.stream().map((x) -> x.getName())
//                     .forEach(System.out::println);
    list.stream().map(Employee::getName)//方法引用
                 .forEach(System.out::println);

    System.out.println("-----------------------------------------");

    Stream<Stream<Character>> stream2= list1.stream().map(TestStreamAPI1::filterCharacter);

    stream2.forEach((sm) ->{
        sm.forEach(System.out::println);
    });
}
public static Stream<Character> filterCharacter(String str){
    List<Character> characters = new ArrayList<>();

    for (Character ch: str.toCharArray()) {
        characters.add(ch);
    }
    return characters.stream();
}

flatMap—接收一个函数作为参数，将流中每个值都换成另一个 流，然后把所有流连接成一个流

//flatMap----接收一个函数作为参数，将流中每个值都换成另一个流，然后把所有流连接成一个流
@Test
public void test8(){
    List<String> li = Arrays.asList("aa","bb","cc","dd");

    Stream<Character> sm = li.stream().flatMap(TestStreamAPI1::filterCharacter);
    sm.forEach(System.out::println);
}
public static Stream<Character> filterCharacter(String str){
    List<Character> characters = new ArrayList<>();

    for (Character ch: str.toCharArray()) {
        characters.add(ch);
    }
    return characters.stream();
}

mapToInt(ToIntFunction f)—接收一个函数作为参数,该函数 会被应用到每个元素上,产生一个新的IntStream

//mapToInt(ToIntFunction f)----接收一个函数作为参数,该函数会被应用到每个元素上,产生一个新的IntStream
@Test
public void test9(){
    IntStream intStream = list.stream().mapToInt(Employee::getAge);
    intStream.forEach(System.out::println);
}

mapToLang(ToLangFunction f)—接收一个函数作为参数,该 函数会被应用到每个元素上,产生一个新的LongStream

//d.mapToLang(ToLangFunction f)----接收一个函数作为参数,该函数会被应用到每个元素上,产生一个新的LongStream
@Test
public void test10(){
    LongStream longStream = list.stream().mapToLong(Employee::getSalary);
    longStream.forEach(System.out::println);
}

mapToDouble(ToDoubleFunction f)—接收一个函数作为参 数,该函数会被应用到每个元素上,产生一个新的DoubleStream

//mapToDouble(ToDoubleFunction f)----接收一个函数作为参数,该函数会被应用到每个元素上,产生一个新的DoubleStream
@Test
public void test11(){
    DoubleStream doubleStream = list.stream().mapToDouble(Employee::getSalary);
    doubleStream.forEach(System.out::println);
    //输出结果：9999.0,6666.0,3333.0.....
}

排序

sorted—自然排序

//sorted----自然排序
@Test
public void test12(){
    List<String> strList = Arrays.asList("ccc","aaa","ddd","eee","bbb");
    strList.stream().sorted().forEach(System.out::println);
}

sorted(Comparator comp)—定制排序

//sorted(Comparator comp)----定制排序
@Test
public void test13(){
    list.stream().sorted((e1,e2) ->{
       if(e1.getName().equals(e2.getName())){
           return e1.getSex().compareTo(e2.getSex());
       } else{
           return e1.getName().compareTo(e2.getName());
       }
    }).forEach(System.out::println);
}