java8 lambda表达式 学习demo

/**
 * 描述:
 * java8 lambda表达式demo
 * @author 闲走天涯
 * @create 2021/4/10 16:25
 */
public class Demo {
    public static void main(String[] args) {
        List<String> stringList = new ArrayList();
        stringList.add("one");
        stringList.add("two");
        stringList.add("three");
        //  list过滤条件  joining将list转为string
        String str = stringList.stream().filter(p -> !p.equals("two")).collect(Collectors.joining("&","[","]"));

        // list转Map 需要设置key和value的值
        Map<String,Object> map = stringList.stream().collect(Collectors.toMap(p->p+"_k",p->p+"_v"));
        //遍历输出
        map.forEach((k,v)->{System.out.println("k="+k+",v="+v);});

        // list转Set 不需要修改值
        Set<String> set = stringList.stream().filter(p -> !"one".equals(p)).collect(Collectors.toSet());
        //遍历输出
        set.forEach(integer -> {System.out.println(integer);});
        set.forEach(System.out::println);

        //Converter 接口
        Integer num = 1;
        Converter<Integer, String> s = param ->{return String.valueOf(param+num);};
        //等效于
        Converter<Integer, String> converter = new Converter<Integer, String>() {
            @Override
            public String convert(Integer source) {
                return String.valueOf(source+num);
            }
        };
        System.out.println(s.convert(2));
        System.out.println(converter.convert(2));


        //对象::实例方法  Consumer<T> 输入对象，不返回对象
        Consumer<String> sc = System.out::println;
        //sc = p->System.out.println(p);
        sc.accept("hello world!");

        //类::静态方法  Function<T, R> 输入对象，返回对象
        Function<Integer, String> sf = String::valueOf;
        //sf = p->String.valueOf(p);
        System.out.println(sf.apply(10));

        //类::实例方法 BiPredicate<T,R> 接收两个对象，返回Boolean
        BiPredicate<String,String> bpc = String::equals;
        //bpc = (a,b)->a.equals(b);
        System.out.println(bpc.test("a","b"));

        //Predicate<T> 接收一个对象，返回Boolean
        Predicate<String> pre = p -> p.length()<5;
        System.out.println(pre.test("hello world!"));

        //UnaryOperator 接收一个对象，返回同类型的对象
        UnaryOperator<String> uo = p->p+86;
        System.out.println(uo.apply("100"));

        //BinaryOperator 接收两个同类型对象，返回一个同类型对象
        BinaryOperator<String> bo = (a,b)->a+b;
        System.out.println(bo.apply("100","86"));

        //Supplier 提供T对象（例如工厂），不接收值
        Supplier<String> sup = String::new;
        String newString = sup.get();

        Comparator<Person> c = (Person p1,Person p2) -> p1.getAge().compareTo(p2.getAge());
        c = Comparator.comparing(Person::getAge);
        Person p1 = new Person(10,12);
        Person p2 = new Person(9,13);
        System.out.println(c.compare(p1,p2));

        //线程
        new Thread(()->{int number=0; while(number<10){System.out.println(number); number++;}}).start();
        // 等效于
        new Thread(new Runnable() {
            @Override
            public void run() {
                int number=0;
                while(number<10){
                    System.out.println(number);
                    number++;
                }
            }
        }).start();


        // 快捷接口方法实现方式 实现接口 Operate
        Operate maxOp = (int a, int b) -> {return (a > b ? a : b);};
        Operate minOp = (int a, int b) -> {return (a < b ? a : b);};
        Operate addOp = (int a, int b) -> {return a + b;};
        Operate subOp = (int a, int b) -> {return a - b;};
        Operate mulOp = (int a, int b) -> {return a * b;};
        Operate divOp = (int a, int b) -> {return a / b;};

        System.out.println(opeaten(1,2,addOp));
    }
    interface Operate{
        Integer operate(int a,int b);
    }

    public static int opeaten(int a,int b,Operate operate){
        return operate.operate(a,b);
    }

}
//类
class Person{
    private Integer age;
    private Integer year;
    Person(Integer age,Integer year){
        this.age=age;
        this.year=year;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}