Java8新特性

Lambda表达式

/**  * Lambda表达式的使用  * 1.举例：(o1,o2)->Integer.compare(o1,o2);  * 2.格式：  *         ->Lambda操作符  或  箭头操作符  *         ->左边： lambda形参列表（其实就是接口中的抽象方法的形参列表）  *         ->右边： Lambda体（其实就是重写的抽象方法的方法体）  *3.Lambda表达式的使用：分为六种情况  *总结：  *      ->左边：Lambda形参列表的参数类型可以省略（类型推断）。如果参数列表只有一个参数，小括号也可以省略  *      ->右边：Lambda体应该使用一对大括号，如果Lambda体只有一条执行语句（可能是return语句），那么可以省略这一对大括号和return。  *4.Lambda本质：接口都必须是函数式接口。（接口里面只有一个抽象方法）  */ public class LambdaTest1 { //语法格式一：无参，无返回值 @Test public void test1(){         Runnable runnable = new Runnable() { @Override public void run() {                 System.out.println("123"); } };          runnable.run();         System.out.println("**************");         Runnable r2=()-> {             System.out.println("456"); };         r2.run(); } @Test public void test2(){ //语法格式二：Lambda需要一个参数，但是没有返回值         Consumer<String> con=new Consumer<String>(){ @Override public void accept(String s) {                 System.out.println("s"); } };         con.accept("46789");         System.out.println("***********************");         Consumer<String> con1=(String s)->{             System.out.println(s); };         con1.accept("753159"); } @Test public void test3(){ //语法格式三：数据类型可以省略，因为可由编译器推断得出，称为类型推断         Consumer<String> con1=(String s)->{             System.out.println("s"); };          System.out.println("******************");         Consumer<String> con2=(s)->{             System.out.println(s); }; } @Test public void test4(){ //语法格式四：Lambda若只需要一个参数，参数的小括号可以省略         Consumer<String> con1=(s)->{             System.out.println("s"); };         con1.accept("123");         System.out.println("******************");         Consumer<String> con2=s->{             System.out.println(s); };         con2.accept("45659"); } @Test public void test5(){ //语法格式五：Lambda若需要两个或以上的参数，多条执行语句，并且可以有返回值         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(o2); } };         System.out.println("******************");         Comparator<Integer> com2=(o1,o2)->{             System.out.println(o1);             System.out.println(o2); return o1.compareTo(o2); }; } @Test public void test6(){ //语法格式六：Lambda只有一条语句的时候，return与大括号若有，都可以省略         Comparator<Integer> com1=new Comparator<Integer>(){ @Override public int compare(Integer o1, Integer o2) { return o1.compareTo(o2); } };         System.out.println("******************");         Comparator<Integer> com2=(o1,o2)-> o1.compareTo(o2); } } 

函数式接口：

特点：只有一个抽象方法

• 你可以通过Lambda表达式来创建该接口的对象。（若Lambda表达式抛出一个受检异常，即：非运行时异常。那么该异常需要在目标接口的抽象方法上进行声明）。
• 我们可以在一个接口上使用@Functionallnterface注解，这样做可以检查它是否是一个函数式接口。同时javadoc也会包含一个声明，说明这个接口是一个函数式接口。
• 在java.util.function包下定义了Java8的丰富的函数式接口。

Java内置四大核心函数式接口

示例：

/**  * Java内置的4大核心函数式接口  * 消费型接口Consumer<T>   void accept(T t)  * 供给型接口Supplier<T>    T get()  * 函数接口Function<T,R>    R apply(T t)  * 断定型接口Predicate<T>   boolean test(T t)  */ public class LambdaTest2 { @Test public void test1(){ happyTime(500,money-> System.out.println(money)); } public void happyTime(double money, Consumer<Double> con){         con.accept(money); } @Test public void test2(){         List<String> List= Arrays.asList("123","456","789");         java.util.List<String> strings = filterString(List, s -> s.contains("3"));         System.out.println(strings); } //根据给定的规则过滤集合中的字符串 public List<String> filterString(List<String> list,Predicate<String> pre){         ArrayList<String> filterList=new ArrayList<>(); for(String s:list){ if(pre.test(s)){                 filterList.add(s); } } return filterList; } } 

方法引用、构造器引用及数组引用

方法引用：

• 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用。

• 方法引用可以看做是Lambda表达深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。

• 要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致。

• 格式：使用操作符 “：：“将类（或对象）与方法名分隔开。

• 如下三种主要使用情况：

  对象：：实例方法名

  类：：静态方法名

  类：：实例方法名

方法引用的示例：

/**  * 方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值类型  * 与方法引用的方法的形参列表和返回值类型相同。(针对情况一、二)  */ public class LambdaTest3 { //情况一：    对象：：方法名 //Consumer中的void accept(T t) //printStream中的void println(T t) @Test public void test1(){         Consumer<String> con1=str-> System.out.println(str);         con1.accept("背景");         System.out.println("***************");         PrintStream ps=System.out;         Consumer<String> con2=ps::println;         con2.accept("哈哈"); } //Supplier中的T get() //Emplyee中的String getName() @Test public void test2(){          Employee employee = new Employee(1001, "Tom", 2600);         Supplier<String> con1=()->employee.getName();         System.out.println(con1.get());         System.out.println("****************");         Supplier<String> con2=employee::getName;         System.out.println(con2.get()); } //情况二：   类：：静态方法 //Comparator中的int compare(T t1,T t2) //Integer中的int compare(T t1,T t2) @Test public void test3(){         Comparator<Integer> con1=(o1,o2)->o1.compareTo(o2);         System.out.println(con1.compare(12,31));         System.out.println("***********************");         Comparator<Integer> con2=Integer::compareTo;         System.out.println(con2.compare(12,3)); } //Function中的R apply(T t) //Math中的Long round(Double d) @Test public void test4(){         Function<Double,Long> func=new Function<Double,Long>(){ @Override public Long apply(Double d) { return Math.round(d); } };         System.out.println("**********************");         Function<Double,Long> func2=d->Math.round(d);         System.out.println("***********************");         Function<Double,Long> func3=Math::round; } //情况三:        类：：实例方法 //Comparator中的int compare(T t1,T t2) //String中的int t1.compareTo(t2) @Test public void test5(){         Comparator<String> con1=(o1,o2)->o1.compareTo(o2);         System.out.println(con1.compare("abc","asdf"));         System.out.println("***************");         Comparator<String> con2=String::compareTo; } } 

构造器引用：

和方法引用类似，函数接口的抽象方法的形参列表和构造器的形参列表一致。

抽象方法的返回值类型即为构造器所属的类的类型。

构造器引用示例：

public class ConstructorRefTest { //构造器引用 //Supplier中的T get() @Test public void test1(){         Supplier<Employee> sup1=()->new Employee();          Supplier<Employee> sup2=Employee::new; } //Function中的R apply(T t) @Test public void test2(){          Function<Integer,Employee> func1=id->new Employee(id);         Employee apply = func1.apply(1001);         System.out.println(apply);          Function<Integer,Employee> func2=Employee::new;         Employee apply1 = func2.apply(123);         System.out.println(apply1); } //BiFunction中的R apply(T t,U u) @Test public void test3(){         BiFunction<Integer,String,Employee> fun1=(str,name)->new Employee();         Employee hahah = fun1.apply(1, "hahah");         System.out.println(hahah);          BiFunction<Integer,String,Employee> fun2=Employee::new; } } 

数组引用：

可以把数组看作特殊的类，则写法跟构造器引用类似。

数组引用示例：

/数组引用     //Function中的R apply(T t) @Test public void test4(){         Function<Integer,String[]> fun1= Length->new String[Length];         String[] apply = fun1.apply(10);         System.out.println(Arrays.toString(apply));          Function<Integer,String[]> fun2=String[] :: new;         String[] apply1 = fun2.apply(10);         System.out.println(apply1); } 

Stream API

创建Stream的方式：

public class StreamAPITest { //创建Stream方式一：通过集合 @Test public void test1(){         List<Employee> employees=EmployeeData.getEmployees(); //default Stream<E> stream():返回一个顺序流         Stream<Employee> stream = employees.stream(); //default Stream<E> parallelStream():返回一个并行流         Stream<Employee> parallelStream = employees.parallelStream(); } //创建Stream方式二：通过数组 @Test public void test2(){ //调用Arrays类的static<T> Stream<T> stream(T[]  array):返回一个流 int[] arr =new int[]{1, 2, 3, 4, 5, 6};         IntStream stream = Arrays.stream(arr);          Employee employee1 = new Employee(1001,"Tom");         Employee employee2 = new Employee(1002,"Jerry");         Employee[] employees = {employee1, employee2};         Stream<Employee> stream1 = Arrays.stream(employees); } //创建Stream方式三：通过Stream的of() @Test public void test3(){         Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6); } } 

Stream的中间操作：

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部狐狸，称为“惰性求值”。

• 筛选与切片

public class StreamAPITest1 { @Test public void test1(){         List<Employee> list=EmployeeData.getEmployees(); //方法一：filter(Predicate p)  接收Lambda,从流中排除某些元素         Stream<Employee> stream=list.stream(); //练习：查询员工表中薪资大于7000的员工信息         stream.filter(e->e.getSalary() >7000).forEach(System.out::println); //方法二：limit(n)---截断流   使其元素不超过给定数量 //练习：查询员工表中前三条员工信息         list.stream().limit(3).forEach(System.out::println); //方法三：skip(n)---跳过元素，返回一个扔掉了前n个元素的流，若流中元素不足n个，则返回一个空值。         list.stream().skip(3).forEach(System.out::println); //方法四：distinct()---筛选，通过流所生成元素的hashCode()和equals()去除重复元素         list.stream().distinct().forEach(System.out::println); } } 

• 映射

//映射 @Test public void test2(){ //map(Function f)         List<String> list = Arrays.asList("aa", "bb", "cc", "dd");         list.stream().map(str->str.toUpperCase()).forEach(System.out::println);          List<Employee> list1 = EmployeeData.getEmployees();         Stream<String> stream = list1.stream().map(str -> str.getName());         stream.filter(name->name.length()>3).forEach(System.out::println); } 

• 排序

//排序 @Test public void test3(){ //sorted()---自然排序         List<Integer> list = Arrays.asList(12, 23, 45, 56, 78, 89);         list.stream().sorted().forEach(System.out::println); //要求Employee类实现自然排序（实现Comparable接口）         List<Employee> employees = EmployeeData.getEmployees();         employees.stream().sorted().forEach(System.out::println); //sorted(Comparator com)----定制排序          List<Employee> employees1 = EmployeeData.getEmployees();         employees1.stream().sorted((e1,e2)->{ int compare = Integer.compare(e1.getAge(), e2.getAge()); if(compare!=0){ return compare; }else{ return Integer.compare(e1.getSalary(), e2.getSalary()); } }).forEach(System.out::println); } 

Stream的终止操作：

• 匹配与查找

public class StreamAPITest2 { //匹配与查找 @Test public void test1(){         List<Employee> employees = EmployeeData.getEmployees(); //allMatch(Predicate p)---检查是否匹配所有元素 //所有员工的年龄是否都大于十八岁 boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);         System.out.println(allMatch); //anyMatch(Predicate p)---检查是否至少匹配所一个元素 //是否存在员工的年龄大于十八岁 boolean anyMatch = employees.stream().anyMatch(e -> e.getAge() > 18);         System.out.println(anyMatch); //noneMatch(Predicate p)---检查是否没有匹配所有元素 //是否存在员工姓“雷” boolean noneMatch = employees.stream().noneMatch(e -> e.getName().contains("雷"));         System.out.println(noneMatch); //findFirst---返回第一个元素         Optional<Employee> first = employees.stream().findFirst();         System.out.println(first); //findAny---返回当前流中的任意元素         Optional<Employee> any = employees.stream().findAny();         System.out.println(any); } @Test public void test2(){         List<Employee> employees = EmployeeData.getEmployees(); //count---返回流中元素的个数 long count = employees.stream().filter(e->e.getSalary()>5000).count();         System.out.println(count); //max(Comparator c)----返回流中最大值         Stream<Integer> integerStream = employees.stream().map(e -> e.getAge());         Optional<Integer> max = integerStream.max(Double::compare);         System.out.println(max); //max(Comparator c)----返回流中最小值         Optional<Employee> min = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));         System.out.println(min); } } 

• 归约

public class StreamAPITest3 { //归约 @Test public void test1(){ //reduce(T identity,BinaryOperator) //计算1-10自然数之和         List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);         Integer reduce = list.stream().reduce(0, Integer::sum);         System.out.println(reduce); //reduce(BinaryOperator)         List<Employee> employees = EmployeeData.getEmployees(); //        Optional<Integer> reduce1 = employees.stream().map(Employee::getSalary).reduce(Double::sum);         Optional<Integer> reduce1 = employees.stream().map(Employee::getSalary).reduce((d1, d2) -> d1 + d2);         System.out.println(reduce1); } } 

• 收集

@Test public void test2(){ //查询工资大于6000的员工，结果返回为一个List或Set         List<Employee> employees = EmployeeData.getEmployees();         List<Employee> list = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());         list.forEach(System.out::println);          Set<Employee> list1 = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());         list1.forEach(System.out::println); } 

Optional类

public class OptionalTest { @Test public void test1(){         Girl girl=new Girl();         girl=null; //of(T t):保证t是非空的         Optional<Girl> girl1 = Optional.of(girl); } @Test public void test2(){         Girl girl=new Girl();         girl=null; //ofNullable(T t):t可以为空         Optional<Girl> girl1 = Optional.ofNullable(girl);         System.out.println(girl1); //orElse(T t1):如果当前的Optional内部封装的t是非空的，则返回内部的t。 //如果内部的t是空的，则返回orElse()方法中的参数t1.         Girl girl2 = girl1.orElse(new Girl("木子"));         System.out.println(girl1); } @Test public String getGirlName(Boy boy){ return boy.getGirl().getName(); } @Test public void test3(){         Boy boy = new Boy();         String girlName = getGirlName(boy);         System.out.println(girlName); } //优化以后的getGirlName() @Test public String getGirlName1(Boy boy){ if(boy!=null){             Girl girl = boy.getGirl(); if(girl!=null){ return girl.getName(); } } return null; } @Test public void test4(){         Boy boy = new Boy();         boy=null;         String girlName1 = getGirlName1(boy);         System.out.println(girlName1); } //使用Optional类的getGirlName2() @Test public String getGirlName2(Boy boy){         Optional<Boy> boyOptional = Optional.ofNullable(boy);          Boy boy1 = boyOptional.orElse(new Boy(new Girl("迪丽热巴"))); //boy1一定非空         Girl girl = boy1.getGirl();         Optional<Girl> girl1 = Optional.ofNullable(girl); //girl2一定非空         Girl girl2 = girl1.orElse(new Girl("杨幂")); return girl2.getName(); } }