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-</version>
</dependency>
11.filter():
