Java8 新特性 Lamdba表达式的一些简单用法

Java8新特性总结

---

 

Lamdba 表达式：

    /**
* @author :CodingFarmer_码农  Connor(康纳)_郭
* @date : 17:24 20.5.12
* @Company : http://www.gskj.com
* @Version : 1.0
* <p>
* 1. 举例 (o1,o2) -> Integer.compare(o1,o2)
* 2. 格式：
* -> :lamdba操作符，
* ->左边: lambda形参列表，(接口抽象方法中的形参列表)
* ->右边:lambda体 (即重写的抽象方法的方法体)
* <p>
* <p>
* <p>
* lambda表达式的使用： 分为 6种 用法;
*
*  lambda 总结
*          -> 左边：  lambda形参列表： (即为接口的形参列表) 数据类型可以省略
*          -> 右边：  lambda方法体：(重写的抽象方法的方法体)，lambda只有一条执行语句(也可能是 return 语句)。{} return都可以执行省略。
*
* lambda表达式的本质： 函数式接口的实例对象
*
* @FunctionalInterface 显示标注该类位 函数式接口
*
* 如果一个接口中只声明了一个抽象方法的接口就是  函数式接口
*/
public class LambdaTest2 {
​
    // 语法格式 1， 无参数、无返回值
    @Test
    public void test1() {
​
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("ssss");
            }
        };
        r1.run();
​
        System.out.println("Lamdba ------------");
​
        Runnable r2 = () -> System.out.println("ssss");
        r2.run();
    }
​
​
    // 语法格式 2， 有参数、无返回值
    @Test
    public void test2() {
​
        Consumer<String> con1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con1.accept("试试实");
​
        System.out.println("Lamdba ------------");
​
        Consumer<String> con2 = (String s) -> {
            System.out.println(s);
        };
        con2.accept("asdadasdads");
​
    }
​
    // 语法格式 3， 数据类型可以省略，可有编辑器推断得出、称为 类型推断；
    @Test
    public void test3() {
​
​
        Consumer<String> con2 = (String s) -> {
            System.out.println(s);
        };
        con2.accept("asdadasdads");
​
​
        System.out.println("---------------------------");
​
​
        Consumer<String> con3 = (s) -> {
            System.out.println(s);
        };
        con3.accept("asdadasdads");
    }
​
​
    // 类型推断
    List<String> list = new ArrayList<>();
​
    int[] a = {1, 2, 3};
​
    // 语法格式 4， 如只有一个参数时，()可以省略
    @Test
    public void test4() {
        Consumer<String> con3 = (s) -> {
            System.out.println(s);
        };
        con3.accept("asdadasdads");
​
        System.out.println("---------------------------");
​
        Consumer<String> con4 = s -> {
            System.out.println(s);
        };
        con4.accept("asdadasdads");
    }
​
    // 语法格式 5， 如需要两个或两个以上的参数。多条执行语句。并且有返回值
    @Test
    public void test5() {
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(02);
            }
        };
        System.out.println(com1.compare(0, 12));
        System.out.println("Lamdba ------------");
​
        Comparator<Integer> com2 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(02);
        };
​
        System.out.println(com2.compare(12, 0));
    }
​
    // 语法格式 5， 当lamdba体 只有一条语句，return,{}都可以省略
    @Test
    public void test6() {
​
        Comparator<Integer> com2 = (o1, o2) -> {
            return o1.compareTo(02);
        };
​
        System.out.println(com2.compare(12, 0));
​
        System.out.println("---------------------------");
​
        Comparator<Integer> com3 = (o1, o2) -> o1.compareTo(02);
​
        System.out.println(com3.compare(0, 1));
    }
}
 

java 内置的四大 函数式接口

