（jdk8---＞新特性一lambda表达式的语法及应用）jdk8的简介+数字排序和数据集合的排序方式案例（学了之后贼简单，轻轻松松做好排序）

最新推荐文章于 2023-02-14 23:01:26 发布
最新推荐文章于 2023-02-14 23:01:26 发布
阅读量731 收藏 1
点赞数
文章标签： java jdk1.8
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/men_ma/article/details/110790330
版权

转载请标明出处：https://blog.youkuaiyun.com/men_ma/article/details/106847165.
本文出自 不怕报错 就怕不报错的小猿猿 的博客

（jdk8--->新特性一lambda表达式）jdk8的简介+数字排序和数据集合的排序方式案例（学了之后贼简单，轻轻松松做好排序）

目标

在这里插入图片描述
开发工具：eclipse

首先我们先来新建一个项目
在这里插入图片描述

1.案例一：数字排序（出现jdk8之前与出现jdk8之后）

可能有人问有疑惑，我们为什么要学习jdk8？现在博主通过一个案例来讲解（数字排序）

在jdk8没有出现之前，我们是这样排序的，如下：

	
//	jdk8出现之前的数字排序方式
	@Test
	public void test1() {
//		倒序排序
		Comparator<Integer> c=new Comparator<Integer>() {

			@Override
			public int compare(Integer o1, Integer o2) {
				return -Integer.compare(o1, o2);
			}
			
		};
//		没有Comparator时，这时是顺序排序
		Set<Integer> set=new TreeSet<>(c);
		set.add(2);
		set.add(6);
		set.add(9);
		set.add(3);
		set.add(7);
		set.add(5);
		System.out.println(set);
	}

利用junit单元测试结果：

在这里插入图片描述
顺序排序：
在这里插入图片描述

倒序排序：

在这里插入图片描述
在jdk8出现之后，我们是这样排序的，利用jdk8常用的lambda表达式如下：

	
//	jdk8出现之后
	@Test
	public void test2() {
//		jdk8常用的lambda表达式
		Set<Integer> set=new TreeSet<>((x,y)->-Integer.compare(x, y));
		set.add(2);
		set.add(6);
		set.add(9);
		set.add(3);
		set.add(7);
		set.add(5);
		System.out.println(set);
	}

测试结果：
在这里插入图片描述
看到这里是不是感觉jdk8的功能能让我们开发的程序员能够快速的开发呢

2.案例二：获取公司中员工工资大于6000的员工信息及获取公司中员工年龄大于40的员工信息

首先我们先来建一个实体类Employee：
为减少代码量，省略的get/set方法及构造方法和tostring方法

package com.java5678.jdk8;

public class Employee {
	private String name;
	private int age;
	private float salary;
}

刚刚那个简单的数字排序大家可能不能直观的感受到jdk8的强大之处，现在我们再来个案例来进行对比，如下：

2、获取公司中员工工资大于6000的员工信息
3、获取公司中员工年龄大于40的员工信息

我们先搞一些初始化数据：


	List<Employee> employees;
	@Before
	public void before() {
		employees = Arrays.asList(new Employee("zhangsan",22,8888.8f),
                new Employee("lisi",44,6666.6f),
                new Employee("wangwu",55,4444.4f),
                new Employee("maliu",11,1111.1f),
                new Employee("tianqi",77,7777.7f),
                new Employee("wangba",33 ,3333.3f),
                new Employee("zhaojiu",99,5656.7f),
                new Employee("huoying",56,8787.6f));
	}

在没有学jdk8时，我们是这样做的：

	
//	2、获取公司中员工工资大于6000的员工信息
	private List<Employee> filterList1(List<Employee> employees){
		List<Employee> list = new ArrayList<>();
		for (Employee employee : employees) {
			if(employee.getSalary() > 6000) {
				list.add(employee);
			}
		}
		
		return list;
	}
//	3、获取公司中员工年龄大于40的员工信息
	private List<Employee> filterList2(List<Employee> employees){
		List<Employee> list = new ArrayList<>();
		for (Employee employee : employees) {
			if(employee.getAge() > 40) {
				list.add(employee);
			}
		}
		return list;
	}
	
