java_lambda表达式

场景：找出满足条件的Hero，从普通方法，匿名类，以及Lambda这几种方式展开：

1.普通方法：

使用一个普通方法，在for循环遍历中进行条件判断，筛选出满足条件的数据：hp > 100 && damage < 50

Hero类：

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 +
                '}';
    }
}

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("初始化后的集合：");
        for (Hero hero: heros) {
            System.out.println(hero);
        }
        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.println(hero);
            }
        }
    }
}

2.匿名类方法：

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

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

HeroChecker 接口：

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

TestLambda 类：

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);
        }
    }
   
}

3.Lambda方式：

使用Lambda方式筛选出数据：filter(heros, (h)->h.hp>100 && h.damage<50);

同样是调用filter方法，从上一步的传递匿名类对象，变成了传递一个Lambda表达式进去：h->h.hp>100 && h.damage<50;

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.从匿名类演变成Lambda表达式：

 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);