Java8新特性_Stream_映射

最新推荐文章于 2024-09-21 22:32:32 发布
原创 最新推荐文章于 2024-09-21 22:32:32 发布 · 281 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring boot #后端 #java

本文通过实例展示了Java Stream API的使用，包括过滤、映射、短路操作、去重等，并探讨了其在处理集合数据时的效率和便捷性。测试用例覆盖了年龄筛选、薪资比较、去重等多个场景。

 

package com.zs.boot.controller;

public class Employee {

	private int id;
	private String name;
	private int age;
	private double salary;
	private Status status;

	public Employee() {
	}

	public Employee(String name) {
		this.name = name;
	}

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

	public Employee(int id, String name, int age, double salary) {
		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	public Employee(int id, String name, int age, double salary, Status status) {
		this.id = id;
		this.name = name;
		this.age = age;
		this.salary = salary;
		this.status = status;
	}

	public Employee(String name, int age, double salary) {
		this.name = name;
		this.age = age;
		this.salary = salary;
	}

	public Status getStatus() {
		return status;
	}

	public void setStatus(Status status) {
		this.status = status;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	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;
	}

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

	public String show() {
		return "测试方法引用！";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + id;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		long temp;
		temp = Double.doubleToLongBits(salary);
		result = prime * result + (int) (temp ^ (temp >>> 32));
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Employee other = (Employee) obj;
		if (age != other.age)
			return false;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + ", status=" + status
				+ "]";
	}

	public enum Status {
		FREE, BUSY, VOCATION;
	}

}

package com.zs.boot.controller;

import org.junit.Test;

import java.util.*;
import java.util.stream.Stream;

public class TestStream2API {

    List<Employee> employees = Arrays.asList(
            new Employee("刘德华",48,8000),
            new Employee("张学友",28,8500),
            new Employee("黎明",45,6500),
            new Employee("黎明",45,6500),
            new Employee("郭富城",51,5500));

    //过滤出年龄大于35
    //内部迭代：迭代操作由StreamAPI完成
    @Test
    public void test1(){
        //中间操作，不会执行任何操作
        Stream<Employee> s = employees.stream().filter(e -> e.getAge()>35);

        /*
        s.forEach(System.out::println);这样写会打印对象所有信息，不会只打印姓名，而我只打印姓名
        可以参考这样写Stream<String> namesStream = employees.stream().map(Employee::getName);
        Stream<String> namesStream  =  s.map(employees -> employees.getName());//用Employee::getName更简洁
        namesStream.forEach(System.out::println);
        即：
        employees.stream().filter(e -> e.getAge()>35).map(Employee::getName).forEach(System.out::println);
        */
        //中间操作后必须加终止操作才执行
        s.forEach((str) -> System.out.println(str.getName()));
        /*
        刘德华
        黎明
        郭富城
        */

    }

    //外部迭代
    @Test
    public void test2(){
        Iterator<Employee> it = employees.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }

    @Test
    public void test3(){
        /*Employee [id=0, name=刘德华, age=48, salary=8000.0, status=null]
        Employee [id=0, name=张学友, age=28, salary=8500.0, status=null]
        Employee [id=0, name=黎明, age=45, salary=6500.0, status=null]*/
        employees.stream().filter(e -> e.getSalary()>6000).limit(3).forEach(System.out::println);

        System.out.println("------------------------------------------------------");

        /*短路！
        Employee [id=0, name=刘德华, age=48, salary=8000.0, status=null]
        短路！
        Employee [id=0, name=张学友, age=28, salary=8500.0, status=null]*/
        //找到满足条件的两条数据后，后续的迭代操作就不再进行了
        employees.stream().filter(e -> {
            System.out.println("短路！");
            return e.getSalary()>6000;
        }).limit(2).forEach(System.out::println);
    }

    /*Employee [id=0, name=黎明, age=45, salary=6500.0, status=null]*/
    //跳过前两个
    @Test
    public void test4(){
        employees.stream().filter(e -> e.getSalary()>6000).skip(2).forEach(System.out::println);
    }

