Java8新特性(四)专项练习

目录

​​一.  函数式接口专项练习​​

​​二.Lambda专项练习​​

​​Lambda专项练习二​​

​​Lambda专项练习三​​

​​Lambda专项练习四​​

​​三.Stream专项练习​​

​​1.stream专项练习​​

​​2.stream专项练习​​

​​3.stream专项练习​​

​​4.Stream专项练习​​

​​5.Stream专项练习​​

​​6.Stream专项练习​​

​​7.Stream专项练习​​

​​四.Optional专项练习​​

一.  函数式接口专项练习

相关实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {
    private int id;
    private String name;
    private int age;
    private double salary;

    public Employee(String name) {
        this.name = name;
    }

    public Employee(String name,int id ) {
        this.id = id;
        this.name = name;
    }

    public String show( ) {
        System.out.println("--------------------111111----------");
        return "你好";
    }

}

什么是函数式接口

      1.只包含一个抽象方法的接口，称为函数式接口。

      2.你可以通过Lambda表达式来创建该接口的对象。（若Lambda表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）

      3.我们可以在任意函数式接口上使用@FunctionalInterface注解，这样做可以检查它是否是一个函数式接口，同时Javadoc也会包含一条声明，说明这个接口是

@FunctionalInterface
public interface MyFunction {

   public String getValue(String str);

}

@FunctionalInterface
public interface MyFunction2<T,R> {

    public R getValue(T t1,T t2);

}

public class TestLambda {
    List<Employee> emps = Arrays.asList(
            new Employee(101, "张三", 18, 9999.99),
            new Employee(102, "李四", 59, 6666.66),
            new Employee(103, "王五", 28, 3333.33),
            new Employee(104, "赵六", 8, 7777.77),
            new Employee(105, "田七", 38, 5555.55)
    );

    @Test
    public void test1(){
        Collections.sort(emps, (e1, e2) -> {
            if(e1.getAge() == e2.getAge()){
                return e1.getName().compareTo(e2.getName());
            }else{
                return -Integer.compare(e1.getAge(), e2.getAge());
            }
        });
        for (Employee emp : emps) {
            System.out.println(emp);
        }
    }
    //需求，用于处理字符串
    public String strHandler(String str,MyFunction mf){
        return mf.getValue(str);
    }

    @Test
    public void test2(){
        String trimStr=strHandler("   我的名字叫汤姆  ",(str)->str.trim());
        System.out.println("trimStr = " + trimStr);

        String upper=strHandler("abcdefg",(str)->str.toUpperCase());
        System.out.println("upper = " + upper);

        String newStr=strHandler("我的名字",(str)->str.substring(1,3));
        System.out.println("newStr = " + newStr);
    }
    public void op(Long l1,Long l2, MyFunction2<Long,Long> mf){

        System.out.println(mf.getValue(l1,l2));

    }
    @Test
    public void test3(){
        op(100L,200L,(x,y)->x+y);
        op(200l,300l,(x,y)->x*y);

    }
}

二.Lambda专项练习

public class TestLambda {

