Java Lambda&Stream

已于 2023-05-15 14:17:29 修改
阅读量165 收藏 1
点赞数
分类专栏： Java Lambda&Stream 文章标签： java
于 2022-08-30 21:15:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuyankang123/article/details/126612723
版权

Java Lambda&Stream

文章目录

一、Lambda

1）背景

java 是面向对象的语言，想方法传递参数不能是单个函数。

eg: sort() 需要一个比较的函数，只能创建一个函数，将方法包装在对象中传递，可以通过创建匿名内部类对象，将比较函数包装起来。

java 8 之后为了再次简化语法，推出了Lambda 语法

2）Lambda表达式

Lambda 表达式就是一个匿名函数，简化匿名内部类语法。

以后可以将匿名内部类当作参数传递，由java 根据语言进行 推断，不全常规代码。

package com.xytx.javalambdastream.lambda;

public class Car {
    private String name;
    private int num;

    public Car(String name, int num) {
        this.name = name;
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

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


package com.xytx.javalambdastream.lambda;

import java.util.Arrays;

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

        Car car1 = new Car("奔驰",1);
        Car car2 = new Car("奔驰",2);
        Car car3 = new Car("奔驰",3);
        Car car4 = new Car("奔驰",4);
        Car car5 = new Car("奔驰",5);

        Car [] cars = {car2,car4,car5,car3,car1};

        Arrays.sort(cars,(c1,c2)->{ // 根据cars 类型推断c1,c2类型，从而补全常规代码
            return c1.getNum()-c2.getNum();
        });
        System.out.println(Arrays.toString(cars));


    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o4Ps9d2H-1661865248773)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\1658192173580.png)]

Lambda 表达式本质 —>“语法糖”

**“语法糖”😗*也译为糖衣语法，是由英国计算机科学家彼得·约翰·兰达（Peter J. Landin）发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。通常来说使用语法糖能够增加程序的可读性，从而减少程序代码出错的机会。

3）Lambda 结构

（1）无参无返回值

package com.xytx.javalambdastream.lambda;
@FunctionalInterface
public interface Oper {
    //使用Lambda 表达式前提，接口中只能有一个抽象方法，因为需要自动类型推断
    //@FunctionalInterface 表示是一个功能函数接口，接口中只能定义一个抽象方法
    public void show();
}


package com.xytx.javalambdastream.lambda;

import java.util.Arrays;

public class OperTest {
    public static void main(String[] args) {
        OperTest test = new OperTest();
        test.run(()->{
            System.out.println("无参无返回值");
        });



    }
public void run(Oper test){ //调用接口中的抽象方法
        test.show();
}

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O8UK9wAJ-1661865248775)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\1658193309091.png)]

（2）有参有返回值

package com.xytx.javalambdastream.lambda;
@FunctionalInterface
public interface Oper {
    //使用Lambda 表达式前提，接口中只能有一个抽象方法，因为需要自动类型推断
    //@FunctionalInterface 表示是一个功能函数接口，接口中只能定义一个抽象方法
    int show(Integer a,Integer b);

}


package com.xytx.javalambdastream.lambda;

public class OperTest {
    public static void main(String[] args) {
        OperTest test = new OperTest();
        test.run((a,b)->{
            int c = a + b;
            System.out.println(c);
            return c;
        });



    }
public void run(Oper test){ //调用接口中的抽象方法
        test.show(5,6);

}

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CVAXV4DB-1661865248776)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\1658194379909.png)]

二、Stream

1) Stream

Stream 流是java8推出的新功能，与IO流完全不同的。

提供了对象数据集合进行操作的各种方法，我们只需要声明式的告诉其应该做什么。

jave中的集合，数组主要是存储数据，而Stream主要左右是对集合进行操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T7KJ8zFb-1661865248776)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\1658195150407.png)]

Stream 就是一个对集合进行遍历的高级迭代器

2）案例

package com.xytx.javalambdastream.stream;

import java.util.Arrays;

public class Demo1 {
    public static void main(String[] args) {
        Integer [] arrays = {5,6,8,9,7,5,2,3,1,4,4,5};
        Arrays.stream(arrays)  //返回一个Stream 对象
              .distinct()  //去重
              .filter((e)->{return e<7;})  //对流进行一个过滤操作，又返回一个流对象
              .sorted((a,b)->{return a-b;})  //对流进行一个排序操作，又返回一个流对象
              .limit(8) //限制取出元素的个数
              .skip(4)  //跳过指定数量的元素
              .forEach((e)->{//遍历 e 
                  System.out.println(e);
              });
    }
}


package com.xytx.javalambdastream.stream;