/**
* @author :CodingFarmer_码农  Connor(康纳)_郭
* @date : 18:12 20.5.12
* @Company : http://www.gskj.com
* @Version : 1.0
* <p>
* java内置的4 大核心 函数式接口
* 消费型接口  Consumer<T>  void accept(T t)
* 供给型接口 Supplier<T>   T get()
* 函数型接口 Function<T,R> R apply(T)
* 断定型接口 Predicate<T>  boolean test(T t)
*/
public class LambdaTest3 {
​
​
    /**
     * 测试 消费接口
     */
    @Test
    public void testConsumer() {
        consumerTest(5000d, new Consumer<Double>() {
            @Override
            public void accept(Double aDouble) {
                System.out.println(" 阿萨大啊啊啊" + aDouble);
            }
        });
​
​
        // lambda 写法
        consumerTest(6000d, money -> {
            System.out.println(" 阿萨大啊啊啊" + money);
        });
    }
​
    public void consumerTest(Double money, Consumer<Double> con) {
        con.accept(money);
    }
​
    /**
     * 测试 断定接口
     */
    @Test
    public void testPredicate() {
​
        List<String> list = Arrays.asList("北京", "南京", "东京", "西京", "上海");
​
//        List<String> list1 = filterString(list, new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//                return s.contains("京");
//            }
//        });
        // System.out.println(list1);
​
​
        // lambda
​
//        List<String> list2 = filterString(list, s -> {
//                    return s.contains("京");
//                }
//        );
​
        List<String> list2 = filterString(list, s ->s.contains("京"));
​
        System.out.println(list2);
    }
​
​
    public List<String> filterString(List<String> list, Predicate<String> predicate) {
​
        ArrayList<String> arrayList = new ArrayList<>();
​
        for (String s : list) {
            if (predicate.test(s)) {
                arrayList.add(s);
            }
        }
        return arrayList;
    }
}
 

Lambda的方法引用

/**
* 方法引用的使用
* <p>
* Created by shkstart.
* <p>
* 1.使用场景， 当要传递给 lambda体的操作，已经有实现的方法了。就可以用方法引用
* <p>
* 2.方法引用：本质上就是lambda表达式，而lambda作为函数式接口的实例，所以 方法引用就是函数式接口的实例
* <p>
* 3. 使用格式： 类:(对象):: 方法名
* <p>
* 4.具体分为三种情况
* 对象 :: 非静态方法
* 类  :: 静态方法
* 类 :: 非静态方法
*/
public class MethodRefTest {
​
​
    // 情况一：对象 :: 实例方法
    //Consumer中的void accept(T t)
    //PrintStream中的void println(T t)
    @Test
    public void test1() {
​
        Consumer<String> con1 = s -> System.out.println(s);
        con1.accept("上海");
​
        System.out.println("---------------方法引用-------------");
​
        PrintStream ps = System.out;
        Consumer<String> con2 = ps::println;  //方法引用
        con2.accept("shanghai");
    }
​
​
    //Supplier中的T get()
    //Employee中的String getName()
    @Test
    public void test2() {
        Employee sss = new Employee(1, "sss");
​
        Supplier<String> c3 = () -> sss.getName();
​
        System.out.println("---------------方法引用-------------");
​
        Supplier<String> c4 = sss::getName;
​
        System.out.println(c4.get());
    }
​
​
    // 情况二：类 :: 静态方法
    //Comparator中的int compare(T t1,T t2)
    //Integer中的int compare(T t1,T t2)
    @Test
    public void test3() {
        Comparator<Integer> com = (o1,o2) -> Integer.compare(1, 2);
        System.out.println("---------------方法引用-------------");
​
        Comparator<Integer> com2 =  Integer :: compare;
        System.out.println(com2.compare(1, 0));
    }
​
​
    //Function中的R apply(T t)
    //Math中的Long round(Double d)
    @Test
    public void test4() {
        Function<Double,Double> fun = new Function<Double, Double>() {
            @Override
            public Double apply(Double aDouble) {
                return null;
            }
        };
        System.out.println("---------------方法引用-------------");
​
        Function<Double,Long> fun2 = aDouble -> Math.round(aDouble);
        System.out.println(fun2.apply(5.6));
​
        System.out.println("---------------方法引用-------------");
        Function<Double,Long> fun3 = Math ::round;
​
        System.out.println(fun3.apply(8.1));
​
    }
​
​
    // 情况三：类 :: 实例方法
    // Comparator中的int comapre(T t1,T t2)
    // String中的int t1.compareTo(t2)
    @Test
    public void test5() {
​
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return  o1.compareTo(o2);
            }
        };
