Lambda系列教材（一）- Java Lambda 表达式教程

工具版本兼容问题

假设一个情景：找出满足条件的Hero
本教程将从使用普通方法，匿名类，以及 Lambda这几种方式，逐渐的引入Lambda的概念

纠

本视频是解读性视频，所以希望您已经看过了本知识点的内容，并且编写了相应的代码之后，带着疑问来观看，这样收获才多。不建议一开始就观看视频

20分39秒
本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

步骤 1 : 普通方法
步骤 2 : 匿名类方式
步骤 3 : Lambda方式
步骤 4 : 设置eclipse以支持Lambda
步骤 5 : 从匿名类演变成Lambda表达式
步骤 6 : 匿名方法
步骤 7 : Lambda的弊端
步骤 8 : 练习-Comparator
步骤 9 : 答案-Comparator

步骤 1 :

普通方法

edit 顶折

纠问

使用一个普通方法，在for循环遍历中进行条件判断，筛选出满足条件的数据

hp>100 && damage<50

TestLambda.java
Hero.java

代码行数较多，请点击查看

package lambda;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
 
import charactor.Hero;
 
public class TestLambda {
    public static void main(String[] args) {
        Random r = new Random();
        List<Hero> heros = new ArrayList<Hero>();
        for (int i = 0; i < 10; i++) {
            heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100)));
        }
        System.out.println("初始化后的集合：");
        System.out.println(heros);
        System.out.println("筛选出 hp>100 && damange<50的英雄");
        filter(heros);
    }
 
    private static void filter(List<Hero> heros) {
        for (Hero hero : heros) {
            if(hero.hp>100 && hero.damage<50)
                System.out.print(hero);
        }
    }
 
}

代码行数较多，请点击查看

package charactor;
    
public class Hero implements Comparable<Hero>{
    public String name; 
    public float hp;
       
    public int damage;
       
    public Hero(){
          
    }
      
    public Hero(String name) {
        this.name =name;
  
    }
      
    //初始化name,hp,damage的构造方法
    public Hero(String name,float hp, int damage) {
        this.name =name;
        this.hp = hp;
        this.damage = damage;
    }
  
    @Override
    public int compareTo(Hero anotherHero) {
        if(damage<anotherHero.damage)
            return 1;  
        else
            return -1;
    }
  
    @Override
    public String toString() {
        return "Hero [name=" + name + ", hp=" + hp + ", damage=" + damage + "]\r\n";
    }
      
}

步骤 2 :

匿名类方式

edit 顶折

纠问

首先准备一个接口HeroChecker，提供一个test(Hero)方法
然后通过匿名类的方式，实现这个接口

HeroChecker checker = new HeroChecker() {
public boolean test(Hero h) {
return (h.hp>100 && h.damage<50);
}
};

接着调用filter，传递这个checker进去进行判断，这种方式就很像通过Collections.sort在对一个Hero集合排序，需要传一个 Comparator的匿名类对象进去一样。

TestLambda.java
HeroChecker.java

代码行数较多，请点击查看

package lambda;
  
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
  
import charactor.Hero;
  
public class TestLambda {
    public static void main(String[] args) {
        Random r = new Random();
        List<Hero> heros = new ArrayList<Hero>();
        for (int i = 0; i < 5; i++) {
            heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100)));
        }
        System.out.println("初始化后的集合：");
        System.out.println(heros);
        System.out.println("使用匿名类的方式，筛选出 hp>100 && damange<50的英雄");
        HeroChecker checker = new HeroChecker() {
            @Override
            public boolean test(Hero h) {
                return (h.hp>100 && h.damage<50);
            }
        };
          
        filter(heros,checker);
    }
  
    private static void filter(List<Hero> heros,HeroChecker checker) {
        for (Hero hero : heros) {
            if(checker.test(hero))
                System.out.print(hero);
        }
    }
  
}

代码行数较多，请点击查看

package lambda;

import charactor.Hero;

