how2j.cn

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



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



步骤 1 : 引用静态方法   
步骤 2 : 引用对象方法   
步骤 3 : 引用容器中的对象的方法   
步骤 4 : 引用构造器   
步骤 5 : 练习-引用静态方法   
步骤 6 : 答案-引用静态方法   
步骤 7 : 练习-引用容器中的对象的方法   
步骤 8 : 答案-引用容器中的对象的方法   
步骤 9 : 练习-引用构造器   
步骤 10 : 答案-引用构造器   

步骤 1 :

引用静态方法

edit
首先为TestLambda添加一个静态方法:

public static boolean testHero(Hero h) {
return h.hp>100 && h.damage<50;
}

Lambda表达式:

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

在Lambda表达式中调用这个静态方法:

filter(heros, h -> TestLambda.testHero(h) );

调用静态方法还可以改写为:

filter(heros, TestLambda::testHero);

这种方式就叫做引用静态方法
引用静态方法
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); HeroChecker c = new HeroChecker() { public boolean test(Hero h) { return h.hp>100 && h.damage<50; } }; System.out.println("使用匿名类过滤"); filter(heros, c); System.out.println("使用Lambda表达式"); filter(heros, h->h.hp>100 && h.damage<50); System.out.println("在Lambda表达式中使用静态方法"); filter(heros, h -> TestLambda.testHero(h) ); System.out.println("直接引用静态方法"); filter(heros, TestLambda::testHero); } public static boolean testHero(Hero h) { return 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); } } }
步骤 2 :

引用对象方法

edit
与引用静态方法很类似,只是传递方法的时候,需要一个对象的存在

TestLambda testLambda = new TestLambda();
filter(heros, testLambda::testHero);

这种方式叫做引用对象方法
引用对象方法
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("使用引用对象方法 的过滤结果:"); //使用类的对象方法 TestLambda testLambda = new TestLambda(); filter(heros, testLambda::testHero); } public boolean testHero(Hero h) { return 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); } } }
步骤 3 :

引用容器中的对象的方法

edit
首先为Hero添加一个方法

public boolean matched(){
return this.hp>100 && this.damage<50;
}

使用Lambda表达式

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

在Lambda表达式中调用容器中的对象Hero的方法matched

filter(heros,h-> h.matched() );

matched恰好就是容器中的对象Hero的方法,那就可以进一步改写为

filter(heros, Hero::matched);

这种方式就叫做引用容器中的对象的方法
引用容器中的对象的方法
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("Lambda表达式:"); filter(heros,h-> h.hp>100 && h.damage<50 ); System.out.println("Lambda表达式中调用容器中的对象的matched方法:"); filter(heros,h-> h.matched() ); System.out.println("引用容器中对象的方法 之过滤结果:"); filter(heros, Hero::matched); } public boolean testHero(Hero h) { return 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); } } }
有的接口中的方法会返回一个对象,比如java.util.function.Supplier提供
了一个get方法,返回一个对象。

public interface Supplier<T> {
T get();
}

设计一个方法,参数是这个接口

public static List getList(Supplier<List> s){
return s.get();
}

为了调用这个方法,有3种方式
第一种匿名类:

Supplier<List> s = new Supplier<List>() {
public List get() {
return new ArrayList();
}
};
List list1 = getList(s);


第二种:Lambda表达式

List list2 = getList(()->new ArrayList());


第三种:引用构造器

List list3 = getList(ArrayList::new);
package lambda; import java.util.ArrayList; import java.util.List; import java.util.function.Supplier; public class TestLambda { public static void main(String[] args) { Supplier<List> s = new Supplier<List>() { public List get() { return new ArrayList(); } }; //匿名类 List list1 = getList(s); //Lambda表达式 List list2 = getList(()->new ArrayList()); //引用构造器 List list3 = getList(ArrayList::new); } public static List getList(Supplier<List> s){ return s.get(); } }
步骤 5 :

练习-引用静态方法

edit  姿势不对,事倍功半! 点击查看做练习的正确姿势
比较器-Comparator 章节中的代码,使用引用静态方法的方式来实现
步骤 6 :

答案-引用静态方法

edit
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
查看本答案会花费3个积分,您目前总共有点积分。查看相同答案不会花费额外积分。 积分增加办法 或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)
查看本答案会花费3个积分,您目前总共有点积分。查看相同答案不会花费额外积分。 积分增加办法 或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)
账号未激活 账号未激活,功能受限。 请点击激活
本视频是解读性视频,所以希望您已经看过了本答案的内容,带着疑问来观看,这样收获才多。 不建议一开始就观看视频

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