    /*Employee [id=0, name=刘德华, age=48, salary=8000.0, status=null]
    Employee [id=0, name=张学友, age=28, salary=8500.0, status=null]
    Employee [id=0, name=黎明, age=45, salary=6500.0, status=null]*/
    //去重，注意要去实体类中重写hashcode和equals
    @Test
    public void test5(){
        employees.stream().filter(e -> e.getSalary()>6000).distinct().forEach(System.out::println);
    }


    /*
    AA
    BB
    CC
    DD
    */
    @Test
    public void test6(){
        List<String> list = Arrays.asList("aa","bb","cc","dd");
        list.stream().map(str -> str.toUpperCase(Locale.ROOT)).forEach(System.out::println);

        System.out.println("----------------------------");

        //取出员工姓名
        employees.stream().map(e -> e.getName()).forEach(System.out::println);
        //等效写法
        employees.stream().map(Employee::getName).forEach(System.out::println);

        System.out.println("----------------------------");


        /*a
        a
        b
        b
        c
        c
        d
        d*/
        //Stream<Stream<Character>> stream = list.stream().map(s ->filterCharacter(s));
        //等效写法
        Stream<Stream<Character>> stream = list.stream().map(TestStream2API::filterCharacter);
        stream.forEach(sm -> sm.forEach(
                System.out::println
        ));

        System.out.println("----------------------------");

        /*a
        a
        b
        b
        c
        c
        d
        d*/
        Stream<Character> stream1 = list.stream().flatMap(TestStream2API::filterCharacter);
        stream1.forEach(
                System.out::println
        );
    }