public interface HeroChecker {
	public boolean test(Hero h);
}

步骤 3 :

Lambda方式

edit 顶折

纠问

使用Lambda方式筛选出数据

filter(heros,(h)->h.hp>100 && h.damage<50);

同样是调用filter方法，从上一步的传递匿名类对象，变成了传递一个Lambda表达式进去

h->h.hp>100 && h.damage<50

咋一看Lambda表达式似乎不好理解，其实很简单，下一步讲解如何从一个匿名类一点点演变成Lambda表达式

代码行数较多，请点击查看

package lambda;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import charactor.Hero;

public class TestLamdba {
	public static void main(String[] args) {
		Random r = new Random();
		List<Hero> heros = new ArrayList<Hero>();
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100)));
		}
		System.out.println("初始化后的集合：");
		System.out.println(heros);
		System.out.println("使用Lamdba的方式，筛选出 hp>100 && damange<50的英雄");
		filter(heros,h->h.hp>100 && h.damage<50);
	}

	private static void filter(List<Hero> heros,HeroChecker checker) {
		for (Hero hero : heros) {
			if(checker.test(hero))
				System.out.print(hero);
		}
	}

}

步骤 4 :

设置eclipse以支持Lambda

edit 顶折

纠问

如果你的eclipse能够正常识别Lambda，那么就可以跳过这个章节了。
因为Lambda是JDK8的内容，除了JDK需要使用1.8以上版本外( 在JDK环境变量配置下载的就是1.8了)，还需要在eclipse中把编译器设置为1.8才能够正常识别Lambda.

设置办法：
菜单->Window->Preferences->Java-Compiler->Compiler compliance leve: 设置为1.8即可

步骤 5 :

从匿名类演变成Lambda表达式

edit 顶折

纠问

Lambda表达式可以看成是匿名类一点点演变过来
1. 匿名类的正常写法

HeroChecker c1 = new HeroChecker() {
public boolean test(Hero h) {
return (h.hp>100 && h.damage<50);
}
};

2. 把外面的壳子去掉
只保留方法参数和方法体
参数和方法体之间加上符号 ->

HeroChecker c2 = (Hero h) ->{
return h.hp>100 && h.damage<50;
};

3. 把return和{}去掉

HeroChecker c3 = (Hero h) ->h.hp>100 && h.damage<50;

4. 把参数类型和圆括号去掉(只有一个参数的时候，才可以去掉圆括号)

HeroChecker c4 = h ->h.hp>100 && h.damage<50;

5. 把c4作为参数传递进去

filter(heros,c4);

6. 直接把表达式传递进去

filter(heros, h -> h.hp > 100 && h.damage < 50);

代码行数较多，请点击查看

package lambda;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import charactor.Hero;

public class TestLamdba {
	public static void main(String[] args) {
		Random r = new Random();
		List<Hero> heros = new ArrayList<Hero>();
		for (int i = 0; i < 5; i++) {
			heros.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100)));
		}
		System.out.println("初始化后的集合：");
		System.out.println(heros);
		System.out.println("使用匿名类的方式，筛选出 hp>100 && damange<50的英雄");
		// 匿名类的正常写法
		HeroChecker c1 = new HeroChecker() {
			@Override
			public boolean test(Hero h) {
				return (h.hp > 100 && h.damage < 50);
			}
		};
		// 把new HeroChcekcer，方法名，方法返回类型信息去掉
		// 只保留方法参数和方法体
		// 参数和方法体之间加上符号 ->
		HeroChecker c2 = (Hero h) -> {
			return h.hp > 100 && h.damage < 50;
		};

		// 把return和{}去掉
		HeroChecker c3 = (Hero h) -> h.hp > 100 && h.damage < 50;

		// 把 参数类型和圆括号去掉
		HeroChecker c4 = h -> h.hp > 100 && h.damage < 50;

		// 把c4作为参数传递进去
		filter(heros, c4);
		
		// 直接把表达式传递进去
		filter(heros, h -> h.hp > 100 && h.damage < 50);
	}

	private static void filter(List<Hero> heros, HeroChecker checker) {
		for (Hero hero : heros) {
			if (checker.test(hero))
				System.out.print(hero);
		}
	}

}