//	3、获取公司中员工年龄大于60的员工信息
	private List<Employee> filterList3(List<Employee> employees){
		List<Employee> list = new ArrayList<>();
		for (Employee employee : employees) {
			if(employee.getAge() > 40) {
				list.add(employee);
			}
		}
		return list;
	}

测试代码：


//	jdk8出现之前的数据集合的排序方式
	@Test
	public void test3() {
		List<Employee> filterList1 = filterList1(employees);
		for (Employee employee : filterList1) {
			System.out.println(employee);
		}
		System.out.println("----------------");
		List<Employee> filterList2 = filterList2(employees);
		for (Employee employee : filterList1) {
			System.out.println(employee);
		}
	}

测试结果：
在这里插入图片描述
如上所述的这两个案例排序，你会发现有很多的重复代码，他们唯一不同的地方是if的条件语句不一样，现在我们来看看jdk8是怎么做的，贼简单，lets go

首先我们来定义一个MyPredicate接口，这个接口是jdk8内置的，后面我们会学的：

package com.java5678.jdk8;

public interface MyPredicate<T> {

	public boolean test(T t);
}

这时有人会有疑问了，我们定义这个接口有什么用呢？我们还是根据上面的需求完成同样的功能

//创建一个调研性方法，为测试代码做前铺
private List<Employee> filterList(List<Employee> employees,	MyPredicate<Employee> mp){
		List<Employee> list = new ArrayList<>();
		for (Employee employee : employees) {
			if(mp.test(employee)) {
				list.add(employee);
			}
		}
		return list;
	}

在这里插入图片描述

测试代码：

//	jdk8出现之后的数据集合的排序方式
	@Test
	public void test4() {
//		获取公司中员工工资大于6000的员工信息
		List<Employee> filterList1 = filterList(employees,(e)->e.getSalary()>6000);
		for (Employee employee : filterList1) {
			System.out.println(employee);
		}
//		3、获取公司中员工年龄大于40的员工信息
		System.out.println("----------------");
		List<Employee> filterList2 = filterList(employees,(e)->e.getAge()>40);
		for (Employee employee : filterList2) {
			System.out.println(employee);
		}
//		3、获取公司中员工年龄大于60的员工信息
		System.out.println("----------------");
		List<Employee> filterList3 = filterList(employees,(e)->e.getAge()>60);
		for (Employee employee : filterList3) {
			System.out.println(employee);
		}
	}

测试结果：
在这里插入图片描述

如上所述的案例合并为一个Demo.java类：

package com.java5678.jdk8;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

import org.junit.Before;
import org.junit.Test;

/**
 * 为什么要学习jdk8
 * @author zjjt
 *
 */
public class Demo1 {
	
	List<Employee> employees;
	@Before
	public void before() {
		employees = Arrays.asList(new Employee("zhangsan",22,8888.8f),
                new Employee("lisi",44,6666.6f),
                new Employee("wangwu",55,4444.4f),
                new Employee("maliu",11,1111.1f),
                new Employee("tianqi",77,7777.7f),
                new Employee("wangba",33 ,3333.3f),
                new Employee("zhaojiu",99,5656.7f),
                new Employee("huoying",56,8787.6f));
	}
	
//	jdk8出现之前的数字排序方式
	@Test
	public void test1() {
//		倒序排序
		Comparator<Integer> c=new Comparator<Integer>() {

			@Override
			public int compare(Integer o1, Integer o2) {
				return -Integer.compare(o1, o2);
			}
			
		};
//		没有Comparator时，这时时顺序排序
		Set<Integer> set=new TreeSet<>(c);
		set.add(2);
		set.add(6);
		set.add(9);
		set.add(3);
		set.add(7);
		set.add(5);
		System.out.println(set);
	}
	
	
	
//	jdk8出现之后
	@Test
	public void test2() {
//		jdk8常用的lambda表达式
		Set<Integer> set=new TreeSet<>((x,y)->-Integer.compare(x, y));
		set.add(2);
		set.add(6);
		set.add(9);
		set.add(3);
		set.add(7);
		set.add(5);
		System.out.println(set);
	}
	
	
	
	
//	2、获取公司中员工工资大于6000的员工信息
	private List<Employee> filterList1(List<Employee> employees){
		List<Employee> list = new ArrayList<>();
		for (Employee employee : employees) {
			if(employee.getSalary() > 6000) {
				list.add(employee);
			}
		}
		
		return list;
	}
//	3、获取公司中员工年龄大于40的员工信息
	private List<Employee> filterList2(List<Employee> employees){
		List<Employee> list = new ArrayList<>();
		for (Employee employee : employees) {
			if(employee.getAge() > 40) {
				list.add(employee);
			}
		}
		return list;
	}
	
//	3、获取公司中员工年龄大于60的员工信息
	private List<Employee> filterList3(List<Employee> employees){
		List<Employee> list = new ArrayList<>();
		for (Employee employee : employees) {
			if(employee.getAge() > 40) {
				list.add(employee);
			}
		}
		return list;
	}

//	jdk8出现之前的数据集合的排序方式
	@Test
	public void test3() {
		List<Employee> filterList1 = filterList1(employees);
		for (Employee employee : filterList1) {
			System.out.println(employee);
		}
		System.out.println("----------------");
		List<Employee> filterList2 = filterList2(employees);
		for (Employee employee : filterList1) {
			System.out.println(employee);
		}
	}
	
