java lambda表达式 steam api

最新推荐文章于 2023-07-01 17:41:18 发布
最新推荐文章于 2023-07-01 17:41:18 发布
阅读量4.2w 收藏
点赞数
文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24330181/article/details/130637936
版权

java lambda表达式 steam api

案例使用 java版本为 jdk-17

foreach

遍历

public class JavaDemo03 {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
        nums.forEach(System.out::println);
    }
}

运行结果：

1
2
3
4
5
6
7
8
9

map

逐个操作列表中每一个元素

public class JavaDemo04 {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
        List<Integer> numbers = nums.stream().map(num -> num * 2).toList();
        numbers.forEach(System.out::println);
    }
}

运行结果：

2
4
6
8
10
12
14
16
18

flatMap

先对集合中每个元素进行map，再对map后的每个元素进行flatten

map后的每个元素也是一个集合

public class JavaDemo06 {
    public static void main(String[] args) {
        List<Integer> listA = new ArrayList<>();
        listA.add(1);
        listA.add(2);

        List<Integer> listB = new ArrayList<>();
        listA.add(5);
        listA.add(6);

        List<List<Integer>> listC = new ArrayList<>();
        listC.add(listA);
        listC.add(listB);

        List<Integer> numbers = listC.stream().flatMap(Collection::stream).toList();
        numbers.forEach(System.out::println);
    }
}

运行结果：

1
2
5
6

filter

过滤出符合规则的数据生成新的列表

public class JavaDemo07 {
    public static void main(String[] args) {
        List<Person> persons = new ArrayList<>();
        Person person;
        for (int i = 0; i < 10; i++) {
            person = new Person("user" + (i + 1), (i + 1) % 2);
            persons.add(person);
        }
        // 获取男性列表
        List<Person> manList = persons.stream().filter(user -> user.getGender() == 1).toList();

        // 获取女性列表
        List<Person> womanList = persons.stream().filter(user -> user.getGender() == 0).toList();

        manList.forEach(System.out::println);
        System.out.println("+++++++++++++++++++++++");
        womanList.forEach(System.out::println);
    }
}

class Person {
    private String name;
    private int gender;

    public Person() {
    }

    public Person(String name, int gender) {
        this.name = name;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

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

    public int getGender() {
        return gender;
    }

    public void setGender(int gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", gender=" + gender +
                '}';
    }
}
 class JavaDemo03 {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
        nums.forEach(System.out::println);
    }
}

运行结果：

Person{name='user1', gender=1}
Person{name='user3', gender=1}
Person{name='user5', gender=1}
Person{name='user7', gender=1}
Person{name='user9', gender=1}
+++++++++++++++++++++++
Person{name='user2', gender=0}
Person{name='user4', gender=0}
Person{name='user6', gender=0}
Person{name='user8', gender=0}
Person{name='user10', gender=0}

reduce

相邻两个元素转为一个元素

列表中的所有元素转为一个元素

1, 2, 3, 4, 5, 6, 7, 8, 9
-1, 3, 4, 5, 6, 7, 8, 9
-4, 4, 5, 6, 7, 8, 9
-8, 5, 6, 7, 8, 9
-13, 6, 7, 8, 9
-19, 7, 8, 9
-26, 8, 9
-34, 9
-43


public class JavaDemo08 {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
        List<Integer> numbers = nums.stream().reduce((a, b) -> a - b).stream().toList();
        numbers.forEach(System.out::println);
    }
}

运行结果：

-43

count

计数器

public class JavaDemo12 {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9);
        long count = nums.stream().filter(num -> num % 2 == 0).count();
        System.out.println("列表中偶数是数量 >>> " + count);
    }
}

运行结果：

4

distinct

去重

public class JavaDemo13 {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 5, 6, 7, 8, 9, 3, 4, 5, 7, 8, 2, 3);
        List<Integer> numbers = nums.stream().distinct().toList();
        numbers.forEach(System.out::println);
    }
}

运行结果：

1
2
3
5
6
7
8
9
4

sorted

排序类需要实现 Comparable 接口

public class JavaDemo14 {
    public static void main(String[] args) {
        List<Dog> dogs = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            dogs.add(new Dog("dog" + (i + 1), ThreadLocalRandom.current().nextInt(1, 10)));
        }
        dogs.forEach(System.out::println);
        List<Dog> newDogs = dogs.stream().sorted((a, b) -> a.getAge() - b.getAge()).toList();
        System.out.println("++++++++++++++");
        newDogs.forEach(System.out::println);
    }
}

