Java13-Lambda

最新推荐文章于 2023-06-09 00:15:44 发布
最新推荐文章于 2023-06-09 00:15:44 发布
阅读量169 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40893824/article/details/110431227
版权

https://www.nowcoder.com/tutorial/94/ae05554a3ad84e42b6f9fc4d52859dc4

https://how2j.cn/frontroute
https://how2j.cn/k/lambda/lambda-lamdba-tutorials/697.html

目录

1 引子

lambda 用处：找出某个特征的对象
参见：
https://blog.csdn.net/weixin_40839731/article/details/79594897

1.1 普通方法

用 for 进行逐一判断

1.2 匿名类方式

匿名类：
业务方法代码肯定是有的
就是没有自己名字

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

完整代码：

package 第17个程序_Lambda.a1_匿名类方式查找;

public class Hero {
    String name;
    float hp; //血量
    float armor; //护甲
    int moveSprrd; //速度

    public Hero(String name, float hp, float armor){
        this.name = name;
        this.hp = hp;
        this.armor = armor;
    }
}

package 第17个程序_Lambda.a1_引子.s1_匿名类方式查找;

import java.util.LinkedList;
import java.util.List;
import java.util.Random;

public class test {
    public static void main(String[] args) {
        Random r = new Random();
        List<Hero> list = new LinkedList<>();
        for (int i = 0; i < 5; i++)
            list.add(new Hero("hero " + r.nextInt(100), r.nextInt(1000), r.nextInt(100)));
        print(list);
        System.out.println("\n匿名类筛选 hp>100 armor <50 的英雄");

        HeroChecker heroChecker = new HeroChecker() {
            @Override
            public boolean test(Hero hero) {
                return (hero.hp > 100 && hero.armor < 50);
            }
        };
        filter(list, heroChecker);
    }

    public static void filter(List<Hero> list, HeroChecker heroChecker){
        int flag = 0;
        for (Hero hero: list){
            if (heroChecker.test(hero)){
                System.out.println(hero.name + " " + hero.hp + " " + hero.armor);
                flag++;
            }
        }
        if (flag == 0)
            System.out.println("无！");
    }

    public static void print(List<Hero> list){
        System.out.println("输出:");
        for (Hero hero:list){
            System.out.println(hero.name + " " + hero.hp + " " + hero.armor);
        }
    }
}

1.3 Lambda

filter(list, hero -> hero.hp>100 && hero.armor<50);
完整代码：

    package 第17个程序_Lambda.a1_引子.s2_Lambda;
    
    public class Hero {
        String name;
        float hp; //血量
        float armor; //护甲
        int moveSprrd; //速度
    
        public Hero(String name, float hp, float armor){
            this.name = name;
            this.hp = hp;
            this.armor = armor;
        }
    }

package 第17个程序_Lambda.a1_引子.s2_Lambda;

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

package 第17个程序_Lambda.a1_引子.s2_Lambda;

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

public class test {
    public static void main(String[] args) {
        Random r = new Random();
        List<Hero> list = new ArrayList<>();
        for (int i = 0; i < 5; i++){
            list.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100)));
        }
        print(list);

        System.out.println("用 filter 方式, 查找 hp>100 armor <50 的英雄:");
        filter(list, hero -> hero.hp>100 && hero.armor<50);
    }

    public static void filter(List<Hero> list, HeroChecker heroChecker){
        int flag = 0;
        for(Hero hero:list){
            if(heroChecker.test(hero)){
                System.out.println(hero.name + " " + hero.hp + " " + hero.armor);
                flag++;
            }
        }
        if (flag == 0)
            System.out.println("无！");
    }

    public static void print(List<Hero> list){
        System.out.println("输出:");
        for (Hero hero:list){
            System.out.println(hero.name + " " + hero.hp + " " + hero.armor);
        }
        System.out.println();
    }
}

1.3.1 弊端

可读性差
不便调试
JDK8 以上支持

1.4 练习

把比较器-Comparator 的代码改为 Lambda 表达式

package 第17个程序_Lambda.a1_引子.s2_Lambda.练习;

public class Hero {
    public String name;
    public float hp;
    public int damage;

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

    public String toString() {
        return "Hero [name=" + name + ", hp=" + hp + ", damage=" + damage + "]\r\n";
    }