​
​
        System.out.println(com.compare(1, 2));
        System.out.println("---------------Lambda-------------");
​
        Comparator<Integer> com2=(o1,o2)->{return o1.compareTo(02);};
        System.out.println(com2.compare(2, 2));
​
        Comparator<Integer> com4=(o1,o2)->o1.compareTo(02);
        System.out.println(com4.compare(2, 2));
​
        System.out.println("---------------方法引用-------------");
​
        Comparator<Integer> com3 = Integer::compareTo;
        System.out.println(com3.compare(3, 2));
    }
​
​
    //BiPredicate中的boolean test(T t1, T t2);
    //String中的boolean t1.equals(t2)
    @Test
    public void test6() {
        BiPredicate<String,String> pre1 = (s1,s2)->s1.equals(s2);
        System.out.println(pre1.test("s", "a"));
        System.out.println("---------------Lambda-------------");
​
        BiPredicate<String,String> pre2 = String :: equals;
​
        System.out.println( pre2.test("s", "a"));
        System.out.println("---------------方法引用-------------");
    }
​
​
    // Function中的R apply(T t)
    // Employee中的String getName();
    @Test
    public void test7() {
​
        Function<Employee,String> fun1 = e->e.getName();
        Employee ssss = new Employee(1, "ssss");
        System.out.println( fun1.apply(ssss));
        System.out.println("---------------Lambda-------------");
​
        Function<Employee,String> fun2 = Employee::getName;
        System.out.println(fun2.apply(ssss));
        System.out.println("---------------方法引用-------------");
    }
​
}

Lambda的 构造器引用，数组引用

/**
* 一、构造器引用
* 和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。
* 抽象方法的返回值类型即为 构造器所属的类的类型。
* <p>
* 二、数组引用
*      可以把 数组看作是一个特殊的类，则写法跟 构造器引用一样。
* <p>
* <p>
* <p>
* Created by shkstart
*/
public class ConstructorRefTest {
    //构造器引用
    //Supplier中的T get()
    @Test
    public void test1() {
​
        Supplier<Employee> sup = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        System.out.println(sup.get());
​
        Supplier<Employee> sup2 = () -> new Employee();
        System.out.println("------------------Lambda---------------");
​
        Supplier<Employee> sup3 = Employee::new;
        System.out.println(sup3.get());
        System.out.println("------------------方法引用---------------");
    }
​
​
    //Function中的R apply(T t)
    @Test
    public void test2() {
        Function<Integer, Employee> fun1 = new Function<Integer, Employee>() {
            @Override
            public Employee apply(Integer integer) {
                return new Employee(integer);
            }
        };
        System.out.println(fun1.apply(20));
        System.out.println("------------------普通形式---------------");
​
        Function<Integer, Employee> fun2 = id -> new Employee(id);
        System.out.println(fun2.apply(30));
        System.out.println("------------------lambda---------------");
​
        Function<Integer, Employee> fun3 = Employee::new;
        System.out.println(fun3.apply(60));
        System.out.println("------------------l构造器引用---------------");
​
    }
​
​
    //BiFunction中的R apply(T t,U u)
    @Test
    public void test3() {
​
        BiFunction<Integer, String, Employee> b1 = (id, name) -> new Employee(id, name);
        System.out.println(b1.apply(20, "Connor"));
        System.out.println("------------------lambda---------------");
​
        BiFunction<Integer, String, Employee> b2 = Employee::new;
        System.out.println(b1.apply(60, "Robert"));
        System.out.println("------------------构造器引用---------------");
​
    }
​
    //数组引用
    //Function中的R apply(T t)
    @Test
    public void test4() {
        Function<Integer, String[]> fun1 = length -> new String[length];
        String[] apply = fun1.apply(2);
        System.out.println(Arrays.toString(apply));
        System.out.println("------------------lambda---------------");
​
        Function<Integer, String[]> fun2 = String []::new;
        String[] apply1 = fun2.apply(5);
        System.out.println(Arrays.toString(apply1));
        System.out.println("------------------数组引用---------------");
​
    }
}