package collection; import java.util.ArrayList; import java.util.Collections; 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); Collections.sort(heros,(h1,h2)->TestCollection.compare(h1, h2)); Collections.sort(heros,TestCollection::compare); System.out.println(heros); } public static int compare(Hero h1, Hero h2){ return h1.hp>=h2.hp?1:-1; } }
步骤 7 :

练习-引用容器中的对象的方法

edit  姿势不对,事倍功半! 点击查看做练习的正确姿势
比较器-Comparator 章节中的代码,使用 引用容器中的对象的方法 的方式来实现。
提示: 为Hero提供一个compareHero方法
步骤 8 :

答案-引用容器中的对象的方法

edit
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
查看本答案会花费4个积分,您目前总共有点积分。查看相同答案不会花费额外积分。 积分增加办法 或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)
查看本答案会花费4个积分,您目前总共有点积分。查看相同答案不会花费额外积分。 积分增加办法 或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)
账号未激活 账号未激活,功能受限。 请点击激活
本视频是解读性视频,所以希望您已经看过了本答案的内容,带着疑问来观看,这样收获才多。 不建议一开始就观看视频

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


package charactor; public class Hero{ public String name; public float hp; public int damage; public String getName() { return name; } public void setName(String name) { this.name = name; } public float getHp() { return hp; } public void setHp(float hp) { this.hp = hp; } public int getDamage() { return damage; } public void setDamage(int damage) { this.damage = damage; } public Hero(){ } public Hero(String name) { this.name =name; } public boolean matched(){ return this.hp>100 && this.damage<50; } public Hero(String name,float hp, int damage) { this.name =name; this.hp = hp; this.damage = damage; } public int compareHero(Hero h){ return hp>=h.hp?-1:1; } public String toString() { return "Hero [name=" + name + ", hp=" + hp + ", damage=" + damage + "]\r\n"; } }
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 = (h1,h2)-> h1.compareHero(h2) ; Collections.sort(heros,c); Collections.sort(heros,Hero::compareHero); System.out.println(heros); } }
步骤 9 :

练习-引用构造器

edit  姿势不对,事倍功半! 点击查看做练习的正确姿势
比较ArrayList和LinkedList的区别这段代码,改造成引用构造器的模式。
目前的调用方式是:

List<Integer> l;
l = new ArrayList<>();
insertFirst(l, "ArrayList");

l = new LinkedList<>();
insertFirst(l, "LinkedList");


改造后的调用方式将变为:

insertFirst(ArrayList::new, "ArrayList");
insertFirst(LinkedList::new, "LinkedList");
package collection; import java.util.ArrayList; import java.util.LinkedList; import java.util.List; public class TestCollection { public static void main(String[] args) { List<Integer> l; l = new ArrayList<>(); insertFirst(l, "ArrayList"); l = new LinkedList<>(); insertFirst(l, "LinkedList"); } private static void insertFirst(List<Integer> l, String type) { int total = 1000 * 100; final int number = 5; long start = System.currentTimeMillis(); for (int i = 0; i < total; i++) { l.add(0, number); } long end = System.currentTimeMillis(); System.out.printf("在%s 最前面插入%d条数据,总共耗时 %d 毫秒 %n", type, total, end - start); } }
步骤 10 :

答案-引用构造器

edit
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
在查看答案前,尽量先自己完成,碰到问题再来查看答案,收获会更多
查看本答案会花费4个积分,您目前总共有点积分。查看相同答案不会花费额外积分。 积分增加办法 或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)
查看本答案会花费4个积分,您目前总共有点积分。查看相同答案不会花费额外积分。 积分增加办法 或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)
账号未激活 账号未激活,功能受限。 请点击激活
本视频是解读性视频,所以希望您已经看过了本答案的内容,带着疑问来观看,这样收获才多。 不建议一开始就观看视频

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