步骤 6 :

匿名方法

edit 顶折

纠问

与匿名类概念相比较，
Lambda 其实就是匿名方法，这是一种把方法作为参数进行传递的编程思想。

虽然代码是这么写

filter(heros, h -> h.hp > 100 && h.damage < 50);

但是，Java会在背后，悄悄的，把这些都还原成匿名类方式。
引入Lambda表达式，会使得代码更加紧凑，而不是各种接口和匿名类到处飞。

步骤 7 :

Lambda的弊端

edit 顶折

纠问

Lambda表达式虽然带来了代码的简洁，但是也有其局限性。
1. 可读性差，与啰嗦的但是清晰的匿名类代码结构比较起来，Lambda表达式一旦变得比较长，就难以理解
2. 不便于调试，很难在Lambda表达式中增加调试信息，比如日志
3. 版本支持，Lambda表达式在JDK8版本中才开始支持，如果系统使用的是以前的版本，考虑系统的稳定性等原因，而不愿意升级，那么就无法使用。

Lambda比较适合用在简短的业务代码中，并不适合用在复杂的系统中，会加大维护成本。

步骤 8 :

练习-Comparator

edit 顶折

纠问

姿势不对,事倍功半! 点击查看做练习的正确姿势

把比较器-Comparator 章节中的代码，按照从匿名类演变成Lambda表达式的步骤，改写为Lambda表达式

步骤 9 :

答案-Comparator

edit 顶折

纠问

在查看答案前，尽量先自己完成，碰到问题再来查看答案，收获会更多

查看本答案会花费4个积分，您目前总共有点积分。查看相同答案不会花费额外积分。积分增加办法或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)

账号未激活账号未激活，功能受限。请点击激活

本视频是解读性视频，所以希望您已经看过了本答案的内容，带着疑问来观看，这样收获才多。不建议一开始就观看视频

4分10秒本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

代码行数较多，请点击查看

package collection;
     
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
    
import charactor.Hero;
     
public class TestCollection {
    public static void main(String[] args) {
        Random r =new Random();
        List<Hero> heros = new ArrayList<Hero>();
            
        for (int i = 0; i < 10; i++) {
            heros.add(new Hero("hero "+ i, r.nextInt(100), r.nextInt(100)));
        }
        System.out.println("初始化后的集合：");
        System.out.println(heros);
        
        //匿名类
        Comparator<Hero> c = new Comparator<Hero>() {
            @Override
            public int compare(Hero h1, Hero h2) {
                return h1.hp>=h2.hp?1:-1;
            }
        };
        
        //Lambda表达式
        c = (Hero h1, Hero h2)-> {
            return h1.hp>=h2.hp?1:-1;
        };
        //去掉 return和大括号
        c = (Hero h1, Hero h2)->h1.hp>=h2.hp?1:-1;
        //去掉 参数类型        
        c = (h1, h2)->h1.hp>=h2.hp?1:-1;
        //有两个参数，无法去掉圆括号
        Collections.sort(heros,c);
        
        //直接把Lambda表达式作为参数传进去
        Collections.sort(heros,(h1, h2)->h1.hp>=h2.hp?1:-1);
        System.out.println(heros);
    }
}

Lambda系列教材（二）- 方法引用

程序编程之旅公众号，关注后实时获知最新的教程和优惠活动，谢谢。

问答区域

2021-08-17 答案

logiczqr

关于 JAVA 中级-Lambda-Hello Lambda -练习-Comparator 的提问