class Dog {
    private String name;
    private int age;

    public Dog() {
    }

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

运行结果：

Dog{name='dog1', age=3}
Dog{name='dog2', age=3}
Dog{name='dog3', age=3}
Dog{name='dog4', age=3}
Dog{name='dog5', age=7}
Dog{name='dog6', age=6}
Dog{name='dog7', age=4}
Dog{name='dog8', age=8}
Dog{name='dog9', age=7}
Dog{name='dog10', age=2}
++++++++++++++
Dog{name='dog10', age=2}
Dog{name='dog1', age=3}
Dog{name='dog2', age=3}
Dog{name='dog3', age=3}
Dog{name='dog4', age=3}
Dog{name='dog7', age=4}
Dog{name='dog6', age=6}
Dog{name='dog5', age=7}
Dog{name='dog9', age=7}
Dog{name='dog8', age=8}

limit

TopN

public class JavaDemo17 {
    public static void main(String[] args) {
        int base = 1000;
        ArrayList<Video> videos = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            videos.add(new Video(base + i + 1, ThreadLocalRandom.current().nextInt(100, 1000)));
        }
        videos.forEach(System.out::println);
        System.out.println("+++++++++++++");
        videos.sort((a, b) -> b.getGold() - a.getGold());
        List<Video> topList = videos.stream().limit(3).toList();
        topList.forEach(System.out::println);
    }
}

class Video {
    private int vid;
    private int gold;

    public Video() {
    }

    public Video(int vid, int gold) {
        this.vid = vid;
        this.gold = gold;
    }


    public int getVid() {
        return vid;
    }

    public void setVid(int vid) {
        this.vid = vid;
    }

    public int getGold() {
        return gold;
    }

    public void setGold(int gold) {
        this.gold = gold;
    }

    @Override
    public String toString() {
        return "Video{" +
                "vid='" + vid + '\'' +
                ", gold=" + gold +
                '}';
    }
}

运行结果：

Video{vid='1001', gold=566}
Video{vid='1002', gold=548}
Video{vid='1003', gold=620}
Video{vid='1004', gold=897}
Video{vid='1005', gold=264}
Video{vid='1006', gold=311}
Video{vid='1007', gold=882}
Video{vid='1008', gold=870}
Video{vid='1009', gold=106}
Video{vid='1010', gold=185}
+++++++++++++
Video{vid='1004', gold=897}
Video{vid='1007', gold=882}
Video{vid='1008', gold=870}

groupBy

分组

public class JavaDemo18 {
    public static void main(String[] args) {
        List<Animal> animals = new ArrayList<>();
        Animal animal;
        for (int i = 0; i < 10; i++) {
            animal = new Animal("animal" + (i + 1), (i + 1) % 2);
            animals.add(animal);
        }
        // 按照性别分组
        Map<Integer, List<Animal>> animalGenderGroup = animals.stream().collect(Collectors.groupingBy(Animal::getGender));
        animalGenderGroup.forEach((key, value) -> System.out.println((key == 1 ? "雄性" : "雌性") + " >>> " + value));
    }
}

class Animal {
    private String name;
    private int gender;

    public Animal() {
    }