    public Hero(String name, int hp, int damage) {
        this.name = name;
        this.hp = hp;
        this.damage = damage;
    }
}

package 第17个程序_Lambda.a1_引子.s2_Lambda.练习;

import java.util.*;

public class test {
    public static void main(String[] args) {
        Random random = new Random();
        List<Hero> heroes = new ArrayList<>();
        for (int i = 0; i < 5; i++){
            heroes.add(new Hero("hero " + i, random.nextInt(100), random.nextInt(100)) );
        }
        System.out.println("初始化后: ");
        print(heroes);

        /*
        直接 Collections.sort(heros); 会报错，因为排序标准不知道!
        */
        System.out.printf("尝试排序... ");
        Collections.sort(heroes, (x,y) -> x.hp>y.hp ? 1:(x.hp == y.hp ? (x.damage>y.damage?1:-1):-1) );
        System.out.println("成功!");
        print(heroes);
    }

    public static void print(List<Hero> list){
        System.out.println("输出:");
        for (Hero hero:list){
            System.out.println(hero.name + " " + hero.hp + " " + hero.damage);
        }
        System.out.println();
    }
}

2 方法引用

2.1 引用 静态方法

package 第17个程序_Lambda.a2_方法引用.s1_引用静态方法;

public class Hero {
    String name;
    float hp; //血量
    float armor; //护甲
    int moveSprrd; //速度

    public Hero(String name, float hp, float armor){
        this.name = name;
        this.hp = hp;
        this.armor = armor;
    }
}

package 第17个程序_Lambda.a2_方法引用.s1_引用静态方法;

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

package 第17个程序_Lambda.a2_方法引用.s1_引用静态方法;

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

public class test {
    public static void main(String[] args) {
        Random r = new Random();
        List<Hero> list = new ArrayList<>();
        for (int i = 0; i < 5; i++){
            list.add(new Hero("hero " + i,r.nextInt(1000), r.nextInt(100)));
        }
        print(list);

        HeroChecker c = new HeroChecker() {
            @Override
            public boolean test(Hero hero) {
                return (hero.hp>100 && hero.armor<50);
            }
        };

        System.out.println("用匿名类过滤");
        filter(list,c);

        System.out.println("\n用 Lambda 过滤");
        filter(list, hero -> (hero.hp>100 && hero.armor<50) );

        // 静态方法
        System.out.println("\n在 Lambda 中引用静态方法");
        filter(list, hero -> (test.testHero(hero)));

        System.out.println("\n直接引用静态方法");
        filter(list, test::testHero);
    }

    private static void filter(List<Hero> list, HeroChecker heroChecker){
        int flag = 0;
        for (Hero hero:list){
            if (heroChecker.test(hero)){
                System.out.println(hero.name + " " + hero.hp + " " + hero.armor);
                flag++;
            }
        }
        if (flag == 0)
            System.out.println("无!");
    }

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

    public static void print(List<Hero> list){
        System.out.println("输出:");
        for (Hero hero:list){
            System.out.println(hero.name + " " + hero.hp + " " + hero.armor);
        }
        System.out.println();
    }
}

2.2 引用 对象方法

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

完整代码：

package 第17个程序_Lambda.a2_方法引用.s2_引用对象方法;

public class Hero {
    String name;
    float hp; //血量
    float armor; //护甲
    int moveSprrd; //速度

    public Hero(String name, float hp, float armor){
        this.name = name;
        this.hp = hp;
        this.armor = armor;
    }
}

package 第17个程序_Lambda.a2_方法引用.s2_引用对象方法;

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

package 第17个程序_Lambda.a2_方法引用.s2_引用对象方法;

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

public class test {
    public static void main(String[] args) {
        Random r = new Random();
        List<Hero> list = new ArrayList<>();
        for (int i = 0; i < 5; i++){
            list.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100)));
        }
        print(list);

        System.out.println("引用对象方法过滤结果:");
        test t = new test();
        filter(list, test::testHero);
    }

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

    private static void filter(List<Hero> list, HeroChecker heroChecker){
        int flag = 0;
        for (Hero hero: list){
            if (heroChecker.test(hero)){
                System.out.printf(hero.name + " " + hero.hp + " " + hero.armor + " \t");
                flag++;
            }
        }
        if (flag == 0)
            System.out.println("无!");
    }

    public static void print(List<Hero> list){
        System.out.println("输出:");
        for (Hero hero:list){
            System.out.printf(hero.name + " " + hero.hp + " " + hero.armor + " \t");
        }
        System.out.println();
    }
}