    //原来的匿名内部类
    @Test
    public void test1() {
        Comparator<String> com = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return Integer.compare(o1.length(), o2.length());
            }
        };

        TreeSet<String> ts = new TreeSet<>(com);

        TreeSet<String> ts2 = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return Integer.compare(o1.length(), o2.length());
            }
        });
    }


    //现在的Lambda表达式
    @Test
    public void test2() {
        Comparator<String> com = (x, y) -> Integer.compare(x.length(), y.length());
        TreeSet<String> ts = new TreeSet<>(com);
    }


    List<Employee> emps = Arrays.asList(
            new Employee(101, "张三", 18, 9999.99),
            new Employee(102, "李四", 59, 6666.66),
            new Employee(103, "王五", 28, 3333.33),
            new Employee(104, "赵六", 8, 7777.77),
            new Employee(105, "田七", 38, 5555.55)
    );

    //需求。获取公司中年龄小于35的员工的信息
    public List<Employee> filterEmployeeAge(List<Employee> emps) {
        List<Employee> list = new ArrayList<>();
        for (Employee emp : emps) {
            if (emp.getAge() <= 35) {
                list.add(emp);
            }
        }
        return list;
    }


    @Test
    public void test3() {
        List<Employee> list = filterEmployeeAge(emps);
        for (Employee Employee : list) {
            System.out.println("Employee = " + Employee);
        }
    }

    //需求获取公司中工资大于5000的员工信息
    public List<Employee> filterEmployeeSalary(List<Employee> emps) {
        List<Employee> list = new ArrayList<>();
        for (Employee Employee : emps) {
            if (Employee.getSalary() >= 5000) {
                list.add(Employee);
            }
        }
        return list;
    }

    //优化方式一:策略模式
    public List<Employee> filterEmployee(List<Employee> emps, Mypredicate<Employee> mp) {
        List<Employee> list = new ArrayList<>();
        for (Employee emp : emps) {
            if (mp.test(emp)) {
                list.add(emp);
            }
        }
        return list;
    }

    @Test
    public void test4() {
        List<Employee> list = filterEmployee(emps, new FilterEmployeeForAge());
        for (Employee emp : list) {
            System.out.println("emp = " + emp);
        }
        System.out.println("------------------");
        List<Employee> list2 = filterEmployee(emps, new FilterEmployeeForSalary());
        for (Employee emp : list2) {
            System.out.println("emp = " + emp);
        }
    }

    //优化方式二：匿名内部类
    @Test
    public void test5() {
        List<Employee> list3 = filterEmployee(emps, new Mypredicate<Employee>() {
                    @Override
                    public boolean test(Employee Employee) {
                        return Employee.getId() <= 103;
                    }
                }


        );
        for (Employee emp : list3) {
            System.out.println("emp = " + emp);
        }

    }

    //优化方式三：Lambda表达式
    @Test
    public void test6() {
        List<Employee> list = filterEmployee(emps, (Employee) -> Employee.getAge() <= 35);
        list.forEach(System.out::println);
        System.out.println("------------------");
        List<Employee> list1 = filterEmployee(emps, Employee -> Employee.getSalary() >= 5000);
        list1.forEach(System.out::println);
    }

    //优化方式四.Stream Api

    @Test
    public void test7() {
        emps.stream().filter((e) -> e.getAge() <= 35).forEach(System.out::println);
        System.out.println("-----------------");
        emps.stream().filter((e) -> e.getSalary() >= 5000).forEach(System.out::println);
    }


}

Lambda专项练习二

public class TestLambda1 {


    @Test
    public void test1() {
        int num = 0;//jdk1.7之前必须是final

        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("num = " + num);
            }
        };
        r.run();
        System.out.println("----------------");
        Runnable r1 = () -> System.out.println("hello Lambda!");
        r1.run();
    }

    @Test
    public void test2() {
        Consumer<String> consumer = x -> System.out.println("x = " + x);
        consumer.accept("你好，lambda!");
    }

    @Test
    public void test3() {
        Comparator<Integer> com = (x, y) -> {
            System.out.println("函数式接口");
            return Integer.compare(x, y);
        };
    }

    @Test
    public void test4(){
        Comparator<Integer> com=(x,y)->Integer.compare(x,y);
    }

    //需求：对一个数进行运算

    @Test
    public void test6(){
        Integer num=operation(100,x->x*x);
        System.out.println("num = " + num);
        System.out.println(operation(200,y->y+200));
    }

    public Integer operation (Integer num,MyFun mf){return mf.getValue(num);}


}

Lambda专项练习三

public class TestLambda2 {

    //predicate<T> 断言型接口
    @Test
    public void test4() {
        List<String> list = Arrays.asList("Hello", "atguigu", "Lambda", "www", "ok");
        List<String> strList = filterStr(list, (s) -> s.length() > 3);
        strList.forEach(System.out::println);
    }

    //需求：将满足条件的字符串，放入集合中
    public List<String> filterStr(List<String> list, Predicate<String> pre) {
        List<String> strList = list.stream().filter(str -> pre.test(str)).collect(Collectors.toList());
        return strList;
    }


    //Function<T,R>函数型接口
    @Test
    public void test3() {
        String newStr = strHandler("       你好，java8! ", (str) -> str.trim());
        System.out.println("newStr = " + newStr);
        String subStr = strHandler("你好 Java8", (str) -> str.substring(2, 4));
        System.out.println("subStr = " + subStr);
    }

    //需求：用于处理字符串
    public String strHandler(String str, Function<String, String> fun) {
        return fun.apply(str);
    }


