Java8新特性，你一定能学会的超详细保姆级源码笔记，看完还不会请直接砍我

Java8新特性，你一定能学会的超详细保姆级源码笔记，看完还不会请直接砍我 1. 新特性简介

新特性简介

1. 速度更快

2. 代码更少：新增了Lambda表达式

3. 强大的Stream API

4. 便于并行

5. 最大化减少空指针异常Optional

2. Lambda表达式

介绍

Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

基础语法

1. Java8引入了一个新的 *** 作符： ->，该 *** 作符称为箭头 *** 作符或Lambda *** 作符，箭头 *** 作符将Lambda表达式拆分为2部分

2. 左侧：Lambda表达式的参数列表

3. 右侧：Lambda表达式中所执行的功能，即Lambda体

4. 语法格式1：无参数，无返回值：

   () -> System.out.println( "hello world" );
   

   public class test {
       public static void main(String[] args) {
           Runnable r = new Runnable() {
               @Override
               public void run() {
                   System.out.println("Hello World!");
               }
           };
           r.run();
   
           System.out.println("--------------------------------------");
           Runnable r1 = () -> {
               System.out.println("Hello Lambda");
           };
           r1.run();
       }
   }
   

5. 语法格式2：有一个参数，并且无返回值，小括号可省略不写，：

   public class test {
       public static void main(String[] args) {
           Consumer con = x -> {
               System.out.println(x);
           };
           con.accept("QWERTY");
       }
   }
   

6. 语法格式3：有2个以上的参数，有返回值，并且Lambda体中有多条返回值

   public class test {
       public static void main(String[] args) {
           Comparator com = (x,y) -> {
               System.out.println("函数式接口");
               return Integer.compare(x,y);
           };
       }
   }
   

7. 语法格式4：若Lambda体中只有一条语句，return和大括号都可省略不写

   public class test {
       public static void main(String[] args) {
           Comparator com = (x,y) -> Integer.compare(x,y);
       }
   }
   

8. 语法格式5：Lambda表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出数据类型，即“类型推断”

9. Lambda表达式需要函数式接口的支持！

   函数式接口：接口中只有一个抽象方法的接口，称为函数式接口，可以使用@FunctionalInterface修饰

案例1：简单运算

1. 函数式运算接口

   @FunctionalInterface
   public interface MyFun {
       Integer getValue(Integer num);
   }
   

2. 测试类

   public class test {
   
       public static void main(String[] args) {
           Integer result = operation(10,x ->{
               return x * x;
           });
           System.out.println(result);
       }
   
       //operation方法，参数1为一Integer类型数据，参数2为一运算接口
       public static Integer operation(Integer num, MyFun myFun){
           return myFun.getValue(num);
       }
   }
   

案例2：定制排序比较两个Employee，先按年龄比，年龄相同再按姓名比，使用Lambda作为参数传递

1. Employee

   @Data
   @AllArgsConstructor
   @NoArgsConstructor
   public class Employee {
       private String name;
       private int age;
       private Double salary;
   }
   

2. 测试类

   public class test {
   
       public static void main(String[] args) {
           List list = Arrays.asList(
                   new Employee("1号", 25, 5000.0),
                   new Employee("2号", 35, 3000.0),
                   new Employee("3号", 35, 2000.0),
                   new Employee("4号", 35, 8000.0),
                   new Employee("5号", 65, 1000.0)
           );
           Collections.sort(list,(e1,e2)->{
               if (e1.getAge() == e2.getAge()){
                   return e1.getName().compareTo(e2.getName());
               }else {
                   return -Integer.compare(e1.getAge(),e2.getAge());
               }
           });
           Iterator iterator = list.iterator();
           while (iterator.hasNext()){
               System.out.println(iterator.next());
           }
       }
   }
   

3. 函数式接口

四大核心函数式接口

1. Consumer：消费型接口

   void accept(T t);

2. Supplier：供给型接口

   T get();

3. Function(T,R)：函数型接口

   R apply(T t);

4. Predicate：断言型接口

   boolean test(T t);

例子

1. Consumer：消费型接口

   @Test
   public void test(){
       this.happy(1000,m -> {
           System.out.println("我消费了"+ m);
       });
   }
   
   public void happy(double money, Consumer con){
       con.accept(money);
   }
   

2. Supplier：供给型接口

   @Test
   public void test(){
       List numList = this.getNumList(5, () -> (int) (Math.random() * 100));
       for (Integer integer : numList) {
           System.out.println(integer);
       }
   }
   
   //产生指定数量的整数
   public List getNumList(int num, Supplier sup){
       List list = new ArrayList<>();
       for (int i = 0; i < num; i++) {
           list.add(sup.get());
       }
       return list;
   }
   

3. Function(T,R)：函数型接口

   @Test
   public void test(){
       System.out.println(this.handler("str", str -> (str + "123")));
   }
   
   //处理字符串
   public String handler(String str, Function fun){
       return fun.apply(str);
   }
   

4. Predicate：断言型接口

   @Test
   public void test(){
       List stringList = Arrays.asList("qwe", "123", "hello", "ranhaifeng", "asdasdsaewqewqe");
       List list = filterStr(stringList, s -> (s.length() > 3));
       for (String s : list) {
           System.out.println(s);
       }
   }
   
   //将满足条件的字符串放入集合
   public List filterStr(List list, Predicate pre){
       List stringList = new ArrayList<>();
       for (String s : list) {
           if (pre.test(s)){
               stringList.add(s);
           }
       }
       return stringList;
   }
   

其他接口

4. 方法引用与构造器引用

方法引用

1. 方法引用:若 Lambda 体中的内容有方法已经实现了，我们可以使用“方法引用”，可以理解为方法引用是Lambda表达式的另外一种表现形式。

2. 主要有三种语法格式：

   • 对象::实例方法名
   • 类::静态方法名
   • 类::实例方法名

3. 例子

       //对象::实例方法
       @Test
       public void test(){
           Consumer con = x -> {
               System.out.println(x);
           }; 
           PrintStream out = System.out;
           Consumer con1 = out::println;
           Consumer con2 = System.out::println;
           con2.accept("qwe");
       } 
   
       //类::静态方法名
       @Test
       public void test(){
           int x;int y;
           Comparator com = (x,y)-> Integer.compare(x,y);
           Comparator com1 = Integer::compare;
       }
   
   
       // 类::实例方法名
       @Test
       public void test(){
           BiPredicate bp = (x,y) -> x.equals(y);
           BiPredicate bp2 = String::equals;
       }
   

4. 注意：

   • Lambda体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的函数列表和返回值类型保持一致！
   • 若Lambda参数列表中的第一参数是实例方法的调用者，第二个参数是实例方法的参数时，可以使用ClassName::method

构造器引用

1. 例子

       @Test
       public void test(){
           Supplier