2.3 引用 容器中的对象方法

Hero 中加方法：

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

Lambda 表达式：
filter(heros,h-> h.hp>100 && h.damage<50 );
=filter(heros,h-> h.matched() );
= filter(heros, Hero::matched);

完整代码:：

package 第17个程序_Lambda.a2_方法引用.s3_引用容器中对象的方法;

public class Hero {
    String name;
    float hp; //血量
    float armor; //护甲
    int moveSprrd; //速度

    public Hero(String name, float hp, float armor){
        this.name = name;
        this.hp = hp;
        this.armor = armor;
    }

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

package 第17个程序_Lambda.a2_方法引用.s3_引用容器中对象的方法;

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

package 第17个程序_Lambda.a2_方法引用.s3_引用容器中对象的方法;

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

public class test {
    public static void main(String[] args) {
        Random r = new Random();
        List<Hero> list = new ArrayList<>();
        for (int i = 0; i < 5; i++){
            list.add(new Hero("hero " + i, r.nextInt(1000), r.nextInt(100)));
        }
        print(list);

//        System.out.println("Lambda 表达式过滤:");
//        filter(list, hero -> (hero.hp>100 && hero.armor<50) );

//        System.out.println("Lambda 调用容器中 对象的 matched 过滤:");
//        filter(list, hero -> hero.matched());

        System.out.println("引用容器中对象的方法 过滤结果");
        filter(list, Hero::matched);

    }

    private static void filter(List<Hero> list, HeroChecker heroChecker){
        int flag = 0;
        for (Hero hero: list){
            if (heroChecker.test(hero)){
                System.out.printf(hero.name + " " + hero.hp + " " + hero.armor + " \t");
                flag++;
            }
        }
        if (flag == 0)
            System.out.println("无!");
    }

    public static void print(List<Hero> list){
        System.out.println("输出:");
        for (Hero hero:list){
            System.out.printf(hero.name + " " + hero.hp + " " + hero.armor + " \t");
        }
        System.out.println();
    }
}

2.4 引用 构造器

package 第17个程序_Lambda.a2_方法引用.s4_引用构造器;

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

package 第17个程序_Lambda.a2_方法引用.s4_引用构造器;

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

public class test {
    public static void main(String[] args) {
        Supplier<List> supplier = new Supplier<List>() {
            @Override
            public List get() {
                return new ArrayList();
            }
        };

        // 匿名类
        List list1 = getList(supplier);

        //Lambda 表达式
        List list2 = getList( () -> new ArrayList());

        // 引用构造器
        List list3 = getList( ArrayList::new );
    }
    public static List getList(Supplier<List> supplier){
        return supplier.get();
    }
}

2.5 练习1

比较器 - Comparator 代码
【引用静态方法】实现
【引用容器中的对象方法】实现

package 第17个程序_Lambda.a2_方法引用.练习1;

public class Hero {
    public String name;
    public float hp;
    public int damage;

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

    public String toString() {
        return "Hero [name=" + name + ", hp=" + hp + ", damage=" + damage + "]\r\n";
    }

    public Hero(String name, int hp, int damage) {
        this.name = name;
        this.hp = hp;
        this.damage = damage;
    }

    public static int matched(Hero hero1, Hero hero2){
        return (hero1.hp>hero2.hp ? 1:-1);
    }
}

package 第17个程序_Lambda.a2_方法引用.s3_引用容器中对象的方法;

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

package 第17个程序_Lambda.a2_方法引用.练习1;

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

public class test {
    public static void main(String[] args) {
        Random random = new Random();
        List<Hero> heroes = new ArrayList<>();
        for (int i = 0; i < 5; i++){
            heroes.add(new Hero("hero " + i, random.nextInt(1000), random.nextInt(100)) );
        }
        System.out.println("初始化后: ");
        System.out.println(heroes);

//        System.out.println("尝试排序... ");
//        System.out.println("Lambda 引用静态方法");
//        Collections.sort(heroes, (hero1, hero2) -> (test.compare(hero1, hero2)) );
//        System.out.println("成功!");
//        System.out.println(heroes);

//        System.out.println("直接引用静态方法");
//        Collections.sort(heroes, test::compare);
//        System.out.println("成功!");
//        System.out.println(heroes);

        System.out.println("引用容器中对象方法:");
        Collections.sort(heroes, Hero::matched);
        System.out.println(heroes);
    }