    //supplier<T>供给型接口
    @Test
    public void test2() {

        List<Integer> numList = getNumList(10, () -> (int) (Math.random() * 100));

        numList.forEach(System.out::println);

    }


    //需求：产生指定个数的整数，并放入集合中
    public List<Integer> getNumList(int num, Supplier<Integer> sup) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            list.add(sup.get());
        }
        return list;
    }

    //消费型接口Consumer<T>
    @Test
    public void test1(){
        happy(10000,System.out::println);

    }

    public void happy(double money, Consumer<Double> con){
        con.accept(money);
    }

}

Lambda专项练习四

public class TestMethodRef {
    //数组引用
    @Test
    public void test8(){
        Function<Integer,String[]>  fun=(args)->new String [args];
        String [] strs=fun.apply(10);
        System.out.println(strs.length);
        System.out.println("------------------------");
        Function<Integer, Employee[]> fun2=Employee[]::new;
        Employee[] emps=fun2.apply(20);
        System.out.println(emps.length);
    }


    //构造器引用
    @Test
    public void test7(){
        Function<String,Employee> fun=Employee::new;
        BiFunction<String,Integer,Employee> fun2=Employee::new;
    }

    @Test
    public void test6(){
        Supplier<Employee> sup=()->new Employee();
        System.out.println(sup.get());
        System.out.println("-----------------");
        Supplier<Employee> sup2=Employee::new;
        System.out.println(sup2.get());
    }


    //类名：：实例方法名
    @Test
    public void test5(){
        BiPredicate<String,String> bp=(x,y)->x.equals(y);
        System.out.println(bp.test("abcde","abcde"));
        System.out.println("-----------------------------");
        BiPredicate<String,String> bp2=String::equals;
        System.out.println(bp2.test("abcd","abcd"));
        System.out.println("-----------------------------");
        Function<Employee,String> fun=e -> e.show();
        System.out.println(fun.apply(new Employee()));
        System.out.println("-----------------------------");
        Function<Employee,String> fun2=Employee::show;
        System.out.println(fun2.apply(new Employee()));
    }


    //类名：：静态方法
    @Test
    public void test4(){
        Comparator<Integer> com=(x,y)->Integer.compare(x,y);
        System.out.println("----------------------");
        Comparator<Integer> com2=Integer::compare;
    }

    @Test
    public void test3(){
        BiFunction<Double,Double,Double> fun=(x,y)->Math.max(x,y);
        System.out.println(fun.apply(1.5,1.6));
        System.out.println("----------------------");
        BiFunction<Double,Double,Double> fun2=Math::max;
        System.out.println( fun2.apply(1.3,1.5));
    }

    //对象的引用：：实例方法名
    @Test
    public void test2(){
        Employee emp=new Employee(101,"张三",18,99999.99);
        Supplier<String> sup=()->emp.getName();
        System.out.println(sup.get());
        System.out.println("------------------");
        Supplier<String> sup2=emp::getName;
        System.out.println(sup2.get());
    }

    @Test
    public void test1(){
        PrintStream ps=System.out;
        Consumer<String> con=str->ps.println(str);
        con.accept("Hello world!");
        System.out.println("-------");
        Consumer<String> con2=ps::println;
        con2.accept("Hello world!");

    }

}

三.Stream专项练习

  1.stream专项练习

public class TestStreamApI {
    //1.创建Stream
    @Test
    public void test1() {
        //1.Collection提供了两个方法 stream()与parallelStream()
        List<String> list = new ArrayList<>();
        Stream<String> stream = list.stream();//获取一个顺序流
        Stream<String> parallelStream = list.parallelStream();//获取一个并行流
        //2.通过Arrays中的stream()创建一个数据流
        Integer[] nums = new Integer[10];
        Stream<Integer> stream1 = Arrays.stream(nums);
        //3.通过stream类中静态方法 of()
        Stream<Integer> stream2 = Stream.of(1, 2, 3, 4, 5);
        //4.创建无限流
        //迭代
        Stream<Integer> stream3 = Stream.iterate(0, (x) -> x + 2).limit(10);
        stream3.forEach(System.out::println);
        //生成
        Stream<Double> stream4 = Stream.generate(Math::random).limit(2);
        stream4.forEach(System.out::println);
    }


