java8新特性（2）-Lambda表达式

最新推荐文章于 2024-08-14 20:13:39 发布
最新推荐文章于 2024-08-14 20:13:39 发布
阅读量400 收藏
点赞数
文章标签： Lambda  新特性
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35755863/article/details/91520792
版权
本文详细介绍了Java 8的Lambda表达式，它允许将函数作为方法参数，简化代码并提高代码的可读性。通过实例分析，展示了如何使用Lambda进行过滤和排序操作，并探讨了方法引用的使用，以及在使用Lambda时的类型推断和局部变量注意事项。
摘要由CSDN通过智能技术生成

一：官方定义

 Lambda 表达式 − Lambda允许把函数作为一个方法的参数（函数）作为参数传递进方法中。

该表达式的目的是：优化我们的代码，使我们的代码更加的简洁。

举例说明：

   //使用java7排序
  private void sortUsingJava7(List<String> names){   
      Collections.sort(names, new Comparator<String>() {
         @Override
         public int compare(String s1, String s2) {
            return s1.compareTo(s2);
         }
      });
   }
   
   
  // 使用 java 8 排序
   private void sortUsingJava8(List<String> names){
      Collections.sort(names, (s1, s2) -> s1.compareTo(s2));
   }

      在7/8中我们看出来实则区别就是 对于Collections.sort（..）方法的调用。在使用 new Comparator<String>() 直接将参数转换成行为方法。

二：分析

1.线上代码：（其中User（id ->String ，name -> String ,age -> int））

public static void main(String[] args) {

	List<User> list = new ArrayList<>();
	User user1 = new User("1", "u1", 15);
	User user2 = new User("2", "u2", 15);
	User user3 = new User("2", "u3", 15);
	User user4 = new User("4", "u4", 16);
	User user5 = new User("5", "u5", 16);
	User user6 = new User("6", "u6", 16);
	User user7 = new User("7", "u7", 16);
	User user8 = new User("8", "u8", 17);
	User user9 = new User("9", "u9", 17);
	list.add(user1);
	list.add(user2);
	list.add(user3);
	list.add(user4);
	list.add(user5);
	list.add(user6);
	list.add(user7);
	list.add(user8);
	list.add(user9);	

}

2.下面定义一个一个方法：取出年龄大于15的所有的User

/**
 * 取出年龄大于15的所有的User
 * @param age
 * @param userlist
 * @return
 */
public List<User> getUser(Integer age,List<User> userlist){
	List<User> list=new ArrayList<User>();
	for(User user:userlist) {
		if(user.getAge() >= age) {
			list.add(user);
		}
	}
	return list;
}

3.下面要求取出年龄大于15且名字不为张三的所有user

/**
 * 取出年龄大于15且名字不为张三的所有user
 * @param age
 * @param userlist
 * @return
 */
public List<User> getUser2(Integer age,String userName,List<User> userlist){
	List<User> list=new ArrayList<User>();
	for(User user:userlist) {
		if(user.getAge() >= age && !user.getUserName() .equals("张三")) {
			list.add(user);
		}
	}
	return list;
}

4.这是如果要求：取出年龄大于15且名字不为张三且id大于100的用户呢？

   明显又要创建新的方法或者改造老方法，很烦是不是？在java8之前，使用了接口然后实现其中的方法。

    a.定义一个过滤机接口

	//过滤接口---满足条件
	interface userFilter{ boolean accep(User user);}

    b.实现过滤

	//过滤实现的方法
	static List<User>  userfilter(List<User> userList,userFilter userFiler){
		List<User>  resList=new ArrayList<User>();
		
		for(final User user:userList) {
			if(userFiler.accep(user)) {
				resList.add(user);
			}
		}
		return resList;
		
	}

    c.实现应用

    

public static void main(String[] args) {

	List<User> list = new ArrayList<>();
	User user1 = new User("1", "u1", 15);
	User user2 = new User("2", "u1", 15);
	User user3 = new User("2", "u3", 15);
	User user4 = new User("4", "u4", 16);
	User user5 = new User("5", "u5", 16);
	User user6 = new User("6", "u6", 16);
	User user7 = new User("7", "u7", 16);
	User user8 = new User("8", "u8", 17);
	User user9 = new User("9", "u9", 17);
	list.add(user1);
	list.add(user2);
	list.add(user3);
	list.add(user4);
	list.add(user5);
	list.add(user6);
	list.add(user7);
	list.add(user8);
	list.add(user9);	
	
	//实现过滤，重写过滤条件
	List<User> resUser=userfilter(list, new userFilter() {		
		@Override
		public boolean accep(User user) {
			return user.getAge() ==15 && user.getUserName().equals("u1");
		}
	});
}

         很明显，我们过滤的时候只要实现userFilter接口中的数据就可以的。看到上述的代码是不是很熟悉，对java中实现list根据某

    一 个元素排序就是这么做的。这时候我们使用lambda实现代码简化：我想能看懂了吧。