    public static Stream<Character> filterCharacter(String str){
        List<Character> list = new ArrayList<>();
        for (Character ch: str.toCharArray()) {
            list.add(ch);
        }
        return list.stream();
    }

}

类似的还有add()和addAll()

add()，传一个list进去也当成一个元素，addAll()则不会

 

5.java8流的使用 stream的筛选与切片
sunweihao2019的博客
11-05 308
1.关键代码 1.Employee2的bean类 /** * 创建日期：2021/10/29 14:01 * * @author tony.sun * 类说明： */ public class Employee2 { private String name; private Integer age; private Double salary; private Status Status; public Employee2(String name, In
Java8 Stream的筛选和切片
08-05 4081
写多了Spark/Scala，这个是比较简单的。 package com.expgiga.Java8; /** * */ public class Employee { private String name; private int age; private double salary; private int id; public Empl
JAVA InputStream. 对网络数据帧自动分片
ColdZoo Blog
06-21 2807
问题引入组里的工程项目需要涉及安卓平台的网络收发。 我之前为这个项目写了一个WIFI通信模块，根据通讯规约必须传输byte流。因此模块使用的是最底层的InputStream。这也为之后埋下了后患。通讯模块的写法如下：OutputStream out = null; //写 InputStream in = null; //读socket.connect(new InetSo
Java8新特性_Stream_筛选与切片
兴趣是最好的老师
11-28 509
package com.zs.boot.controller; public class Employee { private int id; private String name; private int age; private double salary; private Status status; public Employee() { } public Employee(String name) { this.name = name; } public ...
Java8新特性强大的Stream API中间操作之映射（三）
qq_39746820的博客
04-16 409
Stream是Java8的一大亮点，是对容器对象功能的增强，它专注于对容器对象进行各种非常便利、高效的 聚合操作（aggregate operation）或者大批量数据操作。Stream API借助于同样新出现的Lambda表达式，极大的提高编程效率和程序可读性。同时，它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用fork/join并行方式来拆分任务和加速处理过程。所以说，Java8中首次出现的 java.util.stream是一个函数式语言+多核时代综合影响的产物。
Java8Test.java_java8_almosttog_stream流_
09-29
Java 8是Java语言的一个重要版本，引入了许多新特性，其中Stream API是其最显著的改进之一。Stream API提供了一种新的数据处理方式，使得在集合上进行操作更加简洁、高效。本文将深入探讨Java 8 Stream API的基础...
包括_基础数据结构leetcode基本搜索算法基本排序算法Java8_stream_java_basic.zip
最新发布
09-26
Java 8是Java语言的一次重要更新，引入了lambda表达式和stream API等特性。Stream API提供了一种高效、声明式的数据处理方式，它可以对集合或数组进行操作，包括筛选、映射、排序、查找、聚合等。Stream API的引入...
Java8新特性Stream流实例详解
08-29
Java8新特性Stream流实例详解 Java 8 中引入了 Stream 流，用于操作数据源（集合、数组等）所生成的元素序列。Stream 流是数据渠道，具有声明性、可复合、可并行三个特性，使得 Stream 操作更简洁、更灵活、高效。...
Java 入门指南：Java 8 新特性 —— Stream 流
热带鱼的技术博客
09-21 2293
Java Stream 是 Java 8 引入的一个新的API，它提供了一种函数式编程的方式来处理集合数据。Stream 可以看作是一系列支持高效的、函数式操作的元素序列。 通过使用Stream，可以对集合进行 过滤、映射、排序、查找 等操作，而不需要显示地使用循环或者迭代器。Stream API 使用一种类似于 SQL 查询的方式来操作数据，这样可以使代码更加简洁、可读性更强。
680.678.JAVA基础教程_动态代理与Java8新特性-Stream的中间操作：映射(680).rar
11-09
在Java编程语言中，动态代理和Java 8的新特性，如Stream API，是现代Java开发中的重要组成部分。本文将深入探讨这两个主题，并特别关注Stream API的中间操作——映射（Map）。 首先，让我们理解什么是动态代理。在...
Stream应用（一）——筛选与切片
u010502101的博客
02-12 3753
一、Stream简介Stream是一个数据流通道，用来操作集合、数组、数据源中的序列，并生成新的集合序列，在数据流通道中会对原来的集合、数组、数据源中的序列进行计算，计算的结果会生成一个新的序列，放在一个新的源中。 运用Stream操作分三步：创建Stream流、流中间操作、终止流操作注意： 1. Stream本省不会存储元素； 2. Stream不会改变原来源对象，相反，会返回一个持
Java8新特性强大的Stream API之Stream的中间操作筛选与切片（二）
qq_39746820的博客
04-16 633
Stream API的中间操作之筛选与切片这都是比较基础的方法。通过这些方法我们可以看出其基础还是Lambda表达式，所以还是要在学号Lambda表达式的基础上再进行这方面的学习为好。
Java8新特性-007-Stream映射-中间操作
qq_33605778的博客
12-29 651
方法概述 方 法 描 述 map(Function f) 接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。 mapToDouble(ToDoubleFunction f) 接收一个函数作为参数，该函数会被应用到每个元素上，产生一个新的 DoubleStream。 mapToInt(ToIntFunction f) 接收一个函数作为参数，该函数
Java8新特性Stream之映射
Kevin.wang
07-15 2212
一个非常常见的数据处理套路就是从某些对象中选择信息。比如在SQL里，你可以从表中选 择一列。Stream API也通过map和flatMap方法提供了类似的工具。 映射 1.map 流支持map方法，它会接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映 射成一个新的元素(使用映射一词，是因为它和转换类似，但其中的细微差别在于它是“创建一 个新版本”而不是去“修改”)。 例如下面的例子,...
Java8 Stream分割list集合
热门推荐
qq_40548741的博客
03-04 4万+
使用Java8 Stream分割list集合，写好的工具类，可以直接用 package com.example.java8; import com.example.excel.Student; import org.apache.commons.collections4.CollectionUtils; import java.util.ArrayList; import java.util....
stream筛选与切片——Java8新特性
AlbenXie的博客
03-23 786
package com.example.demo.lambdaStreamAPI; import com.example.demo.lambda.Employee; import org.junit.Test; import java.util.ArrayList; import java.util.Arrays; import java.util.Iterator; import java...
Java8中一个极其强悍的新特性，很多人没用过（非常实用）
公众号-老炮说Java
02-09 385
点击上方蓝色字体，选择“标星公众号”优质文章，第一时间送达上一篇：这300G的Java资料是我师傅当年给我的，免费分享给大家（已修复）下一篇：昨天分享资料不小心把百度网盘深处的秘密泄露了...
stream(流) 映射
weixin_45730866的博客
02-02 250
stream(流) 映射
Java8 Stream映射
08-06 1638
package com.expgiga.Java8; /** * */ public class Employee { private String name; private int age; private double salary; private int id; public Employee() { } public E
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

ZHOU_VIP

您的鼓励将是我创作最大的动力！

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

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

打赏作者

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

抵扣说明：

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

余额充值