java1.8重要新特性

interface A {public void sayString(String str);default public void SayInt(int i) {// 接口内默认实现，不需要子类实现，子类可以覆盖或子接口或子抽象类可以覆盖为抽象方法System.out.println("sayInt--->" + i);}
}abstract class B implements A {public abstract void SayInt(int i);
}class C extends B {@Overridepublic void sayString(String str) {System.out.println("sayString--->" + str);}@Overridepublic void SayInt(int i) {System.out.println("sayInt2--->" + i);}}public class Test {public static void main(String[] args) {C c = new C();c.SayInt(21);c.sayString("senssic");}
}

2.Lambada表达式

// 标注此interface为函数式接口,最好写上
@FunctionalInterface
interface A {public String fLambada(String str);// 函数式接口有且仅有一个抽象方法default public void sayInt(int i) {// 函数式接口可以声明多个默认方法System.out.println("sayInt--->" + i);}default public void sayString(String str) {System.out.println("sayInt--->" + str);}
}class B {public void invoke(A a) {System.out.println(a.fLambada("senssic"));}
}public class Test {public static void main(String[] args) {B b = new B();// 以下三中lambada均可，都是通过lambada来省略代码直接实现接口抽象方法b.invoke((String str) -> {System.out.println(str);// 使用大括号写实现代码return "hello " + str;});b.invoke((String str) -> "hello " + str);// 直接返回b.invoke(str -> "hello " + str);// 省略类型直接返回}
}

2.1 方法和构造方法的引用

使用静态方法实现接口抽象方法

@FunctionalInterface
interface A {public String fLambada(String str);default public void sayInt(int i) {System.out.println("sayInt--->" + i);}default public void sayString(String str) {System.out.println("sayInt--->" + str);}
}class B {public void invoke(A a) {System.out.println(a.fLambada("senssic"));}
}public class Test {public static void main(String[] args) {B b = new B();// 通过静态方法来实现接口的抽象方法,类型必须匹配，// 比如此处，valueOf返回的必须为String类型，valueOf传入的参数必须为一个且为String类型A a = String::valueOf;b.invoke(a);}
}

使用普通方法实现抽象接口

@FunctionalInterface
interface A {public String fLambada(String str);default public void sayInt(int i) {System.out.println("sayInt--->" + i);}default public void sayString(String str) {System.out.println("sayInt--->" + str);}
}class B {public void invoke(A a) {System.out.println(a.fLambada("senssic"));}
}class C {public String invSay(String str) {return "world" + str;}
}public class Test {public static void main(String[] args) {B b = new B();C c = new C();A a = c::invSay;//使用非静态方法实现抽象接口，此处C必须先实例化才能调用其invSay方法b.invoke(a);}
}

使用构造方法实现抽象接口

@FunctionalInterface
interface A {public Person fLambada(String name, int age);default public void sayInt(int i) {System.out.println("sayInt--->" + i);}default public void sayString(String str) {System.out.println("sayInt--->" + str);}
}class Person {private String name;private int age;public Person(String name, int age) {this.setName(name);this.setAge(age);}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "姓名：" + name + "--->年龄：" + age;}
}public class Test {public static void main(String[] args) {A a = Person::new;// 此处使用构造方法来实现抽象接口，注意传入参数和返回类型要与接口一致此处构造方法无返回，但jvm会解析为对应的对象Person person = a.fLambada("senssic", 21);// 再也不用写那么多代码来实现工厂了System.out.println(person.toString());}
}

@FunctionalInterface
interface A {public String fLambada(String str);default public void sayInt(int i) {System.out.println("sayInt--->" + i);}default public void sayString(String str) {System.out.println("sayInt--->" + str);}
}class B {public void invoke(A a) {System.out.println(a.fLambada("senssic"));}public void partVab() {// 局部变量// 可以省略final 也正确，编译器会隐式的认为是final修饰的String name = "qiyu";// 或 final String name = "qiyu";this.invoke(str -> {// name = "德玛西亚";// 此处报错,name不能被修改因为隐式为final的return "hello " + str + "and " + name;});}
}public class Test {public static void main(String[] args) {B b = new B();b.partVab();}
}

@FunctionalInterface
interface A {public String fLambada(String str);default public void sayInt(int i) {System.out.println("sayInt--->" + i);}default public void sayString(String str) {System.out.println("sayInt--->" + str);}
}class B {private String cname = "初始化的成员变量";static private String sname = "初始化的静态变量";public void invoke(A a) {System.out.println(a.fLambada("senssic"));}public void partVab() {// 局部变量// 可以省略final 也正确，编译器会隐式的认为是final修饰的String name = "qiyu";// 或 final String name = "qiyu";// static String sr="";//方法内不能声明静态变量this.invoke(str -> {// name = "德玛西亚";// 此处报错,name不能被修改因为隐式为final的cname = "德玛西亚";// 可以访问有读写权限sname = "皮城女警";// 可以访问有读写权限return "hello " + str + "and " + name + "and " + cname + "and "+ sname;});}
}public class Test {public static void main(String[] args) {B b = new B();b.partVab();}
}

3.3 访问默认接口方法

4.内置的函数式接口

import java.util.function.Predicate;public class Test {public static void main(String[] args) {Predicate<String> pre = str -> str.length() == 4;pre = pre.and(p -> p.contains("f"));System.out.println(pre.test("qiyu"));}
}

4.2 Suppliers

import java.util.function.Supplier;class Person {private String name;private int age;public Person() {// 必须有无参构造函数}public Person(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Overridepublic String toString() {// TODO Auto-generated method stubreturn "名字：" + name + "年龄：" + age;}
}public class Test {public static void main(String[] args) {Supplier<Person> pSupplier = Person::new;Person person = pSupplier.get();System.out.println(person.toString());}
}

4.3 Consumers 

Consumer<Person> greeter = (p) -> System.out.println("Hello, " + p.firstName); 
greeter.accept(new Person("Luke", "Skywalker")); 

4.4 Comparators 

Comparator<Person> comparator = (p1, p2) -> p1.firstName.compareTo(p2.firstName); Person p1 = new Person("John", "Doe"); 
Person p2 = new Person("Alice", "Wonderland"); comparator.compare(p1, p2);             // > 0 
comparator.reversed().compare(p1, p2);  // < 0 

4.5 Optionals 

Optional<String> optional = Optional.of("bam");  
optional.isPresent();           // true 
optional.get();                 // "bam" 
optional.orElse("fallback");    // "bam" optional.ifPresent((s) -> System.out.println(s.charAt(0)));     // "b" 

5. Streams

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;public class Test {public static void main(String[] args) {List<String> sList = new ArrayList<String>();sList.add("a1");sList.add("b2");sList.add("ab");sList.add("acc");sList.add("bc");sList.add("cf6");sList.add("a7");sList.add("17");sList.add("236");sList.add("589");sList.add("5898955");// Filter 流过滤,中间操作返回流本身sList.stream().filter(str -> str.length() == 3).filter(str -> str.contains("c")).forEach(System.out::println);// acc// cf6// sorted 流排序,中间操作返回流本身sList.stream().filter(str -> str.contains("c")).sorted((str1, str2) -> {if (str1.length() == str2.length()) {return 0;} else if (str1.length() > str2.length()) {return 1;} else {return -1;}}).forEach(System.out::println);// bc acc cf6// map 流转换对象,中间操作返回流本身sList.stream().filter(str -> str.matches("\\d+")).map(str -> Integer.parseInt(str)).forEach(System.out::println);// 12// 236// 589// match 流匹配,终结操作System.out.println(sList.stream().allMatch(str -> str.length() == 3));// falseSystem.out.println(sList.stream().anyMatch(str -> str.length() > 5));// true// count 返回当前流数量,终结操作long l = sList.stream().filter(str -> str.length() > 3).count();System.out.println(l);// 1// reduce 减少数量合并流对象，终结操作Optional<String> reOptional = sList.stream().filter(str -> str.length() == 3).reduce((str, str2) -> str + "-->" + str2);reOptional.ifPresent(System.out::println);// acc-->cf6-->236-->589// parallelStream 并行排序，效率更快Optional<String> reOptiona = sList.parallelStream().filter(str -> str.length() == 3).reduce((str, str2) -> str + "-->" + str2);reOptiona.ifPresent(System.out::println);// acc-->cf6-->236-->589}}

6.Time API