JDK1.8之Lambda解析與表示式的使用

簡介：

Lambda表示式是Java SE 8中一個重要的新特性。lambda表示式允許你通過表示式來代替功能介面。 lambda表示式就和方法一樣,它提供了一個正常的引數列表和一個使用這些引數的主體(body,可以是一個表示式或一個程式碼塊)。
Lambda表示式還增強了集合庫。 Java SE 8新增了2個對集合資料進行批量操作的包: java.util.function 包以及java.util.stream 包。 流(stream)就如同迭代器(iterator),但附加了許多額外的功能。 總的來說,lambda表示式和 stream 是自Java語言新增泛型(Generics)和註解(annotation)以來最大的變化。

Java1.8的新特性
Lambda表示式
函式介面
流式操作
Lambda表示式 就是 匿名函式 在jdk1.7版本以前叫做匿名內部類，JDK1.8後對匿名內部類的升級簡化，在JDK1.8的Lambda 表示式中增加 ->的運算子
運算子左邊是 表示式的 （引數列表）， 運算子的右邊 就是方法體，如果沒有引數或者是 返回值的話（）不用寫 。如果從寫方法的話又多句的話加上大括號(int a, int b){ int c=a+b return c;}
看看一下具體的實現

1.在1.8之前的匿名內部類

  public static void main(String[] args) {
        
        TestService testService = new TestService() {
            @Override
            public void stu() {
                System.out.println("我是1.8之前的匿名內部類"); 
           }
        };
        testService.stu();
    }

2.Lambda表示式的寫法

     public static void main(String[] args) {
        

        TestService testService1 =() -> System.out.println("我是1.8後的Lambda表示式");
        testService1.stu();

    }

匿名內部類一個引數

public static void main(String[] args) {


        TestService testService1 = new TestService() {
            @Override
            public void stu(int a) {
                System.out.println("匿名內部類："+(a+4));
            }
        };
        testService1.stu(4);
    }

Lambda 有一個引數的可以把小括號去掉可加可不加

  public static void main(String[] args) {


        TestService testService1 = n -> System.out.println("就一個引數小括號可以去掉"+(n+4));
        testService1.stu(4);
    }

而兩者對比就可以看出JDK1.8 Lambda的寫法更簡潔更高效。

3.匿名內部類返回值加引數寫法：

 public static void main(String[] args) {


        TestService testService1 =new TestService() {
            @Override
            public Integer stu(Integer a, Integer b) {
                Integer c=a+b;
                return c;
            }
        };
        Integer stu = testService1.stu(1, 2);
        System.out.println("匿名內部類 返回值加引數："+stu);
    }

4有返回值和引數 Lambda表示式

	   public static void main(String[] args) {


        TestService testService1 =(a, b) -> {
            Integer c =a+b;
            return c;
        };
        Integer stu = testService1.stu(4, 5);
        System.out.println("返回值+引數:"+stu);
    }

寫法2 如果就一行的話可以把大括號去掉 和return 去掉

   public static void main(String[] args) {


        TestService testService1 =(a, b) -> a+b;

        Integer stu = testService1.stu(4, 5);
        System.out.println("返回值+引數:"+stu);
    }

消費型介面
當某一個函式可以接受一個資料，並且處理這個資料,處理數量後不需要返回任何的資料。這個 函式需要當做資料傳遞，就使用消費介面

 Consumer<T> 

    public static void  ss(int b,String a, Consumer<String> consumer){
        System.out.println(a+"消費介面"+b+"次");
        consumer.accept(a);
    }

呼叫

 Consumer<String> test=(a)-> System.out.println(a);
        ss(1,"我",test);

方法引用
寫一個函式式介面時，方法的實現（Lambda 體） 已經被某個其他的物件實現了，就不需要在Lambda體中，再次呼叫這個實現，而可以直接使用哪個定義好的方法 。

Function<T, R> 

 TestService testService1= System.out::print;
        testService1.test1("sdds");

供給型介面

如果需要定義函式，可以生產一個需要的函式，這個函式需要當前的資料進行傳遞 就是使用供給介面

Supplier<T>

  Supplier<Integer> supplier=() ->{
          return 5*5;
        };

        Map<Object, Integer> ss = ss(20, supplier);

        System.out.println(ss);

直接傳遞表示式

 Map<Object, Integer> ss = ss(20, ()->6+6);

        System.out.println(ss);

函式型介面

Function<T, R>

 Function<Integer,String> function =(i) ->Integer.toString(i);
        String ss = ss(1, function);
        System.out.println(ss);

斷言介面
如果定義一個函式，接收一個資料判斷是否合法，返回一個boolean結果，用斷言介面， 多個斷言用 or and來拼接

Predicate<T>

  Predicate<String> predicate =(a)-> a!="";
        String ss = ss("SDS", predicate);
        System.out.println(ss);

簡寫

   String ss = ss("SDS", a->a!="");
        System.out.println(ss);

流式操作（Stream介面）
Stream
使用Stream介面代替for迴圈 他是無儲存 Stream 不是資料結構，他是某種資料來源的一個檢視，資料來源可以是一個陣列，java容器，Stream操作不會理解執行只有使用者真正需要的 時候才執行，Stream 只要遍歷遍歷過就會失效，像容器的迭代器那樣，想要遍歷需要生成。
Stream型別資料獲取
Map：
keyset().Stream();
values.Stream();
entrySet.Stream();
陣列
Stream中of方法。Stream.of(陣列)

 List<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        /**
         * stream
         *
         * filter斷言
         *
         * forEach 循列印
         */
       list.stream().filter(n -> n != 3).forEach( System.out::println);


       list.stream().forEach( System.out::println);

        //斷言  求個數
        long count = list.stream().filter(n -> n != 3).count();
        //求總個數
        long count1 = list.stream().count();

        System.out.println("總數"+count);
        
        System.out.println("總數"+count1);

Optional類
Optional是用解決空指標的問題，

Optional<T>

   /**
         of  有值
         */
        String s="sd";
        Optional<String> optional=Optional.of(s);
        optional.ifPresent(a-> System.out.println(a));

  /**
         empty  為null
         */
        String s="sd";
        Optional<String> optional=Optional.empty();
        optional.ifPresent(a-> System.out.println(a));

  /**
         ofNullable  有值就返回沒有則不返回
         */
        String s="sd";
        Optional<String> optional=Optional.ofNullable(s);
        optional.ifPresent(a-> System.out.println(a));

       /**
         ofNullable  有值就返回沒有則不返回
         orElse  沒值替換
         */
        String s=null;
        Optional<String> optional=Optional.ofNullable(s);
        String  str= optional.orElse("測試");
        System.out.println(str);
        optional.ifPresent(a-> System.out.println(a));

時間

    LocalDate 
    
    LocalTime 
        
     LocalDateTime
        

具體使用檢視https://www.cnblogs.com/huanshilang/p/12013386.html