    //    2.中间操作
    List<Employee> emps = Arrays.asList(
            new Employee(102, "李四", 59, 6666.66),
            new Employee(101, "张三", 18, 9999.99),
            new Employee(102, "王五", 44, 9999.99),
            new Employee(102, "赵六", 10, 9999.99),
            new Employee(102, "赵六", 28, 9999.99)
    );


    /*筛选与切片
    * filter ---接收Lambda,从流中排除元素
    * limilt ---截断流，使其元素不超过给定数量
    * skip  ---跳过n个元素，返回一个扔掉，前n个元素，若是流中元素不足n个，则返回一个空流
    * 与limit(n)互补
    *
    * distinct---筛选，通过流所生成的hashCode()和equals()去除重复
    * */

    //内部迭代:迭代操作stream Api
    @Test
    public void test2(){
         //所有中间操作不会做任何的处理
        Stream<Employee> stream=emps.stream()
                .filter((e)->{
                    System.out.println("测试中间操作");
                    return e.getAge()<=35;
                });
        stream.forEach(System.out::println);
    }

    //外部迭代
    @Test
    public void test3(){
        Iterator<Employee> it=emps.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }


    @Test
    public void test4(){
        emps.stream().filter(
                e->{
                    System.out.println("短路！");
                    return e.getSalary()>=5000;
                }
        ).limit(3).forEach(System.out::println);
    }



    @Test
    public void test5(){
        emps.parallelStream().filter(
                e->e.getSalary()>=5000)
                .skip(2).forEach(System.out::println);
    }
    @Test
    public void test6(){
        emps.stream().distinct().forEach(System.out::println);
    }

}

 2.stream专项练习

public class TestStreamApi {

/*
*  1.给定一个数字列表，如何返回一个由每个数的平方构成的列表呢？
*   给定1，2，3，4，5，应该返回1，4，9，16，25
* */


    @Test
    public void test1(){
        Integer[] nums=new Integer[]{1,2,3,4,5};
        Arrays.stream(nums).map((x)->{ return x*x ;})
                  .forEach(System.out::println);

    }

    /*
    * 2.怎样用map和reduce 方法数一数流中有多少个Employee呢？
    *
    * */

    List<Employ>  emps=Arrays.asList(
            new Employ(102,"李四",59,666.66, Employ.Status.BUSY),
            new Employ(101,"张三",18,9999.99, Employ.Status.FREE),
            new Employ(103,"王五",8,9999.99, Employ.Status.FREE),
            new Employ(104,"赵六",81,9999.99, Employ.Status.VOCATION),
            new Employ(104,"赵六",38,777.77, Employ.Status.VOCATION)

    );

    @Test
    public void test2(){

        Optional<Integer> count=emps.stream().map(e->2).reduce(Integer::sum);

        System.out.println("count.get() = " + count.get());

    }



}

 3.stream专项练习

public class TestStreamApi1 {
    //
    List<Employee> emps = Arrays.asList(
            new Employee(102, "李四", 59, 6666.66),
            new Employee(101, "张三", 18, 9999.99),
            new Employee(103, "王五", 28, 3333.33),
            new Employee(104, "赵六", 8, 7777.77),
            new Employee(104, "赵六", 8, 7777.77),
            new Employee(104, "赵六", 8, 7777.77),
            new Employee(105, "田七", 38, 5555.55)
    );

    //2.中间操作
    //1.映射  map---接收Lambda,将元素转换称为其他形式或提取信息。按一个函数作为参数，该函数会被应用到每个元素上，该函数会被应用到每个元素上，并将器映射到一个新的元素上
    //flatMap--接收一个函数作为参数，将流中的每个值都换成另一个流，然后将所有流链接成一个流

    @Test
    public void test1() {
        Stream<String> str = emps.stream().map((e) -> e.getName());
        System.out.println("--------------------------------");
        List<String> strList = Arrays.asList("aaa", "bbb", "ccc", "dddd");
        Stream<String> stream = strList.stream().map(String::toUpperCase);
        stream.forEach(System.out::println);

        Stream<Stream<Character>> stream2 = strList.stream()
                .map(TestStreamApi1::filterCharacter);

        stream2.forEach(
                stream21 -> {
                    stream21.forEach(System.out::println);
                }
        );
        System.out.println("----------------------------------");
        Stream<Character> stream3 = strList.stream().flatMap(TestStreamApi1::filterCharacter);
        stream3.forEach(System.out::println);
    }

