java8：（Lambda 表达式，Supplier，@FunctionalInterface，foreach()，Optional，Stream().collect，双冒号，joining，partitioningBy分区，collectingAndThen，filter()）
1.Lambda 表达式：
引导：http://www.cnblogs.com/yulinfeng/p/8452379.html
DEMO1:
List<String> names1 = new ArrayList<String>(); names1.add("Google "); names1.add("Runoob "); names1.add("Taobao "); names1.add("Baidu "); names1.add("Sina "); List<String> names2 = new ArrayList<String>(); names2.add("Google "); names2.add("Runoob "); names2.add("Taobao "); names2.add("Baidu "); names2.add("Sina "); Compare tester = new Compare(); System.out.println("使用 Java 7 语法: "); tester.sortUsingJava7(names1); System.out.println(names1); System.out.println("使用 Java 8 语法: "); tester.sortUsingJava8(names2); System.out.println(names2); } // 使用 java 7 排序 private void sortUsingJava7(List<String> names){ Collections.sort(names, new Comparator<String>() { @Override public int compare(String s1, String s2) { return s1.compareTo(s2); } }); } // 使用 java 8 排序 private void sortUsingJava8(List<String> names){ Collections.sort(names, (s1, s2) -> s1.compareTo(s2)); }
DEMO2:
final static String salutation = "Hello! "; public static void main(String args[]) { Declare tester = new Declare(); // 类型声明 MathOperation addition = (int a, int b) -> a + b; // 不用类型声明 MathOperation subtraction = (a, b) -> a - b; // 大括号中的返回语句 MathOperation multiplication = (int a, int b) -> { return a * b; }; // 没有大括号及返回语句 MathOperation division = (int a, int b) -> a / b; // System.out.println("10 + 5 = " + tester.operate(10, 5, addition)); // System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction)); // System.out.println("10 x 5 = " + tester.operate(10, 5, // multiplication)); // System.out.println("10 / 5 = " + tester.operate(10, 5, division)); // 不用括号 // GreetingService greetService1 = message -> // System.out.println("Hello " + message); // // // 用括号 // GreetingService greetService2 = (message) -> // System.out.println("Hello " + message); // greetService1.sayMessage("Runoob"); // greetService2.sayMessage("Google"); // lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda // 内部修改定义在域外的局部变量，否则会编译错误。 // GreetingService greetService1 = message -> // System.out.println(salutation + message); // greetService1.sayMessage("Runoob"); // 我们也可以直接在 lambda 表达式中访问外层的局部变量： // final int num = 1; // Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num)); // s.convert(2); // 输出结果为 3 //lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义） // int num = 1; // Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num)); // s.convert(2); //num =2会报错 // 在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。 // String first = ""; // Comparator<String> comparator = (first, second) -> Integer.compare(first.length(), second.length()); //编译会出错 } public interface Converter<T1, T2> { void convert(int i); } interface MathOperation { int operation(int a, int b); } interface GreetingService { void sayMessage(String message); } private int operate(int a, int b, MathOperation mathOperation) { return mathOperation.operation(a, b); }
2.Supplier：
public class SupplierTest { private int age; public SupplierTest() { System.out.println(age); } public static void main(String[] args) { //创建Supplier容器，声明为SupplierTest类型，此时并不会调用对象的构造方法，即不会创建对象 Supplier<SupplierTest> s = SupplierTest::new; //调用get()方法，此时会调用对象的构造方法，即获得到真正对象 s.get(); //每次get都会调用构造方法，即获取的对象不同 s.get(); } }
3.@FunctionalInterface
@FunctionalInterface标记在接口上，“函数式接口”是指仅仅只包含一个抽象方法的接口
（1）该注解只能标记在"有且仅有一个抽象方法"的接口上。
（2）JDK8接口中的静态方法和默认方法，都不算是抽象方法。
（3）接口默认继承java.lang.Object，所以如果接口显示声明覆盖了Object中方法，那么也不算抽象方法。
（4）该注解不是必须的，如果一个接口符合"函数式接口"定义，那么加不加该注解都没有影响。加上该注解能够更好地让编译器进行检查。如果编写的不是函数式接口，但是加上了@FunctionInterface，那么编译器会报错。
4.foreach()
package com.test; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; public class Other { public static void main(String[] args) { testForeach2(); } private static void testForeach2() { List<String> items = new ArrayList<>(); items.add("A"); items.add("B"); items.add("C"); items.add("D"); items.add("E"); // items.forEach((x)->{System.out.println(x);}); // items.forEach(System.out::println); // items.stream().filter(s->s.contains("B")).forEach(System.out::println); } private static void testForeach1() { Map<String, Integer> items = new HashMap<>(); items.put("A", 10); items.put("B", 20); items.put("C", 30); items.put("D", 40); items.put("E", 50); items.put("F", 60); items.forEach((k,v)->System.out.println("Item : " + k + " Count : " + v)); items.forEach((k,v)->{ System.out.println("Item : " + k + " Count : " + v); if("E".equals(k)){ System.out.println("Hello E"); } }); } }
5.Optional:
package test; import java.util.Optional; public class Test1 { public static void main(String[] args) { Test1 java8Tester = new Test1(); Integer value1 = null; Integer value2 = new Integer(10); // Optional.ofNullable - 允许传递为 null 参数 Optional<Integer> a = Optional.ofNullable(value1); // Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException Optional<Integer> b = Optional.of(value2); System.out.println(a.ofNullable(3).orElse(2)); } public Integer sum(Optional<Integer> a, Optional<Integer> b){ // Optional.isPresent - 判断值是否存在 System.out.println("第一个参数值存在: " + a.isPresent()); System.out.println("第二个参数值存在: " + b.isPresent()); // Optional.orElse - 如果值存在，返回它，否则返回默认值 Integer value1 = a.orElse(new Integer(0)); //Optional.get - 获取值，值需要存在 Integer value2 = b.get(); return value1 + value2; } }
6.Stream().collect
7.双冒号
8.joining:
9.partitioningBy分区：
10.collectingAndThen:
<!-- https://mvnrepository.com/artifact/com.google.code.google-collections/google-collect --> <dependency> <groupId>com.google.code.google-collections</groupId> <artifactId>google-collect</artifactId> <version>snapshot-20080530</version> </dependency>
11.filter():