package collection; import java.util.ArrayList; import java.util.LinkedList; import java.util.List; import java.util.function.Supplier; public class TestCollection { public static void main(String[] args) { insertFirst(ArrayList::new, "ArrayList"); insertFirst(LinkedList::new, "LinkedList"); } private static void insertFirst(Supplier<List> s, String type) { int total = 1000 * 100; final int number = 5; long start = System.currentTimeMillis(); List list = s.get(); for (int i = 0; i < total; i++) { list.add(0, number); } long end = System.currentTimeMillis(); System.out.printf("在%s 最前面插入%d条数据,总共耗时 %d 毫秒 %n", type, total, end - start); } }


HOW2J公众号,关注后实时获知最新的教程和优惠活动,谢谢。


问答区域    
2021-07-27 引用构造器
莫諾




把比较ArrayList和LinkedList的区别这段代码,改造成引用构造器的模式。 目前的调用方式是: List<Integer> I; I = new ArrayList<>(); insertFirst(I, "ArrayList"); I = new LinkedList<>(); insertFirst(I, "LinkedList"); 改造后的调用方式将变为: insertFirst(ArrayList::new, "ArrayList"); insertFirst(LinkedList::new, "LinkedList");
public class TestCollection {
	
	public static void main(String[] args) {
		insertFirst(ArrayList::new, "ArrayList");
		insertFirst(LinkedList::new, "LinkedList");

	}
	
	private static void insertFirst(Supplier<List> s, String type) {
		// TODO 自动生成的方法存根
		int total = 1000 * 100;
		final int number = 10;
		if (type == "ArrayList") {
			ArrayList<Integer> l = (ArrayList<Integer>) s.get();
			long start = System.currentTimeMillis();
			for (int i = 0; i < total; i++) {
				l.add(0, number);
			}
			long end = System.currentTimeMillis();
			System.out.printf("在%s最前面插入%d条数据,总共耗时%d毫秒%n", type, total, end-start);
		}
		else {
			LinkedList<Integer> l = (LinkedList<Integer>) s.get();
			long start = System.currentTimeMillis();
			for (int i = 0; i < total; i++) {
				l.add(0, number);
			}
			long end = System.currentTimeMillis();
			System.out.printf("在%s最前面插入%d条数据,总共耗时%d毫秒%n", type, total, end-start);
		}
		
	}

							





回答已经提交成功,正在审核。 请于 我的回答 处查看回答记录,谢谢
答案 或者 代码至少填写一项, 如果是自己有问题,请重新提问,否则站长有可能看不到





2021-07-27 引用容器中的对象方法
莫諾




把比较器 - Comparator章节中的代码,使用引用静态方法的方式来实现 提示: 为Hero提供一个compareHero方法 总结: 引用容器中的对象,使用?:: method()句式,?需是方法所属类的实例对象。
//Hero add new method
public int compareHero(*,*) {
        if(h1.hp >= h2.hp)
            return 1;  
        else
            return -1;
}
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);
            
        
//        Collections.sort(heros,(h1,h2) -> (h1.hp >= h2.hp)? 1 : -1);
        Hero h = new Hero();
        Collections.sort(heros, *::compareHero);
        System.out.println("按照血量排序后的集合:");
        System.out.println(heros);

    }

							





回答已经提交成功,正在审核。 请于 我的回答 处查看回答记录,谢谢
答案 或者 代码至少填写一项, 如果是自己有问题,请重新提问,否则站长有可能看不到





2021-07-27 练习-引用静态方法
2021-04-22 引用容器中对象方法时疑惑
2021-04-10 List<Hero>容器的对象为什么是Hero


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

提问之前请登陆
提问已经提交成功,正在审核。 请于 我的提问 处查看提问记录,谢谢
关于 JAVA 中级-Lambda-方法引用 的提问

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

上传截图