    public static int compare(Hero hero1, Hero hero2){
        return hero1.hp>hero2.hp ? 1:-1;
    }
}

2.6 练习2

见下面代码，将其改成构造器模式
原：

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

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

目标：

	insertFirst(ArrayList::new, "ArrayList");
    insertFirst(LinkedList::new, "LinkedList");

原代码：

package 第17个程序_Lambda.a2_方法引用.练习2;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class src {
    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);
    }
}

答案：

package 第17个程序_Lambda.a2_方法引用.练习2;

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

package 第17个程序_Lambda.a2_方法引用.练习2;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class test {
    public static void main(String[] args) {
        List<Integer> l;
        l = new ArrayList<>();
        insertFirst(ArrayList::new, "ArrayList");

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

    }

    private static void insertFirst(Supplier<List> supplier , String type) {
        int total = 1000 * 100;
        final int number = 5;
        long start = System.currentTimeMillis();
        List list = supplier.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);
    }
}

3 聚合操作

传统方法：

for (Hero h : heros) {
   if (h.hp > 100 && h.damage < 50)
      System.out.println(h.name);
}

聚合：

heros
	.stream()
	.filter(h -> h.hp > 100 && h.damage < 50)
	.forEach(h -> System.out.println(h.name));

3.1 简单程序

管道源是 集合 和 数组
对应操作不同

package 第17个程序_Lambda.a3_聚合操作.s1_简单程序;

public class Hero {
    String name;
    float hp; //血量
    float armor; //护甲
    int moveSprrd; //速度

    public Hero(String name, float hp, float armor){
        this.name = name;
        this.hp = hp;
        this.armor = armor;
    }

    public String toString() {
        return "Hero [name=" + name + ", hp=" + hp + ", damage=" + armor + "]\r";
    }
}

package 第17个程序_Lambda.a3_聚合操作.s1_简单程序;

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

public class test {
    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("输出:");
        for (Hero h : heros){
            System.out.println("Hero [name=" + h.name + ", hp=" + h.hp + ", damage=" + h.armor + "]\r");
        }

        // 管道源是集合
        System.out.println("\n管道源是集合");
        heros
            .stream()
            .forEach(hero -> System.out.println(hero) );

        // 管道源是数组
        System.out.println("\n管道源是数组");
        Hero[] heroes1 = heros.toArray(new Hero[heros.size()]);
        Arrays
            .stream(heroes1)
            .forEach(hero -> System.out.println(hero));

    }
}

3.2 中间操作

对元素进行筛选：
filter 匹配
distinct 去除重复(根据equals判断)
sorted 自然排序
sorted(Comparator) 指定排序
limit 保留
skip 忽略

package 第17个程序_Lambda.a3_聚合操作.s2_中间操作;

public class Hero implements Comparable<Hero>{
    public String name;
    public float hp;
    public int damage;

    public Hero(){}

    public Hero(String name, float hp, int damage){
        this.name = name;
        this.hp = hp;
        this.damage = 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 String toString(){
        return "Hero [ name = " + name + ", hp = " + hp + ", damage = " + damage + " ]" ;
    }

    @Override
    public int compareTo(Hero o) {
        if (o.damage > damage)
            return 1;
        else
            return -1;
    }
}

package 第17个程序_Lambda.a3_聚合操作.s2_中间操作;

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

public class test {
    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)));
        }
        heros.add(heros.get(0));// 首末元素重复，故意
        for (Hero h : heros){
            System.out.println("Hero [ name = " + h.name + ", hp = " + h.hp + ", damage = " + h.damage + " ]");
        }

        System.out.println("\nhp>100 && damage<50 的数据:");
        heros
            .stream()
            .filter(hero -> (hero.hp>100 && hero.damage<50) )
            .forEach(hero -> System.out.println(hero.toString()) );

        System.out.println("\n去除重复的数据:");
        heros
            .stream()
            .distinct()
            .forEach(hero -> System.out.println(hero.toString()) );

        System.out.println("\n按血量排序:");
        heros
            .stream()
            .sorted( (hero1, hero2) -> hero1.hp > hero2.hp ? 1:-1 )
            .forEach(hero -> System.out.println(hero.toString()) );

        System.out.println("\n保留前3个:");
        heros
            .stream()
            .limit(3)
            .forEach(hero -> System.out.println(hero.toString()) );

        System.out.println("\n忽略前3个:");
        heros
            .stream()
            .skip(3)
            .forEach(hero -> System.out.println(hero.toString()) );

        System.out.println("\n转为 double 的 Stream");
        heros
                .stream()
                .mapToDouble(Hero::getHp)
                .forEach(hero -> System.out.println(hero) );

        System.out.println("\n转为任意类型的 Stream");
        heros
                .stream()
                .map( hero -> hero.name + " - " + hero.hp + " - " + hero.damage)
                .forEach(hero -> System.out.println(hero) );
    }
}



