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("------------------数组引用---------------"); } }