    public Animal(String name, int gender) {
        this.name = name;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

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

    public int getGender() {
        return gender;
    }

    public void setGender(int gender) {
        this.gender = gender;
    }

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

运行结果：

雌性 >>> [Animal{name='animal2', gender=0}, Animal{name='animal4', gender=0}, Animal{name='animal6', gender=0}, Animal{name='animal8', gender=0}, Animal{name='animal10', gender=0}]
雄性 >>> [Animal{name='animal1', gender=1}, Animal{name='animal3', gender=1}, Animal{name='animal5', gender=1}, Animal{name='animal7', gender=1}, Animal{name='animal9', gender=1}]
李昊哲小课
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java基础24 Lambda表达式及省略写法 Steam流 函数式接口
Xs943的博客
02-24 672
一、jdk8&jdk9接口的特性 1.概念：在jdk1.8 之后 接口中不仅可以有抽象方法 还可以存在其他的成员方法 2.添加的方法 jdk8 增加默认方法与静态方法 jdk9 增加私有的方法 3.影响 接口中不仅只有抽象方法 还有普通的方法 缩短接口与抽象类之间的差别,接口是可以多继承的 所以以后的趋势 接口可能替代抽象类 4.默认方法 概述 默认方法就是使用 default关键字来进行修饰方法 语法： 访问修饰符 default 返回值类型 方法名称(参数列表) { 方法体 } 特点： 接口中默
Java——Lambda&Stream表达式
xinin919的博客
08-31 584
1、Lambda表达式是一个匿名函数，可以理解为一段可以传递的代码，使用它写出更灵活、简洁的代码。2、Lambda表达式的结构：①、Lambda 表达式可以具有零个、一个或多个参数。②、可以显式声明参数的类型，也可以由编译器自动从上下文推断参数的类型。如：(int a,int b)与 (a,b)相同。③、参数用小括号括起来，用逗号分隔。如： (a, b) 或 (int a, int b) 或 (String a, int b, float c)。④、空括号用于表示一组空的参数。...
Steam流学习之Lambda表达式
m0_74307401的博客
06-12 79
lambda表达式是对匿名内部类的优化，只关注参数和方法体。可以用Lambda的格式对其进行修改。（参数列表）->{代码}
JDK 1.8新特性，Lamda表达式，steam流的一些用法例子
xchnba2107的博客
05-19 563
1.返回集合的某个字段集 List<MaThtZjConfigEntity> data = new ArrayList<>() List<String> position = null; if (!CollectionUtils.isEmpty(data)) { position = data.stream().map(MaThtZjConfigEntity::getZjType).distinct().collect(Collectors.toList())
jdk8 的 stream表达式
Keson_wecanmakeit的博客
12-30 267
list.steam().map( xx -> { return xxx}).collect(Collections.toList) ； 处理后返回一个集合 Arrays.asList 快速生成一个ArrayList集合 StringUtils.join(list， Seperator)，可将字符串集合用分隔符拼接成一个字符串 StringUtils.split(string, Se...
详细分析Java Lambda表达式
08-18
"详细分析Java Lambda表达式" Java Lambda表达式是Java 8中引入的一种新的编程方式，它允许开发者将函数作为参数传递给其他函数，或者将函数作为返回值返回。Lambda表达式的引入使得Java语言更加函数化，更加简洁。...
Java Lambda表达式详解和实例
09-04
Java 8引入了Stream API，与Lambda表达式结合，提供了强大的数据处理能力。Stream API提供了诸如`filter`、`map`、`reduce`等方法，可以对集合进行过滤、映射和聚合操作。例如，要找出大于某个值的所有元素，可以...
java lambda表达式用法总结
08-25
Java Lambda 表达式用法总结 Java Lambda 表达式是 Java 8 中引入的一种新的编程方式，它允许开发者使用简洁的语法来表示单方法接口的实现。下面是 Java Lambda 表达式的详细用法总结： 一、什么是函数式编程？ ...
Java Lambda表达式和函数式接口实例分析
08-25
Java Lambda表达式和函数式接口实例分析 Java Lambda表达式和函数式接口是Java 8中引入的一种新特性，它允许开发者使用函数式编程风格来编写代码，从而提高代码的简洁性和可读性。本文将对Java Lambda表达式和函数...
Java 8 lambda表达式
06-27
- **函数式编程**：Java 8引入了`java.util.Function`等接口，以及`Stream API`，允许开发者使用lambda表达式进行函数式编程，如映射、过滤、聚合等操作。 4. **并行处理**：通过`java.util.concurrent.ForkJoin...
MyBatis 从入门到精通
02-07
《MyBatis 从入门到精通》本书中从一个简单的 MyBatis 查询入手，搭建起学习 MyBatis 的基础开发环境。通过全面的示例代码和测试讲解了在 MyBatis XML 方式和注解方式中进行增、删、改、查操作的基本用法，介绍了动态 SQL 在不同方面的应用以及在使用过程中的最佳实践方案。针对 MyBatis 高级映射、存储过程和类型处理器提供了丰富的示例，通过自下而上的方法使读者更好地理解和掌握MyBatis 的高级用法，同时针对 MyBatis 的代码生成器提供了详细的配置介绍。此外，本书还提供了缓存配置、插件开发、Spring、Spring Boot 集成的详细内容。最后通过介绍 Git 和 GitHub 让读者了解MyBatis 开源项目，通过对 MyBatis 源码和测试用例的讲解让读者更好掌握 MyBatis。
MyBatis 案例练习 SQL
07-15
MyBatis 案例练习 SQL
大数据Spark入门到精通v3.0版
04-10
001 - Spark框架 - 简介.avi 002 - Spark框架 - Vs Hadoop.avi 003 - Spark框架 - 核心模块 - 介绍.avi 005 - Spark框架 - 快速上手 - WordCount - 案例分析.avi 009 - Spark框架 - 快速上手 - WordCount - Spark的实现.avi 010 - Spark框架 - 快速上手 - WordCount - 日志和错误.avi 011 - Spark框架 - 运行环境 - 本地环境 - 基本配置和操作.avi 012 - Spark框架 - 运行环境 - 本地环境 - 提交应用程序.avi 013 - Spark框架 - 运行环境 - 独立部署环境 - 基本配置和操作.avi 015 - Spark框架 - 运行环境 - 独立部署环境 - 配置历史服务.avi 019 - Spark框架 - 核心组件 - 介绍.avi 020 - Spark框架 - 核心概念 - Executor & Core & 并行度.avi 023 - SparkCore - 分布式
Lambda表达式和SteamAPI
rishengcsdn的专栏
09-11 1359
Lambda表达式和SteamAPI是JDK8的新特性，所有在实验下面代码时候，请升级JDK到8版本，否则会编译 报错。 首先看Lambda表达式，同正则表达式类似，Lambda表达式不能在JAVA代码中直接使用，先得做一下封装。 import java.util.ArrayList; public class LabExamp {     /**      *  Lambd
java8中 lambda表达式，stream操作
qq_45515347的博客
08-28 399
lambda 和 stream
Stream流&&Lambda表达式
Niko_Guo486的博客
03-25 457
stream流和Lambda表达式都是JAVA8的提出的新概念，em不是IO流的Stream，是一种使用函数式编程方式在集合类上进行操作的工具，使用Stream API对集合进行操作，以内部迭代的方式，非常的方便~又高效。
Linux
weixin_53233582的博客
04-04 1521
Linux 简介 Linux 是一种自由和开放源码的类 UNIX 操作系统。 Linux 英文解释为 Linux is not Unix。 Linux 是在 1991 由林纳斯·托瓦兹在赫尔辛基大学上学时创立的，主要受到 Minix 和 Unix 思想的启发。 Linux 内核最初只是由芬兰人林纳斯·托瓦兹（Linus Torvalds）在赫尔辛基大学上学时出于个人爱好而编写的。 Linux 是一套免费使用和自由传播的类 Unix 操作系统，是一个基于 POSIX 和 UNIX 的多用户、多任务、支持多线
Sqoop 从入门到精通
热门推荐
桃李不言下自成蹊
04-27 6万+
Sqoop是Hadoop和关系数据库服务器之间传送数据的一种工具。它是用来从关系数据库如：MySQL，Oracle到Hadoop的HDFS，并从Hadoop的文件系统导出数据到关系数据库。传统的应用管理系统，也就是与关系型数据库的使用RDBMS应用程序的交互，是产生大数据的来源之一。这样大的数据，由关系数据库生成的，存储在关系数据库结构关系数据库服务器。
Linux 正则表达式
最新发布
桃李不言下自成蹊
07-01 7万+
不加引号：不会将含有空格的字符串视为一个整体输出, 如果内容中有命令、变量等，会先把变量、命令解析出结果，然后在输出最终内容来，如果字符串中带有空格等特殊字符，则不能完整的输出，需要改加双引号，一般连续的字符串，数字，路径等可以用。如果内容中有命令、变量等，会先把变量、命令解析出结果，然后在输出最终内容来。这时候 grep ‘"$HOME’‘的话，因为内容有单引号，第一个单引号会和倒数第二个单引号匹配，导致找不到正确内容，这里只能用双引号（如有单引号方法可以留言讨论），即grep “”$HOME’"。
java lambda表达式
04-29
使用Lambda表达式还可以利用Java 8提供的Stream API来对集合和流进行处理，提高代码的效率和可读性。 Lambda表达式的引入也是Java语言面向函数编程的一次尝试，它使得Java也可以处理函数式编程的一些问题。Java的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

李昊哲小课

桃李不言下自成蹊

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值