    public static Stream<Character> filterCharacter(String str) {
        List<Character> list = new ArrayList<>();
        for (Character ch : str.toCharArray()) {
            list.add(ch);
        }
        return list.stream();

    }

    /*sorted自然排序
     * sorted(Comparator com)---定制排序
     * */
    @Test
    public void test2() {
        emps.stream().map(Employee::getName).sorted().forEach(System.out::println);
        System.out.println("----------------------------------------------------");
        emps.stream().sorted(
                (x, y) -> {
                    if (x.getAge() == y.getAge()) {
                        return x.getName().compareTo(y.getName());
                    } else {
                        return Integer.compare(x.getAge(), y.getAge());
                    }
                }
        ).forEach(System.out::println);

    }



}

4.Stream专项练习

public class TestStreamApi1 {
    //
    List<Employee> emps = Arrays.asList(
            new Employee(102, "李四", 59, 6666.66),
            new Employee(101, "张三", 18, 9999.99),
            new Employee(103, "王五", 28, 3333.33),
            new Employee(104, "赵六", 8, 7777.77),
            new Employee(104, "赵六", 8, 7777.77),
            new Employee(104, "赵六", 8, 7777.77),
            new Employee(105, "田七", 38, 5555.55)
    );

    //2.中间操作
    //1.映射  map---接收Lambda,将元素转换称为其他形式或提取信息。按一个函数作为参数，该函数会被应用到每个元素上，该函数会被应用到每个元素上，并将器映射到一个新的元素上
    //flatMap--接收一个函数作为参数，将流中的每个值都换成另一个流，然后将所有流链接成一个流

    @Test
    public void test1() {
        Stream<String> str = emps.stream().map((e) -> e.getName());
        System.out.println("--------------------------------");
        List<String> strList = Arrays.asList("aaa", "bbb", "ccc", "dddd");
        Stream<String> stream = strList.stream().map(String::toUpperCase);
        stream.forEach(System.out::println);

        Stream<Stream<Character>> stream2 = strList.stream()
                .map(TestStreamApi1::filterCharacter);

        stream2.forEach(
                stream21 -> {
                    stream21.forEach(System.out::println);
                }
        );
        System.out.println("----------------------------------");
        Stream<Character> stream3 = strList.stream().flatMap(TestStreamApi1::filterCharacter);
        stream3.forEach(System.out::println);
    }

    public static Stream<Character> filterCharacter(String str) {
        List<Character> list = new ArrayList<>();
        for (Character ch : str.toCharArray()) {
            list.add(ch);
        }
        return list.stream();

    }

    /*sorted自然排序
     * sorted(Comparator com)---定制排序
     * */
    @Test
    public void test2() {
        emps.stream().map(Employee::getName).sorted().forEach(System.out::println);
        System.out.println("----------------------------------------------------");
        emps.stream().sorted(
                (x, y) -> {
                    if (x.getAge() == y.getAge()) {
                        return x.getName().compareTo(y.getName());
                    } else {
                        return Integer.compare(x.getAge(), y.getAge());
                    }
                }
        ).forEach(System.out::println);

    }



}

5.Stream专项练习

package Java8day02;