List<User> resUser2=userfilter(list, (User user) ->  user.getAge() == 15 && user.getUserName().equals("u1"));

    

     本节完整代码：

      



import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Test {
	
	/**
	 * 取出年龄大于15的所有的User
	 * @param age
	 * @param userlist
	 * @return
	 */
	public List<User> getUser(Integer age,List<User> userlist){
		List<User> list=new ArrayList<User>();
		for(User user:userlist) {
			if(user.getAge() >= age) {
				list.add(user);
			}
		}
		return list;
	}


	/**
	 * 取出年龄大于15且名字不为张三的所有user
	 * @param age
	 * @param userlist
	 * @return
	 */
	public List<User> getUser2(Integer age,String userName,List<User> userlist){
		List<User> list=new ArrayList<User>();
		for(User user:userlist) {
			if(user.getAge() >= age && !user.getUserName() .equals("张三")) {
				list.add(user);
			}
		}
		return list;
	}

	
	//过滤接口
	interface userFilter{ boolean accep(User user);}
	
	//过滤实现的方法
	static List<User>  userfilter(List<User> userList,userFilter userFiler){
		List<User>  resList=new ArrayList<User>();
		
		for(final User user:userList) {
			if(userFiler.accep(user)) {
				resList.add(user);
			}
		}
		return resList;
		
	}
	
public static void main(String[] args) {

	List<User> list = new ArrayList<>();
	User user1 = new User("1", "u1", 15);
	User user2 = new User("2", "u1", 15);
	User user3 = new User("2", "u3", 15);
	User user4 = new User("4", "u4", 16);
	User user5 = new User("5", "u5", 16);
	User user6 = new User("6", "u6", 16);
	User user7 = new User("7", "u7", 16);
	User user8 = new User("8", "u8", 17);
	User user9 = new User("9", "u9", 17);
	list.add(user1);
	list.add(user2);
	list.add(user3);
	list.add(user4);
	list.add(user5);
	list.add(user6);
	list.add(user7);
	list.add(user8);
	list.add(user9);	
	
	//实现过滤，重写过滤条件
	List<User> resUser=userfilter(list, new userFilter() {		
		@Override
		public boolean accep(User user) {
			return user.getAge() ==15 && user.getUserName().equals("u1");
		}
	});
	
	//使用lambda简化 实现过滤，重写过滤条件
	List<User> resUser2=userfilter(list, (User user) ->  user.getAge() == 15 && user.getUserName().equals("u1"));
			
	System.out.println(resUser);
	System.out.println(resUser2);
}





}

d.基于上述的list，我们来使用lamdba重写list的sort方法

	List<User> list = new ArrayList<>();
	User user1 = new User("1", "u1", 1);
	User user2 = new User("2", "u1", 2);
	User user3 = new User("2", "u3", 3);
	User user4 = new User("4", "u4", 4);
	User user5 = new User("5", "u5", 5);
	User user6 = new User("6", "u6", 6);
	User user7 = new User("7", "u7", 7);
	User user8 = new User("8", "u8", 8);
	User user9 = new User("9", "u9", 9);
	list.add(user1);
	list.add(user2);
	list.add(user3);
	list.add(user4);
	list.add(user5);
	list.add(user6);
	list.add(user7);
	list.add(user8);
	list.add(user9);	
	
	//原始方法
	list.sort(new Comparator<User>() {

		@Override
		public int compare(User o1, User o2) {
			if(o1.getAge() > o2.getAge()) {
				return -1;
			}
			if(o1.getAge() < o2.getAge()) {
				return 1;
			}
			
			if(o1.getAge() == o2.getAge()) {
				return -0;
			}
			return 0;
		}
	});
	
	//表达式
	list.sort((User u1,User u2)-> u2.getAge() - u1.getAge());
	System.out.println(list);
	
}

三：lambda表达式

1.基于上述的使用：

   我们看到一半对于方法中有抽象的实现比如：方法名称（需要处理的对象，接口<参数>{方法的具体实现；}）

   转化成lambda表达式:方法名称（需要处理的对象，（参数）->(方法的具体实现)），其中上关于对象集合的过滤就是如此。

   或者  需要处理的对象.方法名（接口<参数>{方法的具体实现 ；}） 转化  需要处理的对象.方法名（(参数)->(具体的实现)），如

    上述的对于list集合的排序就是如此。

    

2.lambda表达式

  a.简而言之就是：参数列表 -> 表达式  /参数列表 -> {表达式集合}

 

3.基于函数式接口使用lambda

  a。自定义函数式接口，比如我们第一个用户过滤接口

@FunctionalInterface
interface userFilter{ boolean accep(User user);}

   其中@FunctionalInterface接口可有可无，但是当有注解时，接口只允许有一个抽象方法，否则会报错。

  b.基于jdk自带的函数式接口（部分）

                

 