把比较器-Comparator 章节中的代码，按照从匿名类演变成Lambda表达式的步骤，改写为Lambda表达式

 System.out.println("使用lambda表达式:");
		TreeSet<Integer> ts2 = new TreeSet<Integer>((o1,o2)->o1 >= o2?-1 : 1);
		for(int i = 0; i < 10; i++){
			ts2.add((int)(Math.random() * 100));
		}
		System.out.println("倒序排序后的集合");
		System.out.println(ts2);

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2021-07-25 练习 - Comparator

莫諾

关于 JAVA 中级-Lambda-Hello Lambda 的提问

把比较器-Comparator 章节中的代码，按照从匿名类演变成Lambda表达式的步骤，改写为Lambda表达式

Random r = new Random();
		List<Hero> heros = new ArrayList<>();

		for (int i = 0; i <10; i++) {
			// 随机实例化hero的hp和damage
        	heros.add(new Hero("hero-" + i, r.nextInt(100), r.nextInt(100)));
        }
		System.out.println("初始化后的集合:");
		System.out.println(heros);
		Collections.sort(heros,(h1,h2) -> (h1.damage >= h2.damage)?1 : -1);

		System.out.println("按照伤害值排序后的集合");
		System.out.println(heros);

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2021-02-22 如果筛选后按照damage排序怎么搞？

WSZY丶

关于 JAVA 中级-Lambda-Hello Lambda -Lambda方式的提问

如果筛选后按照damage排序怎么搞？

1 个答案

从前以前
答案时间：2021-04-15

代码超过 5行，点击查看

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2020-09-08 和ES6的箭头函数很像= =

2020-06-06 类型去掉是怎么知道h是什么东西的？

sy1989

关于 JAVA 中级-Lambda-Hello Lambda 的提问

类型去掉了，到后面这行代码 filter(heros, h -> h.hp > 100 && h.damage < 50); 里，代码怎么知道这个h是什么？它怎么知道h有hp和damage这两个属性的？ filter这个方法有两个参数，一个是a list of heroes，一个是HeroChecker对象，假设HeroChecker里有两个方法test1和test2，test1的参数是Hero而test2的参数不是Hero，而是另一个不包含hp和damage参数的对象，那在上面那行代码里它怎么知道h.hp和h.damage是否应该报错？

4 个答案

songmen
答案时间：2020-11-30

使用lambda，去掉类型，可以去看接口的定义中对应的参数方法，就能知道。使用lambda这种方式，就要求定义接口时，不同的方法，参数不能一样，否则使用lambda无法定位到。

bravezhangw
答案时间：2020-08-25

lambda在使用之前就把你所担心的情况给规避掉了，其简写的参数及方法体只能唯一匹配匿名类的方法。

Gbanya
答案时间：2020-08-12

Collections.sort(heros,(h1,h2)->h1.hp>=h2.hp ? 1:-1);

香蕉大提莫
答案时间：2020-06-15

https://blog.csdn.net/williamtsang/article/details/52582906。虽然我也还不大懂，但感觉这个帖子讲到了一些点上。

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

提问太多，页面渲染太慢，为了加快渲染速度，本页最多只显示几条提问。还有 19 条以前的提问，请点击查看

提问之前请登陆

提问已经提交成功，正在审核。请于我的提问处查看提问记录，谢谢

关于 JAVA 中级-Lambda-Hello Lambda 的提问

尽量提供截图、代码和异常信息，有助于分析和解决问题。也可进本站QQ群交流: 496725845

提问尽量提供完整的代码，环境描述，越是有利于问题的重现，您的问题越能更快得到解答。
对教程中代码有疑问，请提供是哪个步骤，哪一行有疑问，这样便于快速定位问题，提高问题得到解答的速度
在已经存在的几千个提问里，有相当大的比例，是因为使用了和站长不同版本的开发环境导致的,比如 jdk, eclpise, idea, mysql,tomcat 等等软件的版本不一致。
请使用和站长一样的版本，可以节约自己大量的学习时间。站长把教学中用的软件版本整理了，都统一放在了这里，方便大家下载： /k/helloworld/helloworld-version/1718.html

上传截图