	private List<Employee> filterList(List<Employee> employees,	MyPredicate<Employee> mp){
		List<Employee> list = new ArrayList<>();
		for (Employee employee : employees) {
			if(mp.test(employee)) {
				list.add(employee);
			}
		}
		return list;
	}
	
//	jdk8出现之后的数据集合的排序方式
	@Test
	public void test4() {
//		获取公司中员工工资大于6000的员工信息
		List<Employee> filterList1 = filterList(employees,(e)->e.getSalary()>6000);
		for (Employee employee : filterList1) {
			System.out.println(employee);
		}
//		3、获取公司中员工年龄大于40的员工信息
		System.out.println("----------------");
		List<Employee> filterList2 = filterList(employees,(e)->e.getAge()>40);
		for (Employee employee : filterList2) {
			System.out.println(employee);
		}
//		3、获取公司中员工年龄大于60的员工信息
		System.out.println("----------------");
		List<Employee> filterList3 = filterList(employees,(e)->e.getAge()>60);
		for (Employee employee : filterList3) {
			System.out.println(employee);
		}
	}
	
	

	
}

over…

求职之路 | 2024年Java从入门到干活：第18章JDK8-JDK21新特性(一)——Lambda表达式
weixin_36664787的博客
03-28 1834
了解Java发行版本LTS是特么什么鬼Oracle JDK 和 Open JDK的区别，怎么选JDKLambda表达式函数式接口Stream APIOptional类新的时间和日期API...跟我学Java，我保证大家可以包学包会，管死管埋，那么让我们开始新章节的学习吧。篇幅有限，各个版本的新特性将放在最后一节讲述。只声明一个抽象方法的接口，称为函数式接口。当然可以包含其他非抽象方法。Java建议在一个函数式接口声明上使用注解，这样可以检查它是否是一个函数式接口。
Java系列JDK 1.8 新特性之 Lambda表达式.pdf
最新发布
02-21
Lambda表达式是Java 8中引入的一个重要新特性，它允许开发者以一种更加简洁的方式编写函数式接口实现代码。Lambda表达式本质上是一个匿名函数，能够作为一个参数传递给方法调用或存储在变量中，这使得Java支持了更高...
JDK8排序总结
08-31
JDK8排序总结的示例代码，想要对Java8的排序有所了解的可以下载下来看一下
jdk8 lambda 排序
Zsigner的博客
03-06 1105
1.需要根据某一个字段正序重新组合集合 正序排序时: //ProductVo 是一个entity List&lt;ProductVo&gt; tmpLists = new ArrayList&lt;&gt;(); //方法一 stream: tmpLists.stream().sorted(Comparator.comparing(v-&gt;v.getLabelSound())); tmp...
JDK8 排序
qq_33568833的博客
09-08 726
package exmind.base;/** * 实体类 * * @author pengXiaoLin * @date 2017-09-07 11:10 **//** * Created by jstarseven on 2016/3/21. */ public class Human {private String name; private int age;@O
jdk8的排序
weixin_38316999的博客
05-14 535
一 实体类package exmind.base;/** * 实体类 * * @author pengXiaoLin * @date 2017-09-07 11:10 **//** * Created by jstarseven on 2016/3/21. */public class Human {    private String name;    private int age;    @...
jdk8 新特性stream 和lambda表达式Demo
01-24
在`jdk8Demo`的示例中，你会看到如何将Stream API和Lambda表达式结合，优雅地处理集合数据，实现数据过滤、转换和聚合等功能。这两个特性不仅让Java代码更简洁，而且提高了代码的可读性和可维护性，是Java开发者必须...
jdk-8u181-windows-x64.zip
10-10
6. Stream API：JDK 8引入了Stream API，它提供了一种对集合进行声明式处理的新方式，可以用于过滤、映射、聚合等操作，非常适合进行数据处理和分析。 7. 接口私有方法和静态方法：JDK 8允许在接口中定义私有方法和...
Java8：Lambda表达式增强版Comparator和排序
12-22
1、概述 　　在这篇教程里，我们将要去了解下即将到来的JDK 8（译注，现在JDK 8已经发布了）中的Lambda表达式——特别是怎样使用它来编写Comparator和对集合（Collection）进行排序。 　　这篇文章是Baeldung上的“Java ——回归基础”（“Java – Back to Basic”）系列的一部分。 　　首先，让我们先定义一个简单的实体类： public class Human { private String name; private int age; public Human() { super(); } public Human(fi
屌炸天，JDK8的排序大法！！
huangshulang1234的博客
01-25 4905
屌炸天，JDK8的排序大法！！ 今天总结了下JDK中排序的方法，包括JDK8中强大的lambda表达式及函数式接口运用，不废话，请看下面示例。 public class Test {     public static void main(String[] args) {         List list = initList();
JDK8
我3的博客
07-30 188
Java 8 Lambda 表达式 Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。 不需要声明参数类型，编译器可以统一识别参数值 一个参数无需定义圆括号，但多个参数需要定义圆括号 如果主体包含了一个语句，就不需要使用大括号 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号 标记类型接口:是一种没有方法或属性声明的接口,用作描述类的元数据 函数式接口:是只包含一个抽象方法声明的接口(用注解@FunctionalInterface...
【JAVA】jdk8 Stream 排序精通
weixin_41979605的博客
02-14 5830
因为对象比基本类型占用空间大，如果排完序之后再翻转，而同时数组长度比较大，那么就可能有性能问题，所以可以直接指定排序的方向，避免不必要的浪费。但是对于完全的数值比较，其实就按照默认的比较即可，给Stream 排序的值即可,特别是对象，只需要指定字段即可。jdk8的stream流能方便的排序，但是每次都要查资料，非常不方便，不确定，所以这次直接弄懂，不再迷茫。,字符串比较很简单，就是字符依次比较，从小到大，第一位相同比第二位，依次排序。因此对象排序，优先使用这样的方式去指定排序，特别是倒序的时候。
JDK8的排序大法
tanghui20的专栏
05-23 7329
main.java:public class Main {    public static void main(String[] args) throws  Exception{             testJDK8_sort();    }    private static List&lt;User&gt; initList() {        List&lt;User&gt; lis...
JDK 8 之 List排序
热门推荐
IT技术总结
11-04 1万+
1、自然序排序一个list： list.stream().sorted().collect(Collectors.toList()); 2、自然序逆序元素，使用Comparator 提供的reverseOrder() 方法： list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());...
JDK8中各种排序方法！
JavaWebEngineer的博客
07-21 2885
一、代码测试案例 package demo; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; import entity.Users; /** * @author :zkx * @createtime ：2020年5月21日 上午8:56:52 * @description: */ public class Test { p
Java jdk8 排序
m0_37598953的博客
09-04 587
jdk 8 Lambda 表达式的基本排序 1.获取对象 解析json  ResponseEntity&lt;JSONObject&gt; responseEntity = restTemplate.postForEntity(staticDBFeatureBatchSearchUrl,                     params, JSONObject.class);     ...
JDK8新特性深度解析：Lambda表达式的魅力
Lambda表达式是JDK8引入的一项重大新特性，它极大地简化了Java中处理函数式接口的代码，尤其是对于那些只包含单个抽象方法的接口。Lambda表达式的核心思想是将代码视为数据，使得可以像传递其他对象一样传递行为。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值