3.3 结束操作

forEach() 遍历每个元素
toArray() 转换为数组
min(Comparator) 取最小的元素
max(Comparator) 取最大的元素
count() 总数
findFirst() 第一个元素

package 第17个程序_Lambda.a3_聚合操作.s3_结束操作;

public class Hero implements Comparable<Hero>{
    public String name;
    public float hp;
    public int damage;

    public Hero(){}

    public Hero(String name, float hp, int damage){
        this.name = name;
        this.hp = hp;
        this.damage = 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 String toString(){
        return "Hero [ name = " + name + ", hp = " + hp + ", damage = " + damage + " ]" ;
    }

    @Override
    public int compareTo(Hero o) {
        if (o.damage > damage)
            return 1;
        else
            return -1;
    }
}

package 第17个程序_Lambda.a3_聚合操作.s3_结束操作;

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

public class test {
    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("遍历每一个元素:");
        heros
            .stream()
            .forEach(hero -> System.out.println(hero.toString()) );

        System.out.println("\n返回数组:");
        Object[] hs = heros
                .stream()
                .toArray();
        System.out.println(hs.toString());

        System.out.println("\n返回伤害最低的英雄:");
        Hero minDamage = heros
                .stream()
                .min( (hero1, hero2)->hero1.damage - hero2.damage )
                .get();
        System.out.println(minDamage.toString());

        System.out.println("\n返回伤害最高的英雄:");
        Hero maxDamage = heros
                .stream()
                .max( (hero1, hero2)->hero1.damage - hero2.damage )
                .get();
        System.out.println(maxDamage.toString());

        System.out.println("\n流中数据总数:");
        long count = heros
                .stream()
                .count();
        System.out.println(count + "个");

        System.out.println("\n第一个英雄:");
        Hero firstHero = heros
                .stream()
                .findFirst()
                .get();
        System.out.println(firstHero.toString());
    }
}

3.4 练习

准备 10 个随机 Hero
用 传统方式、聚合操作，把 hp 第 3 高的英雄名称打印出来

package 第17个程序_Lambda.a3_聚合操作.练习;

public class Hero implements Comparable<Hero>{
    public String name;
    public float hp;
    public int damage;

    public Hero(){}

    public Hero(String name, float hp, int damage){
        this.name = name;
        this.hp = hp;
        this.damage = 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 String toString(){
        return "Hero [ name = " + name + ", hp = " + hp + ", damage = " + damage + " ]" ;
    }

    @Override
    public int compareTo(Hero o) {
        if (o.damage > damage)
            return 1;
        else
            return -1;
    }
}

package 第17个程序_Lambda.a3_聚合操作.练习;

import 第17个程序_Lambda.a3_聚合操作.s3_结束操作.Hero;

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

public class test {
    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)));
        }
        heros.add(heros.get(0));// 故意加一个重复的元素

        System.out.println("传统方式找第3高hp:");
        Collections.sort(heros, (hero1, hero2)->hero1.hp>hero2.hp?-1:1 );// 降序
        System.out.println(heros.get(2).toString());


        System.out.println("\n去重遍历:");
        heros
            .stream()
            .distinct()
            .sorted((hero1, hero2)->hero1.hp>hero2.hp?-1:1)
            .forEach(hero -> System.out.println("Hero [ name = " + hero.name + ", hp = " + hero.hp + ", damage = " + hero.damage + " ]"));
        System.out.println("\n聚合方式找第3高的hp:");
        Hero hero3 = heros
                .stream()
                .sorted((hero1, hero2)->hero1.hp>hero2.hp?-1:+1)
                .skip(2) // 忽略前7个...
                .findFirst()
                .get();
        System.out.println(hero3.toString());
    }
}