4.lambda使用注意事项

  类型推断、局部变量

 

四：方法的引用

有时候，我们需要在lambo中引用类方法，使用方式 类名：：方法名称

说实话，lambda表达式处理一些内部类是可以的，如果太较真就没必要了。

lambda表达式与new接口的关系
blue
12-21 565
/** * @Author: CQG * @Date: 2021/12/21 11:22 * @description: */ public class TestDemo { interface Printer { void printer(String val); } public void pringSomething(String something, Printer printer) { printer.printer(somet.
Java8新特性——Lambda表达式
m0_64354070的博客
11-28 1304
Java8新特性——Lambda表达式 2.1 什么是Lambda表达式？ 2.2 为什么要使用Lambda表达式？ 2.3 从匿名内部类到 Lambda 的转换 3.1 语法一：无参无返回值，Lambda 体只需要一条语句 3.2 语法二：传递一个参数，无返回值 3.3 语法三：传递一个参数时，参数的小括号可以省略，无返回值 3.4 语法四：传递两个参数，有返回值 3.5 语法五：当 Lambda 体只有一条语句时，return 与大括号可以省略 4.1
Lambda表达式File类
weixin_51621893的博客
12-12 248
今日内容 函数式编程思想 lambda表达式 File类 递归 函数式编程思想 强调的是做什么，而不是以什么样的方式来做，它忽略了面向对象的复杂语法，只要能够获取到结果，谁去做的，怎么做的，都不重要，重要的是结果，不重视过程。 冗余的Runnable代码 传统的写法 public class Demo01Runnable { public static void main(String[] args) { // 匿名内部类的方.
Lambda表达式、方法引用、算法、正则表达式
最新发布
2303_82176667的博客
08-14 1067
但是从另一个角度想，一旦我们学会了，会大大简化我们的代码书写，提高我们编写代码的效率，而且这些新的语法都是有前提条件的，遇到的时候就简化得了。**先聊一聊基本查找：**假设我们要查找的元素是81，如果是基本查找的话，只能从0索引开始一个一个往后找，但是如果元素比较多，你要查找的元素比较靠后的话，这样查找的此处就比较多。接下来，我们学习一下正则表达式的另外两个功能，替换、分割的功能。在学习二分查找之前，我们先来说一下基本查找，从基本查找的弊端，我们再引入二分查找，这样我们的学习也会更加丝滑一下。
lambda表达式
2302_76551974的博客
12-25 806
一：lambda表达式lambda表达式可以用非常少的代码实现抽象方法。lambda 表达式不能独立执行，因此必须实现函数式接口，并且会返回一个函数式接口的对象。语法格式如下：（） -> 结果表达式参数 -> 结果表达式（参数1，参数2，...,参数n) -> 结果表达式二.lambda 表达式实现函数式接口lambda表达式可以实现函数式接口，本节将讲解函数式接口概念以及用 lambda 表达式实现不同类型的函数式接口。1.函数式接口。
668.666.JAVA基础教程_动态代理与Java8新特性-Lambda表达式使用举例(668).rar
11-09
本教程重点探讨了两个关键的Java技术：动态代理和Java 8的新特性，特别是Lambda表达式的应用。 首先，让我们来理解动态代理。在Java中，动态代理允许我们在运行时创建一个实现了特定接口的代理类。这种技术常用于...
670.668.JAVA基础教程_动态代理与Java8新特性-Lambda表达式语法的使用(670).rar
11-09
本教程重点探讨了两个关键的Java技术：动态代理和Java 8的新特性，特别是Lambda表达式的使用。 首先，让我们深入理解动态代理。在Java中，动态代理允许我们在运行时创建一个实现了一组特定接口的代理类。这种代理类...
Java8新特性Lambda表达式的一些复杂用法总结
08-29
Java 8引入了Lambda表达式，这是一种强大的新特性，它为Java编程语言带来了函数式编程的概念。Lambda表达式允许程序员创建匿名函数，即没有名称的函数，这些函数可以直接作为值传递给方法或存储在变量中。这使得代码...
Lambda表达式
qq_40208605的博客
06-12 3229
Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式支持将代码块作为方法参数，Lambda表达式允许使用更简洁的代码来创建只有一个抽象方法的接口（函数式接口）的实例。一、表达式入门先观察下段代码Comparator&lt;String&gt; com = new Comparator&lt;String&gt;(){    @Override    public int...
Java 8新特性详解：Lambda表达式与函数式接口深度解析
Java 8的新特性是编程语言发展的一个重要里程碑，它引入了Lambda表达式和函数式编程的概念，使得代码更加简洁、灵活和高效。以下是对这些新特性的详细解析： 1. **Lambda表达式** - **概念**：Lambda表达式是一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值