Java8新特性之Lambda表达式、函数式接口、Stream API（笔记）

最新推荐文章于 2024-06-07 01:26:48 发布
最新推荐文章于 2024-06-07 01:26:48 发布
阅读量573 收藏 1
点赞数 2
分类专栏： java学习 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzfaq/article/details/122060851
版权

1、Lambda表达式

Lambda是java8的新特性，使用Lambda可以替代只有一个抽象方法的接口（函数接口）实现，类似于匿名内部类。

1.1 、Lambda的语法格式

（）-> {}
  • (): 用来描述参数列表。
  • {}：用来描述方法体、执行语句，当只有一条执行语句或只有返回值的时候可以省略。
  • -> :Lambda运算符

1.2、Lambda基本语法实例
创建多个接口

public interface LambdaInterface {
    int test1();
}

@FunctionalInterface
public interface LambdaInterface1 {
    int test2(int a);
}

@FunctionalInterface
public interface LambdaInterface2 {
   int test3(int a,int b);
}

@FunctionalInterface
public interface LambdaInterface3 {
    void test4();
}

@FunctionalInterface
public interface LambdaInterface4 {
  void test5(int a);
}


@FunctionalInterface
public interface LambdaInterface5 {
   void test6(int a,int b);
}

测试类

public class LambdaTest {
    public static void main(String[] args) {
        /**
         * 无参数，有返回值
         */

        //LambdaInterface test = () ->{return 200;};
        LambdaInterface test = () -> 200;
        int i2 = test.test1();
        System.out.println(i2);
        /**
         * 有单个参数，有返回值
         */
        //LambdaInterface1 test2 = (int a) ->{return a;};
        LambdaInterface1 test2 = a -> a;
        int i3 = test2.test2(200);
        System.out.println(i3);
        /**
         * 有多个参数，有返回值
         */
        //LambdaInterface2 test3 =(int a ,int b) -> {return a-b;};
        LambdaInterface2 test3 =(a,b) -> a-b;
        int i = test3.test3(20, 1);
        System.out.println(i);
        /**
         * 有参数，无返回值
         */
       // LambdaInterface4 test4 = a -> {System.out.println(a);};
        LambdaInterface4 test4 = a -> System.out.println(a);
        test4.test5(12);
        /**
         * 有多个参数，无返回值
         */
        //LambdaInterface5 test5 = (a, b) ->{System.out.println("a="+a+"  b="+b);};
        LambdaInterface5 test5 = (a, b) -> System.out.println(a+b);
        test5.test6(12,24);
        /**
         * 无参数，无返回值
         */
        LambdaInterface3 test6 = () -> System.out.println("无参数，无返回值！");
        test6.test4();
    }

}

输出结果
在这里插入图片描述
1.3、Lambda的方法引用

方法引用：若Lambda体中的内容有方法已经实现了，我们可以使用“方法引用（可以理解为方法引用是Lambda表达式的另一种表现形式）
主要有三种语法格式：
对象::实例化方法名
类::静态方法名
类::实例方法名
注意：1、Lambda体中调用方法的参数列表于返回值类型，要与函数式接口中抽象方法的函数列表和返回值类型保持一致！
2、若Lambda参数列表中的第一参数是实例方法的调用者，而第二个参数是实例方法的参数时，可以ClassName::method

  //对象::实例方法名
    @Test
    public  void test1(){
        //Consumer<String> con1 =(x) -> System.out.println(x);
        Consumer<String> con = System.out::println;
        con.accept("adcdef");
    }
    //类::静态方法名
    @Test
    public void test2(){
      //Comparator<Integer> com = (x ,y) ->Integer.compare(x,y);

      Comparator<Integer> com1 = Integer::compare;
    }
    //类::实例方法名
    @Test
    public void test3(){
        //BiPredicate<String,String> bp =(x,y) -> x.equals(y);
        BiPredicate<String,String> bp =String::equals;
    }
    //数组引用
    @Test
    public void test4(){
        //Function<Integer,String[]> fun =(x) ->new String[x];
        Function<Integer,String[]> fun = String[]::new;
        String[] strs = fun.apply(10);
        System.out.println(strs.length);
    }

}

输出结果
在这里插入图片描述
1.4、方法引用（构造函数）
创建实体类

public class Person {
    public String name;
    public int age;

