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

本文地址：https://blog.csdn.net/weixin_44520739/article/details/107802310