原创

【Java语法系列】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

正文到此结束
本文目录