【Java学习笔记】Lambda

→教程网站

1 筛选特定对象

1.1 使用匿名类方法

创建接口HeroChecker，包含test方法

package lambda;

import charactor.Hero;

public interface HeroChecker {

    public boolean test(Hero h);

}

通过匿名类方法实现该接口

package lambda;

import charactor.Hero;

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

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(100),r.nextInt(100)));
        }
        System.out.println(heros);

        //使用匿名类方法筛选特定条件的Hero
        HeroChecker checker = new HeroChecker() {
            @Override
            public boolean test(Hero h) {
                return (h.hp>50&&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.println(hero);
        }
    }
}

1.2 Lambda方法

直接把表达式传入filter

package lambda;

import charactor.Hero;

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

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(100),r.nextInt(100)));
        }
        System.out.println(heros);


        filter(heros,h-> h.damage>50&&h.hp<50);
    }
    private static void filter(List<Hero> heros,HeroChecker checker){
        for(Hero hero:heros){
            if(checker.test(hero))
                System.out.println(hero);
        }
    }
}

1.3比较

Lambda的方法代码简洁，但可读性较差，适合用于较简短的程序中

2 方法引用

2.1 引用静态方法

package lambda;

import charactor.Hero;

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

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(100),r.nextInt(100)));
        }
        System.out.println("heros集合：");
        System.out.println(heros);

        //在Lambda表达式中使用静态方法
        System.out.println("在Lambda表达式中使用静态方法");
        filter(heros,h->TestLambda.testHero(h));
        System.out.println("直接引用静态方法");
        //直接引用静态方法
        filter(heros,TestLambda::testHero);

    }

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

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

2.2 引用对象方法

引用对象方法前需要实例化对象，调用实例化对象的对象方法

package lambda;

import charactor.Hero;

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

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(100),r.nextInt(100)));
        }
        System.out.println("heros集合：");
        System.out.println(heros);



        //引用对象方法，需要有实例化对象存在
        TestLambda testLambda = new TestLambda();

        System.out.println("直接引用对象方法");
        filter(heros,testLambda::testHero);

        System.out.println("在Lambda中引用对象方法");
        filter(heros,h99->testLambda.testHero(h99));

    }

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

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

2.3 引用容器中对象的方法

在Hero中添加matched方法

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

package lambda;

import charactor.Hero;

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

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(100),r.nextInt(100)));
        }
        System.out.println("heros集合：");
        System.out.println(heros);

        System.out.println("在Lambda中引用容器中的对象方法");
        filter(heros,h99->h99.matched());

    }

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

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

3 聚合操作

package lambda;

import charactor.Hero;

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

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(100), r.nextInt(100)));
        }
        System.out.println("heros集合：");
        System.out.println(heros);

        System.out.println("通过聚合操作方式找出满足条件的数据：");
        heros
                .stream()
                .filter(h -> h.hp > 50 && h.damage < 50)
                .forEach(h -> System.out.println(h));
    }

}