import java.awt.*;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Demo1 {
    public static void main(String[] args) {
        Integer [] arrays = {5,6,8,9,7,5,2,3,1,4,4,5};
        //终端操作
        Integer max = Arrays.stream(arrays)
                .max((a,b)->{return a-b;}) //获取最大值
                .get();
        System.out.println(max);

        Integer sum = Arrays.stream(arrays)
                .reduce((a,b)->{return a+b;}) // 将所以元素相加
                .get();
        System.out.println(sum);

        Object [] objects = Arrays.stream(arrays)
                .distinct()
                .toArray();//去重之后的数组
        System.out.println(Arrays.toString(objects));

        boolean b = Arrays.stream(arrays)
                .distinct()
                .anyMatch((e)->{
                    return e>8; //如果有元素满足大于8，返回true，反之false
                });
        System.out.println(b);

        boolean b1 = Arrays.stream(arrays)
                .distinct()
                .allMatch((e)->{
                    return e<8; //所有元素都满足小于8，返回true，反之false
                });
        System.out.println(b1);

        List<Integer> list = Arrays.stream(arrays)
                .distinct()
                .collect(Collectors.toList()); //去重过后的转为集合
        System.out.println(list);





        /*Arrays.stream(arrays)  //返回一个Stream 对象
              .distinct()  //去重
              .filter((e)->{return e<7;})  //对流进行一个过滤操作，又返回一个流对象
              .sorted((a,b)->{return a-b;})  //对流进行一个排序操作，又返回一个流对象
              .limit(8) //限制取出元素的个数
              .skip(4)  //跳过指定数量的元素
              .forEach((e)->{//遍历 e
                  System.out.println(e);
              });*/
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PIpBOK2a-1661865248776)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\1658197849191.png)]

package com.xytx.javalambdastream.stream;

import com.xytx.javalambdastream.lambda.Car;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Demo2 {
    public static void main(String[] args) {
        Car car1 = new Car("奔驰", 101,"白色");
        Car car2 = new Car("奔驰", 102,"粉色");
        Car car3 = new Car("奔驰", 103,"红色");
        Car car4 = new Car("奔驰", 104,"黑色");
        Car car5 = new Car("奔驰", 105,"蓝色");

        Car [] cars = {car2,car4,car5,car1,car3};
        List<Car> listcar = Arrays.stream(cars)
                .sorted((c1,c2)->{return c1.getNum()-c2.getNum();}) //num 排序
                .filter((c)->{return c.getColor().equals("黑色");}) //获取想要的颜色的车
                .collect(Collectors.toList());
        System.out.println(listcar);

        Map<Integer,String> carmap = Arrays.stream(cars)
                .collect(Collectors.toMap(Car::getNum,Car::getColor));//num--键 color--值
        System.out.println(carmap);

        //map(); 将其映射成一个新元素
        List<String> listcolor = Arrays.stream(cars)
                .map(Car::getColor) //将color映射出来，变成一个新元素
                .collect(Collectors.toList());
        System.out.println(listcolor);
    }


}


package com.xytx.javalambdastream.lambda;

public class Car {
    private String name;
    private int num;
    private String color;

    public Car(String name, int num, String color) {
        this.name = name;
        this.num = num;
        this.color = color;
    }

    public Car(String name, int num) {
        this.name = name;
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HbBRZ7RK-1661865248777)(C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\1658197943891.png)]

public String getColor() {
return color;
}

public void setColor(String color) {
    this.color = color;
}

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

}