    public Person(){
        System.out.println("这是无参构造方法");
    }
    public Person(String name,int age){
        System.out.println("这里是有参构造");
        this.name=name;
        this.age=age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

创建接口

interface LambdaInterfaceTest{
    Person getPerson();
}
interface LambdaInterfaceTest1{
    Person getPerson(String name,int age);
}

测试类


public class LambdaTest2 {
    public static void main(String[] args) {
        LambdaInterfaceTest test = ()-> new Person();
        test.getPerson();
        //构造方法的引用
        LambdaInterfaceTest test1 = Person::new;
        test1.getPerson();
        LambdaInterfaceTest1 test11 =Person::new;
        test11.getPerson("lzf",12);

    }
}

输出结果
在这里插入图片描述

2、函数式接口

1、Lambda表达式使用前提，接口必须是一个函数接口
2、函数式接口(FunctionalInterface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
3、函数式接口可以被隐式转换为 lambda 表达式。
4、 Lambda 表达式和方法引用（实际上也可认为是Lambda表达式）上
5、使用注解@FunctionalInterface

四大内置核心函数接口

public class Lambda5 {
    //Supplier<T>
    @Test
    public void test1(){
        List<Integer> numList = getNumList(10, () -> (int) (Math.random() * 100));
        for (Integer n:numList) {
            System.out.print(n+" ");
        }
    }
    //需求：产生指定个数的整数，并放入集合中
    public List<Integer> getNumList(int num, Supplier<Integer> sup){
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            Integer n = sup.get();
            list.add(n);
        }
        return list;

    }
    @Test
    //Predicate<T>
    public void test2(){
        List<String> list = Arrays.asList("kzf","sdad","sdada","hwidh");
        List<String> strings = filterStr(list, (s -> s.length() > 3));
        for (String a:strings) {
             System.out.print(a+" ");
        }
    }
    //将满足条件的字符串，放入集合中
    public List<String> filterStr(List<String> list, Predicate<String> pre){
        List<String> list1 = new ArrayList<>();
        for (String a: list) {
            if(pre.test(a)){
                list1.add(a);
            }
        }
        return list1;
    }
    //Consumer<T> :处理字符串
    @Test
    public void test3(){
        nihao("dci",(m)-> System.out.println("你好"+m));
    }
    public void nihao(String name, Consumer<String> con){
        con.accept(name);
    }

    //Function<T,R>函数型接口：
    @Test
    public void test4(){
        String s = strHandler("\t\t\t你好我他", (str) -> str.trim());
        System.out.println(s);

    }
    public String strHandler(String str, Function<String,String> fun){
        return fun.apply(str);
    }
}

输出结果

1、22 30 82 84 54 49 62 38 55 2
2、sdad sdada hwidh
3、你好dci
4、你好我他

系统内置的一些函数式接口

public class FunctionalInterface {
    public static void main(String[] args) {

        // Predicate<T>              ：     参数是T 返回值boolean  
        // 在后续如果一个接口需要指定类型的参数，返回boolean时可以指向 Predicate
        //          IntPredicate            int -> boolean
        //          LongPredicate           long -> boolean
        //          DoublePredicate         double -> boolean

        // Consumer<T>               :      参数是T 无返回值(void)
        //          IntConsumer             int ->void
        //          LongConsumer            long ->void
        //          DoubleConsumer          double ->void

        // Function<T,R>             :      参数类型T  返回值R
        //          IntFunction<R>          int -> R
        //          LongFunction<R>         long -> R
        //          DoubleFunction<R>       double -> R
        //          IntToLongFunction       int -> long
        //          IntToDoubleFunction     int -> double
        //          LongToIntFunction       long -> int
        //          LongToDoubleFunction    long -> double
        //          DoubleToLongFunction    double -> long
        //          DoubleToIntFunction     double -> int

        // Supplier<T> : 参数 无 返回值T
        // UnaryOperator<T> :参数T 返回值 T
        // BiFunction<T,U,R> : 参数 T、U 返回值 R
        // BinaryOperator<T> ：参数 T、T 返回值 T
        // BiPredicate<T,U> :  参数T、U  返回值 boolean
        // BiConsumer<T,U> :    参数T、U 无返回值

        /**
         * 常用的 函数式接口
         * Predicate<T>、Consumer<T>、Function<T,R>、Supplier<T>
         */
    }
}

3、Stream Api

创建stream的几种方法

public class LambdaTest6 {
    @Test
    public void test1(){
        //创建Stream
        //1、可以通过Collection系列集合提供的stream（）或parallelStream（）
        List<String> list = new ArrayList<>();
        Stream<String> stream = list.stream();

        //2.通过Stream类中的静态方法of（）
        Stream<String> aa = Stream.of("aa", "bb", "cc");

        //3.通过Arrays中的静态方法stream（）获取数据流
        Person[] person = new Person[10];
        Stream<Person> stream1 = Arrays.stream(person);

        //4.创建无限流
        Stream<Integer> iterate = Stream.iterate(0, (x) -> x + 2);
        iterate.limit(10).forEach(System.out::println);

        //5.生成
        Stream.generate(()->Math.random()*100).limit(10).forEach(System.out::println);
    }

生成测试数据

  List<Person> personList = Arrays.asList(
            new Person("张三", 14),
            new Person("李四", 28),
            new Person("王五", 38),
            new Person("张三", 59),
            new Person("张三", 75),
            new Person("张三", 75),
            new Person("张三", 75)
    );

筛选和切片


    //filter --接受Lambda，从流中排出某些元素
    @Test
    public void test1() {
        Stream<Person> stream = personList.stream()
                .filter((e) -> e.getAge() > 30);
        stream.forEach(System.out::println);
    }

    /**
     * 运行结果
     * Person{name='王五', age=38}
     * Person{name='张三', age=59}
     * Person{name='张三', age=75}
     * Person{name='张三', age=75}
     * Person{name='张三', age=75}
     */

    //limit--截断流，使其元素不超过给定数量
    @Test
    public void test2() {
        personList.stream()
                .filter((e) -> e.getAge() > 30)
                .limit(2)
                .forEach(System.out::println);
    }

    /**
     * 运行结果
     * Person{name='王五', age=38}
     * Person{name='张三', age=59}
     */

    //skip（n）跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回一个空流。与 limit（互补）
    @Test
    public void test3() {
        personList.stream()
                .filter((e) -> e.getAge() > 30)
                .limit(2)
                .skip(1)
                .forEach(System.out::println);
    }

    /**
     * 运行结果
     Person{name='张三', age=59}
     */

    //distinct --筛选，通过流所生成元素的hashCode（）和equals（）去除重复元素
    @Test
    public void test4() {
        personList.stream()
                .filter((e) -> e.getAge() > 30)
                .limit(2)
                .skip(1)
                .distinct()
                .forEach(System.out::println);
    }

    /**
     * 运行结果
     Person{name='张三', age=59}
     */

排序

 @Test
   @Test
    //自然排序
    public void test5(){
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        list.stream()
                .sorted()
                .forEach(System.out::println);
    }
    /**
     * 运行结果
     * 1
     * 2
     * 3
     * 4
     * 5
     */

查找 / 匹配

   //findAny()和findFist()获取第一条数据,如果没有就返回为空。
    @Test
    public void test6() {
        Person person = personList.stream()
                .filter((e) -> e.getAge() > 30)
                .limit(2)
                .findAny()
                .orElse(null);
        System.out.println(person);
    }

    /**
     * 运行结果
     * Person{name='王五', age=38}
     */

    //map(T -> R):使用map取出姓名（字符串）
    @Test
    public void test7(){
        personList.stream()
                .map(Person::getName)
                .forEach(System.out::println);
    }

    /**
     * 运行结果
     * 张三
     * 李四
     * 王五
     * 张三
     * 张三
     * 张三
     * 张三
     */

判断方法

  • 判断List集合中是否有一个元素包含姓名为张三的元素
  • 判断List集合中是否所有实体名称都包含"张"这个字段。
  • 判断List集合中是否存在不包含"张"这个字段。
@Test
    public void test8(){
        boolean result = personList.stream().anyMatch((person -> person.getName().equals("张三")));
        boolean result1 = personList.stream().allMatch(person -> person.getName().contains("张"));
        boolean result2 = personList.stream().noneMatch(person -> person.getName().contains("张"));
        System.out.println(result);
        System.out.println(result1);
        System.out.println(result2);
    }
    /**
     * 运行结果
     * true
     * false
     * false
     */

统计方法

  • reduce((T, T) -> T) 和 reduce(T, (T, T) -> T)
@Test
    public void test9(){
        Integer max = personList.stream().map(Person::getAge).reduce(Integer::max).get();
        Integer min = personList.stream().map(Person::getAge).reduce(Integer::min).get();
        Integer sum = personList.stream().map(Person::getAge).reduce(0,Integer::sum);

        System.out.println(max);
        System.out.println(min);
        System.out.println(sum);
    }
    /**
     * 运行结果
     * 75
     * 14
     * 364
     */
恣意i
关注
专栏目录
java8新特性-Lambda表达式-Stream API-Optional类等
Xia_tomato的博客
10-09 276
一、简介 1、java8新特性最核心的是lamda表达式和Stream API （1）lambda表达式、函数式接口、方法引用与构造器引用、Stream API、接口中的默认方法与静态方法、新时间日期API、其他新特性 （2）优点：速度更快、代码更少（增加了新语法lambda表达式）、强大的Stream API、便于并行、最大化减少空指针异常 Optional容器类 底层数据结构是HashMap，底层内存结构 二、lambda表达式 1、Lambda是一个匿名函数，可理解为一段可以传递的代码。
Java笔记——Lambda表达式和Stream流
weixin_44853206的博客
11-24 787
/ 测试类 public class Demo03LambdaBase {// 匿名内部类的方式 fun(new MyFunctionalInter() {System . out . println("匿名内部类的方式！");} });// Lambda表达式的标准格式的方式 fun(() -> {System . out . println("Lambda表达式的标准格式的方式");});
【Java8】Lambda表达式 和 Stream API 详解笔记
passerbyYSQ
11-26 1164
视频地址：https://www.bilibili.com/video/BV1ut411g7E9 笔记 md 文档：xxx（稍后补上） Lambda表达式 概念 ​ Lambda是一个匿名函数，Lambda表达式可以理解为一段可以传递的代码（将代码像数据一样进行传递） 引入 /** * 匿名内部类 */ @Test public void test1() { Comparator<Integer> com = new Comparator<Integer>().
JAVA8 新特性 Stream API 、Lambda 表达式 引用
weixin_43849470的博客
09-22 303
前言 工作时会经常使用List对象集合转换Map集合、以及各种集合的转换、查询、筛选，从而方便后续操作。该文章大致概括讲述 Stream API和Lambda表达式的应用。
【Java8】Lambda表达式 和 Stream API 详解笔记.zip
11-26
视频地址：https://www.bilibili.com/video/BV1ut411g7E9 【Java8】Lambda表达式 和 Stream API 详解笔记 md文档
Java Lambda FunctionalInterface
热门推荐
01-28 3万+
Java Lambda FunctionalInterface package org.xcysj.b; import java.io.BufferedReader; import java.io.IOException; @FunctionalInterface public interface BufferedReaderProcessor { public String process(BufferedReader br) throws IOException; } ...
【Java基础笔记】Lambda表达式和函数式接口.docx
10-25
Java中的Lambda表达式和函数式接口是Java 8引入的重要特性，它们极大地简化了代码，尤其是在处理函数式编程场景时。下面将详细解释这两个概念及其应用。 **一、Lambda表达式** Lambda表达式是一种简洁的表示匿名...
Java 8 Lambda表达式与函数式接口学习笔记
"这份996视频学习笔记主要关注Java 8的新特性，包括lambda表达式、Stream API、Try-with-resource、Guava库的使用、线程池的管理和Lombok工具的介绍，以及验证框架的基本概念。" 在Java 8中，引入了lambda表达式，...
JAVA8的新特性学习笔记
03-01
该笔记主要记录了学习Java8新增特性的全部信息，包含概念讲解及代码示例，主要针对Lambda表达式、函数式接口、方法引用及构造器引用、Stream API、Optional类几个模块深入浅出的介绍了各个模块的使用。希望对大家的...
Lambda表达式的理解和使用
专业写BUG的博客
10-21 244
Lambda表达式的理解和使用 Lambda示例 /* 游泳接口 */ interface Swimming { void swim(); } public class TestSwimming { public static void main(String[] args) { // 通过匿名内部类实现 goSwimming(new Swimming() { @Override public voi
java最佳实践-lambda 函数式接口
program哲学
05-08 246
概念 函数式接口，当然首先是一个接口，然后就是在这个接口里面只能有一个抽象方法。 这种类型的接口也称为SAM接口，即Single Abstract Method interfaces。 它们主要用在Lambda表达式和方法引用（实际上也可认为是Lambda表达式）上。 @FunctionalInterface 用于指示接口类型声明的翔实注释类型旨在成为 Java 语言规范定义的函数接口。从概念上讲，一个功能接口正好有一个抽象的方法。由于默认方法具有实现，它们不是抽象的。如果接口声明一个抽象的方法压倒了其中一
Java8 Interface Lambda
carl.zhao的专栏
12-22 3142
Java是一门面向对象编程语言。面向对象编程语言和函数式编程语言中的基本元素（Basic Values）都可以动态封装程序行为：面向对象编程语言使用带有方法的对象封装行为，函数式编程语言使用函数封装行为。但这个相同点并不明显，因为Java的对象往往比较“重量级”：实例化一个类型往往会涉及不同的类，并需要初始化类里的字段和方法。
lambda java 接口_Java8一Lambda与函数式接口
weixin_42304618的博客
02-21 327
关于Lambda表示在工作学习中会经常用到，但并没有全面的去了解。在这里做一个较为详细的记录供以后学习查阅。主要参考Java 8 Lambda 表达式引言Java8之前，我们在使用Runnale创建线程的时候，经常需要将Runable实例传入new Thread中。一般采用匿名内部类将函数作为参数的形式传入new Thread(new Runnable() {@Overridepublic voi...
Java基础30（Java 8 特性 Java8中Interface接口 Lambda 表达式 Stream流）
最新发布
qq_52897007的博客
06-07 881
interface接口 的设计目的是面向接口编程，提高扩展性。●Java8中，接口中除了抽象方法外，还可以定义default默认方法和static静态方法。○default修饰的默认方法，属于实例方法，可以被实现类调用或重写。○static修饰的静态方法，属于类的静态方法。但它不能被子类继承，只能用interface接口名称调用。
Java 接口和函数式接口(lambda表达式)
涨姿势
07-31 323
接口 接口其实就是一个特殊的抽象类 如果一个抽象类的方法全是抽象的，并且属性是被public static final修饰的，直接使用接口修饰该类 接口的定义 interface 制定标准 可扩展性 解耦合 接口与接口之间采用 多继承 接口与类之间采用 多实现implements 特点： 接口是特殊的抽象类 接口中定义的成员方法都是抽象方法 接口中的属性都是被public static final 修饰的(接口中省略修饰符) 接口中没有构造方法 接口中允许定义 default 成员方法 接口中允许
【JAVA】Lambda接口&函数级接口
LED_of_Java的博客
06-13 322
Lambda接口只用于函数级接口中，它常常被用在匿名类中，而 函数级接口————接口里面只有一个函数的接口。 标识接口————接口里面什么函数都没有的接口。 以上只是对相关概念的简述，具体解释要依靠具体代码来讲解： //函数级接口 interface T1 { void t(); } //有返回类型的函数级接口 interface T2 { //这里面有一个参数a int...
javaSE . 匿名内部类，Lambda表达式，interface
LiangEdward的博客
07-17 172
一.匿名内部类，interface package com.shsxt.exercise; public class AnonymousInner { public static void main(String[] args) { HaHa ha = new HaHa(); ha.run(); //匿名内部类 简化接口的实现类，可以使用匿名内部类（不经常使...
java函数式、lambda表达式、Stream流的原理，关系和应用
0bug0warning的博客
11-12 1090
一 背景 jdk7到jdk8引入了很多新的特性，函数式接口，新的Date API，stream流，lambda表达式，接口默认方法等。在这里主要对函数式接口、lambda表达式、stream流做简单的记录学习。欢迎大家一起学习交流。 二 函数式接口的概念 函数式接口一句话总结：只有一个抽象方法的接口称为函数式接口。可以用【@FunctionalInterface】注解检验是否是函数式接口，在jvm进行编译的的时候会检查接口是否符合函数式接口规范。 函数式接口的几点特征： 函数式接口只有一个抽象..
【Java-API】lambda表达式4种方法引用
m0_64210833的博客
03-25 4224
首先lambda表达式4种方法引用可以归纳为下列4种： 1，静态方法引用 2，实例方法引用 3，构造方法引用 4，特殊方法引用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值