import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class TestStreamApi2 {

    List<Employee3> emps = Arrays.asList(
            new Employee3(102, "李四", 59, 6666.66, Employee3.Status.BUSY),
            new Employee3(101, "张三", 18, 9999.9, Employee3.Status.FREE),
            new Employee3(103, "王五", 28, 3333.33, Employee3.Status.VOCATION),
            new Employee3(104, "赵六", 8, 7777.77, Employee3.Status.BUSY),
            new Employee3(104, "赵六", 8, 7777.77, Employee3.Status.FREE),
            new Employee3(104, "赵六", 8, 7777.77, Employee3.Status.FREE),
            new Employee3(105, "田七", 38, 5555.55, Employee3.Status.BUSY)
    );

    /*
        allMatch——检查是否匹配所有元素
        anyMatch——检查是否至少匹配一个元素
        noneMatch——检查是否没有匹配的元素
        findFirst——返回第一个元素
        findAny——返回当前流中的任意元素
        count——返回流中元素的总个数
        max——返回流中最大值
        min——返回流中最小值
     */

    @Test
    public void test1(){
        boolean bl=emps.stream().allMatch((e)->e.getStatus().equals(Employee3.Status.BUSY));
        System.out.println(bl);

        boolean bl2=emps.stream().anyMatch((e)->e.getStatus().equals(Employee3.Status.BUSY));
        System.out.println(bl2);

        boolean bl3=emps.stream().noneMatch((e)->e.getStatus().equals(Employee3.Status.BUSY));
        System.out.println(bl3);

    }
    
    
    @Test
    public void test2(){
        Optional<Employee3> op=emps.stream()
                .sorted((e1,e2)->Double.compare(e1.getSalary(),e2.getSalary()))
                .findFirst();
        System.out.println("op.get() = " + op.get());
        System.out.println("--------------------------------");
        Optional<Employee3> op2=emps.parallelStream()
                .filter((e)->e.getStatus().equals(Employee3.Status.FREE))
                .findAny();
        System.out.println("op2.get() = " + op2.get());
    }

    @Test
    public void test3() {
        long count = emps.stream()
                .filter((e) -> e.getStatus().equals(Employee3.Status.FREE)).count();
        System.out.println("count = " + count);
        Optional<Double> op = emps.stream().map(Employee3::getSalary).max(Double::compare);
        System.out.println(op.get());

        Optional<Employee3> op2 = emps.stream().min((e1, e2) -> {
            return Double.compare(e1.getSalary(), e2.getSalary());
        });
    }

    //注意流中：流中进行终止操作后，不能再次使用
//    @Test
//    public void test4(){
//        Stream<Employee3> stream=emps.stream()
//                .filter(e->e.getStatus().equals(Employee3.Status.FREE));
        long count=stream.count();
//        stream.map(Employee3::getSalary).max(Double::compare);
//
//    }




}

6.Stream专项练习

package Java8day02;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import exer.Employee;
import lombok.Data;
import org.junit.Test;

import java.util.*;
import java.util.stream.Collectors;

public class TestStreamApi3 {

    List<Employee3> emps = Arrays.asList(
            new Employee3(102, "李四", 79, 6666.66, Employee3.Status.BUSY),
            new Employee3(101, "张三", 18, 9999.99, Employee3.Status.FREE),
            new Employee3(103, "王五", 28, 3333.33, Employee3.Status.VOCATION),
            new Employee3(104, "赵六", 8, 7777.77, Employee3.Status.BUSY),
            new Employee3(104, "赵六", 8, 7777.77, Employee3.Status.FREE),
            new Employee3(104, "赵六", 8, 7777.77, Employee3.Status.FREE),
            new Employee3(105, "田七", 38, 5555.55, Employee3.Status.BUSY)
    );

  //3.终止操作
    @Test
    public void test1(){
        List<Integer> list=Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer sum=list.stream().reduce(0,(x,y)->x+y);
        System.out.println(sum);
        System.out.println("---------------------------------");
        Optional<Double> op=emps.stream()
                .map(Employee3::getSalary).reduce(Double::sum);
        System.out.println("op.get() = " + op.get());

    }


    //需求：搜索名字中 “六” 出现的次数
    @Test
    public void test2(){
        Optional<Integer> sum=emps.stream()
                .map(Employee3::getName)
                .flatMap(TestStreamApi1::filterCharacter)
                .map((ch)->{
                    if(ch.equals("六"))
                        return 1;
                    else
                        return 0;
                }).reduce(Integer::sum);


    }

    collect——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
    @Test
    public void test3(){
        List<String> list=emps.stream()
                .map(Employee3::getName).collect(Collectors.toList());
        list.forEach(System.out::println);
        System.out.println("----------------------------------------");
        Set<String> set=emps.stream().map(Employee3::getName).collect(Collectors.toSet());
        set.forEach(System.out::println);
        System.out.println("----------------------------------------");
        HashSet<String> hs=emps.stream().map(Employee3::getName).collect(Collectors.toCollection(HashSet::new));
        hs.forEach(System.out::println);

    }