[外链图片转存中...(img-HbBRZ7RK-1661865248777)]
小于同学*
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java-lambda-stream
03-13
java-lambda-stream
java stream lambda_JAVA基础知识|lambda与stream
weixin_39736650的博客
02-16 433
lambda与stream是java8中比较重要两个新特性，lambda表达式采用一种简洁的语法定义代码块，允许我们将行为传递到函数中。之前我们想将行为传递到函数中，仅有的选择是使用匿名内部类，现在我们可以使用lambda表达式替代匿名内部类。在学习lambda表达式之前，建议各位看官先去学习一下匿名内部类(JAVA基础知识|内部类)。stream提供了很多有用的api，方便了我们对集合的操作一、...
Java中Stream配合Lambda使用详解
qq_25775675的博客
07-07 2252
Java 8 是一个非常成功的版本，这个版本新增的Stream，配合同版本出现的Lambda ，给我们操作集合（Collection）提供了极大的便利。Stream流是JDK8新增的成员，允许以声明性方式处理数据集合，可以把Stream流看作是遍历数据集合的一个高级迭代器。Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找/筛选/过滤、排序、聚合和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询
Java中的Lambda表达式以及Stream流
qq_59335499的博客
06-17 779
Lambda 表达式是 Java8 新增的重要特性，Lambda 使 Java 具有了类似函数式编程的风格，其实质也是由编译器根据表达式推断最终生成原始语法的字节码方式。Lambda表达式的使用与有关，函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”而我们要学习的Lambda表达式就是函数式思想的体现。Lambda表达式是Java 8引入的一种新特性，它是一种简洁、灵活的函数式编程方式，可以用来替代匿名内部类。Lambda表达式的使用规则如下：或。其中，
Java-Lambda和Stream的使用大全(案例特全)
weixin_45203607的博客
10-07 1747
Java-Lambda的使用大全 介绍 Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。 JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。 说白了其实还是 匿名内部类 就是少写点代码而已 匿名类部类的作用就是 将接口重写 和对方法 的 参数 进行赋值 比如: interface lambda_inter { voi
Java 基础 —— Java 8 新特性 stream 与 Lambda
IT__learning的博客
09-04 1876
一、Stream 简介 Java 8 引入了全新的 Stream API，这里的 Stream 和 I/O 流不同，它更像具有 Iterable 的集合类，但行为和集合类又有所不同。Stream 是 Java 8 的新特性，是对容器对象功能的增强，它专注于对容器对象进行各种非常便利、高效的聚合操作（aggregate operation）或者大批量数据操作。Stream 是用函数式编程方式在集合类上进行复杂操作的工具，开发者可以更容易地使用 Lambda 表达式，并且更方便地实现对集合的查找、遍历、过滤以及
java_lambda_stream
03-16
java_lambda_stream
Stream和Lambda表达式最佳实践
最新发布
04-24
Stream和Lambda表达式是Java 8引入的两个重要特性，它们极大地简化了集合处理和函数式编程的复杂性。以下是关于Stream和Lambda表达式的最佳实践介绍： Lambda表达式 Lambda表达式允许我们以简洁的方式表示匿名函数...
Java 8 新特性之Stream 和 Lambda
01-24
Java 8 新特性之Stream 和 Lambda
Stream、Lambda表达式练习.doc
01-14
Stream、Lambda表达式练习.doc
Java8函数式编程(Lambda表达式，Stream流，Optional)
qq_62767608的博客
04-23 1945
lambda表达式是Java8的一个新特性，从本质上来讲是一个匿名函数可以使用这个匿名函数实现接口中的方法，并且非常简洁。通常来讲，使用 lambda表达式 是为了。关于接口实现，可以有很多种方式来实现。例如L设计接口的实现类、使用匿名内部类。但是lambda表达式比这两种方式都简单。
java——lambda&Stream流
qq_51733711的博客
08-30 764
lambda&Stream流
Java8新特性详解
qq_36144703的博客
10-15 751
一、Lambda表达式 Lambda表达式引入了一个新的操作符" -> "。Lambda表达式将函数当成参数传递给某个方法，或是把代码本身当作数据处理。 Lambda表达式分为两部分： () -> { //执行的功能 } 左侧：Lambda表达式的参数列表 右侧：Lambda表达式中所需要执行的功能 1、Lambda表达式格式 下面讲解Lambda的写法： Lambda表达式参数列表的数据类型可以省略不写，JVM编译器能通过上下文推断出来 void test(){ ..
java中的Lambda和Stream
钱辉
12-26 240
java中的Lambda和Stream
JAVA Lambda和Stream
qq_53881918的博客
07-18 437
Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中）。使用Lambda表达式可以使代码变的更加简洁紧凑。不需要声明参数类型，编译器可以统一识别参数值。一个参数无需定义圆括号，但多个参数需要定义圆括号。如果主体包含了一个语句，就不需要使用大括号。如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。...
Java 之 Lambda 表达式和 Stream 流
weixin_48498902的博客
03-03 413
JDK 1.8 之后的新特性平常的方法参数都是引用型数据类型或者基本数据类型Lambda 允许把函数接口作为一个方法的参数 (函数作为参数传递进方法中)Lambda 可以使代码更加简洁，优化代码JDK 1.8 版本新特性这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。
Java——Lambda&Stream表达式
xinin919的博客
08-31 553
1、Lambda表达式是一个匿名函数，可以理解为一段可以传递的代码，使用它写出更灵活、简洁的代码。2、Lambda表达式的结构：①、Lambda 表达式可以具有零个、一个或多个参数。②、可以显式声明参数的类型，也可以由编译器自动从上下文推断参数的类型。如：(int a,int b)与 (a,b)相同。③、参数用小括号括起来，用逗号分隔。如： (a, b) 或 (int a, int b) 或 (String a, int b, float c)。④、空括号用于表示一组空的参数。...
Java8新特性【函数式接口、Lambda表达、Stream流】
白豆五的博客
04-18 1137
Java8新特性之函数式接口、Lambda表达、Stream流。
(Java8)Lambda和steam流使用详解，有示例
onebeautifulman的博客
01-29 1043
Stream流在处理大批量数据集合时效率更高，因为Steam流内部使用了并行流的概念。 Lambda表达式简写规则
java lambda Stream
06-09
Java Lambda表达式和Stream API是Java 8中最为重要的新特性之一。Lambda表达式可以使代码更加简洁、可读性更高，而Stream API则提供了一种函数式编程的方式来对集合进行操作。 Lambda表达式可以被认为是一种匿名...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值