qq_1403034144
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java - Lambda的使用
旧时言的博客
03-06 3333
Lambda表达式 1背景 Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda表达式（Lambda expression）可以看作是一个匿名函数，基于数学中的λ演算得名，也可称为闭包（Closure）。 1.1 Lambda表达式的语法 基本语法: (parameters) -> expression或
java8-lambda-utils
05-11
有用的东西 加入 合并类似于sql joins的集合 SortedListJoiner 合并两个排序的列表（类型为T和U）并生成类型为R的列表，其中通过将组合器应用于T和U的实例来创建项目 fullOuterJoin：包括两个列表的所有元素，缺少...
Java - Lambda 表达式
最新发布
Erzbir的博客
06-09 1300
Java Lambda 表达式笔记
Java -- Lambda表达式；函数式接口
MinggeQingchun的博客
11-25 1120
Lambda 表达式，也可称为闭包，它是Java 8 发布的最重要新特性Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。Lambda 表达式（Lambda expression）可以看作是一个匿名函数，基于数学中的λ演算得名，也可称为闭包（Closure）
Java8 -- Lambda表达式
Java小皮孩
01-22 2906
Java8 – Lambda表达式介绍 Lambda表达式，也可以称为闭包。Lambda允许把函数作为一个方法的参数传递进方法中使用。 Lambda表达式的使用前提是：接口中只能有一个方法，否则编译报错 Multiple non-overriding abstract methods found in interface：在接口中找到多个非重写的抽象方法 完整的Lambda表达式由三部分组成：1. 参数列表 ； 2. 箭头(->) ； 3. 声明语句 (+ 返回语句) (Type param1, Ty
java---lambda函数
Yoke______的博客
01-16 1410
背景 lambda 表达式是一个可传递的代码块 ， 可以在以后执行一次或多次。就类似于sort（arrs,comparator）函数在排列结束之前会不停调用comparator代码块，在java中传递一个代码段并不容易 ， 不能直接传递代码段Java 是一种面向对象语言，所以必须构造一个对象 ， 这个对象的类需要有一个方法能包含所需的代码 。于是lambda应运而生。 lambda 表达式的语法 ( String first , String second )- > ...
java基础-lambda表达式
xuruhua的博客
09-10 801
一、java8新特性 1、java8新特性 二、lambda表达式 1、使用举例 2、lambda表达式语法的使用1 (1)举例:(o1,o2) -> Integer.compare(o1,o2); (2)格式: ->:lambda操作符或箭头操作符 ->左边:lambda形参列表 (其实就是接口中的抽象方法的形参列表) ->右边:lambda体 (其实就是重写的抽象方法的方法体) (3)lambda表达式的使用:(分为6种情况去介绍) a、无参..
JAVA--Lambda表达式和set接口
m0_56161893的博客
03-14 2948
一、Lambda表达式 Lambda是JAVA 8添加的新特性，可以看成是一个匿名函数 使用Lambda表达式可以对一个接口的方法进行非常简洁的实现 要求接口中定义的必须要实现的抽象方法只能是一个 可以使用default对接口方法进行修饰，被修饰的方法在接口中可以默认实现 @FunctionalInterface 修饰函数式接口的，接口中的抽象方法只有一个 1 2 3 4 @FunctionalInterf...
java1.8新特性--lambda表达式
weixin_43766390的博客
07-20 2019
快速将一个Lambda表达式的实现指向一个已经写好的方法方法引用可以看作是lambda表达式的特殊形式，或者称之为语法糖。一般方法已经存在才可以使用方法引用，而方法若未存在，则只能使用lambda表达式。......
java--Lambda （3）变量的访问
程序员大腾的博客
11-22 713
学习使用在Lambda表达式，有些地方访问一些变量访问不到，有些地方可以访问却不能改变，有些地方既可以访问还可以修改实用，所以记录一下。
Java8 特性 -- Lambda 详解
l10711097061的博客
11-21 2952
Java8 特性 -- Lambda 详解
java-lambda-stream
03-13
java-lambda-stream
java8集合源码-poc-java8-lambda-stream-rxjava:poc-java8-lambda-stream-rxjava
06-04
java8集合源码java8 lambda 流 rxjava 在 Java 8 版本中，Java 提供了对函数式编程、新的 JavaScript 引擎、用于日期时间操作的新 API、新的流 API 等的支持。 新的功能： Lambda 表达式 向 Java 添加函数处理能力。...
java8-lambda表达式的基础使用.pdf
07-05
java8-lambda表达式的基础使用.pdf
aws-lambda-java8-dynamodb
04-30
具有Java 8，AWS Lambda和Amazon DynamoDB的无服务器架构在一个常见用例的上下文中，此代码库是使用Java 8运行时为AWS Lambda构建的示例API：由Amazon DynamoDB支持作为其数据存储的API。 在生产部署中，您将使用...
Java03-命名规范/ 注释/ 排版(换行、空格)
qq_1403034144的博客
01-15 1081
1. 命名规范 名字一般是两个单词的组合 驼峰命名： 大驼峰 vs 小驼峰 大驼峰：两个单词首字母大写，如ClassRoom 小驼峰：仅第二个单词首字母大写，如classRoom 包名、类名、接口名、变量、常量均使用大驼峰 2. 注释 2.1 //单行注释，快捷键：ctrl + / 或 Ctrl + shift + C，相同操作取消注释 2.2 /* … */多行注释，快捷键：ctrl + shi...
java什么时候用try
qq_1403034144的博客
11-03 842
try { 程序运行成功时执行 } catch { 异常时执行 } finally { 总要执行 } 程序要打开资源，使用完后要关闭的情况下，要使用 try-catch！ 网络连接，即使程序一点错也没有，但网络有可能有不稳定，不知道什么地方会出现错误，要 try…catch 一下 文件、io 也一样，都可能产生不可预料的错误，要try…catch 具体： 代码执行预料不到的情况，用 try-catch a除以b，但 b 是变量，如果b等于0程序就会出错，用 try-ca
Java02-标识符/ 关键字、数据类型/ 分隔符/ 常量final/ 运算符
qq_1403034144的博客
01-15 825
1. 标识符，给变量起名 a. 区分大小写 b. _/ $/ 字母/ 数字，数字不可在首位 c. 关键字不可作为标识符 2. 关键字 关键字全是小写的！ 数据类型：boolean、byte、char、 double、 false、float、int、long、new、short、true、void、instanceof 语句：break、case、 catch、 continue、 defaul...
Java11-集合框架
qq_1403034144的博客
11-27 608
https://www.nowcoder.com/tutorial/94/ae05554a3ad84e42b6f9fc4d52859dc4 https://how2j.cn/frontroute https://how2j.cn/k/collection/collection-arraylist/363.html 目录ArrayList集合框架和数组常用方法其他集合关系与区别其他 ArrayList 集合框架和数组 数组的局限性： 声明长度是 10 的数组 不用的数组浪费了 超过 10 又放不下… 为解决数
java: -source 1.5 中不支持 lambda 表达式
04-29
Lambda 表达式是一种 Java 8 引入的新特性，它提供了一种简洁的方式来编写匿名函数，从而简化了编写代码的工作量。然而，在使用 Java 编译器时，如果将源代码指定为“-source 1.5”时，将无法使用 Lambda 表达式。 这是因为在 Java 8 之前的版本中，Java 编译器并没有实现 Lambda 表达式。因此，如果您想要在 Java 8 之前的版本中使用 Lambda 表达式，您需要升级您的 Java 环境并将源代码设为 Java 8 或更高版本。 如果您正在使用 Java 8 或更高版本，则无需担心。只需将源代码设为 Java 8 或更高版本即可轻松使用 Lambda 表达式。例如，您可以使用以下命令来编译一个使用 Lambda 表达式的 Java 文件： javac -source 1.8 MyClass.java 总之，Java 8 引入了 Lambda 表达式这一新特性，使得编写代码变得更加简单和高效。然而，在更新版本之前，您需要确保您使用的 Java 环境支持 Lambda 表达式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

qq_1403034144

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

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

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

打赏作者

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

抵扣说明：

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

余额充值