    @Test
    public void test4() {
        Optional<Double> max = emps.stream()
                .map(Employee3::getSalary).collect(Collectors.maxBy(Double::compare));
        System.out.println(max.get());
        Optional<Employee3> op = emps.stream().collect(Collectors.minBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
        System.out.println(op.get());
        Double sum = emps.stream()
                .collect(Collectors.summingDouble(Employee3::getSalary));
        System.out.println(sum);
        Double avg = emps.stream().collect(Collectors.averagingDouble(Employee3::getSalary));
        System.out.println("avg = " + avg);
        Long count = emps.stream().collect(Collectors.counting());
        System.out.println(count);
        System.out.println("-------------------------------------------------------------");
        DoubleSummaryStatistics dss = emps.stream()
                .collect(Collectors.summarizingDouble(Employee3::getSalary));
        System.out.println(dss.getMax());
    }

    @Test
    public void test5(){
        Map<Employee3.Status,List<Employee3>> map=emps.stream()
                .collect(Collectors.groupingBy(Employee3::getStatus));
        System.out.println("map = " + map);
    }

    //多级分组
    @Test
    public void test6() {
        Map<Employee3.Status, Map<String, List<Employee3>>> map = emps.stream().collect(Collectors.groupingBy(Employee3::getStatus, Collectors.groupingBy(
                (e) -> {
                    if (e.getAge() >= 60) {
                        return "老年";
                    } else if (e.getAge() >= 35) {
                        return "中年";
                    } else {
                        return "成年";
                    }
                }
        )));
        System.out.println(JSON.toJSONString(map));
    }
    //分区
    @Test
    public void test7(){
      Map<Boolean,List<Employee3>> map=emps.stream().collect(Collectors.partitioningBy((e)->e.getSalary()>=5000));
      System.out.println(map);
        System.out.println("JSON.toJSONString(map) = " + JSON.toJSONString(map));

    }

     @Test
     public void test8() {
         String str = emps.stream()
                 .map(Employee3::getName)
                 .collect(Collectors.joining(",", "---", "-----"));
         System.out.println(str);
     }

    @Test
    public void test9() {
        Optional<Double> sum = emps.stream().map(Employee3::getSalary).collect(Collectors.reducing(Double::sum));
        System.out.println(sum.get());
    }

}

7.Stream专项练习

package Java8day02;

import org.junit.Before;
import org.junit.Test;

import javax.lang.model.SourceVersion;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;

public class TestTransaction {

    List<Transaction> transactions = null;


    @Before
    public void before() {

        Trager raoul = new Trager("Raoul", "Cambridge");
        Trager mario = new Trager("mario", "Milan");
        Trager alan = new Trager("Alan", "Cambridge");
        Trager brian = new Trager("Brian", "Cambridge");

        transactions = Arrays.asList(
                new Transaction(brian, 2011, 300),
                new Transaction(raoul, 2012, 1000),
                new Transaction(raoul, 2011, 400),
                new Transaction(mario, 2012, 710),
                new Transaction(mario, 2012, 700),
                new Transaction(alan, 2012, 950)
                );

    }


    //1.找出2011年发生的所有交易，并按交易额排序（从低到高）
     @Test
    public void test1(){
        transactions.stream().filter((t)->t.getYear()==2011)
                         .sorted((t1,t2)->Integer.compare(t1.getValue(),t2.getValue()))
                          .forEach(System.out::println);

     }

     //2.交易员在那些不同的城市工作过？

    @Test
    public void test2(){
        transactions.stream().map((t)->t.getTrader().getCity())
                .distinct().forEach(System.out::println);


    }

    //3.查找所有来自剑桥的交易员，并按照姓名排序
    @Test
    public void test3(){

        transactions.stream()
                      .filter((t)->t.getTrader().getCity().equals("Cambridge"))
                      .map(Transaction::getTrader)
                      .sorted((t1,t2)-> t1.getName().compareTo(t2.getName()))
                      .distinct()
                      .forEach(System.out::println);
        ;
    }

    //4.返回所有交易员的姓名字符串，按照字母顺序排序
    @Test
    public void test4(){
        transactions.stream()
                .map((t)->t.getTrader().getName())
                .sorted()
                .forEach(System.out::println);


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

        String str=transactions.stream()
                       .map((t)->t.getTrader().getName())
                       .sorted()
                        .reduce("",String::concat);

        System.out.println("str = " + str);

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

        transactions.stream()
                .map((t)->t.getTrader().getName())
                .flatMap(TestTransaction::filterCharacter)
                .sorted((s1,s2)->s1.compareToIgnoreCase(s2))
                .forEach(System.out::println);

    }

    public static Stream<String> filterCharacter(String str){
        List<String> list=new ArrayList<>();

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



    //有没有交易员在米兰工作
    @Test
    public void test5(){
        boolean bl=transactions.stream()
                .anyMatch((t)-> t.getTrader().getCity().equals("Milan"));

        System.out.println("bl = " + bl);
    }



    //6.打印生活在剑桥的交易员的所有交易额
    @Test
    public void test6() {
        Optional<Integer> sum = transactions.stream()
                .filter((e) -> e.getTrader().getCity().equals("Cambridge"))
                .map(Transaction::getValue)
                .reduce(Integer::sum);

        System.out.println("sum.get() = " + sum.get());

    }


    //7.所有交易，最高的交易额是多少
    @Test
    public void test7(){
        Optional<Integer>max =transactions.stream()
                .map(t->t.getValue())
                .max(Integer::compare);
        System.out.println("max = " + max);

    }

    //8.找到交易额最小的交易
    @Test
    public void test8(){
        Optional<Transaction> op=transactions.stream()
                .min((t1,t2)->Integer.compare(t1.getValue(),t2.getValue()));
        System.out.println("op.get() = " + op.get());
    }




}

四.Optional专项练习

public class TestOptional {
    @Test
    public void test4() {
        Optional<Employee> op = Optional.of(new Employee(101, "张三", 18, 9999.99));
        Optional<String> op2 = op.map(Employee::getName);
        System.out.println("op2.get() = " + op2.get());


    }
    @Test
    public void test3() {
        Optional<Employee> op = Optional.ofNullable(new Employee());
        if (op.isPresent()) {
            System.out.println(op.get());
        }
        Employee emp = op.orElse(new Employee("张三"));
        System.out.println(emp);
        Employee emp2 = op.orElseGet(() -> new Employee());
        System.out.println("emp2 = " + emp2);
    }
    @Test
    public void test2() {
        Optional<Employee> op = Optional.ofNullable(null);
        System.out.println(op.get());
        Optional<Employee> op2 = Optional.empty();
        System.out.println(op2.get());
    }
    @Test
    public void test1() {
        Optional<Employee> op = Optional.of(new Employee());
        Employee emp = op.get();
        System.out.println("emp = " + emp);
    }
    @Test
    public void test5() {
        Man man = new Man();
        String name = getGodnessName(man);
        System.out.println("name = " + name);

    }
    //需求：获取一个男人心中女神的名字
    public String getGodnessName(Man man) {
        if (man != null) {
            Godness g = man.getGod();
            if (g != null) {
                return g.getName();
            }
        }
        return "111";
    }
    @Test
    public void test6() {

        Optional<Godness> godness = Optional.ofNullable(new Godness("林志玲"));
        Optional<NewMan> opMan = Optional.ofNullable(new NewMan(godness));
        String name = getGodnessName2(opMan);
        System.out.println("name = " + name);
    }
    public String getGodnessName2(Optional<NewMan> man) {
        return man.orElse(new NewMan())
                .getGodness().orElse(new Godness("1111")).getName();
    }
}

   相关的类型

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Employee {
    private int id;
    private String name;
    private int age;
    private double salary;

    public Employee(String name) {
        this.name = name;
    }

    public Employee(String name,int id ) {
        this.id = id;
        this.name = name;
    }

    public String show( ) {
        System.out.println("--------------------111111----------");
        return "你好";
    }

}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Godness {
    private String name;
}
public class NewMan {
    private Optional<Godness> godness=Optional.empty();
    private Godness god;

    public Optional<Godness> getGod(){
        return Optional.of(god);
    }

    public NewMan() {
    }
    public NewMan(Optional<Godness> godness) {
        this.godness = godness;
    }

    public Optional<Godness> getGodness() {
        return godness;
    }
    public void setGodness(Optional<Godness> godness) {
        this.godness = godness;
    }
    @Override
    public String toString() {
        return "NewMan [godness=" + godness + "]";
    }

}


@Data
@AllArgsConstructor
@NoArgsConstructor
public class Man {
    private Godness god;

}