How2j学习记录 Lambda

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

知识点1:Lambda引入

1.普通方法

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

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 && damage<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;
    }

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

    public int compareTo(Hero anotherHero) {
        if (damage < anotherHero.damage)
            return 1;
        else
            return -1;
    }

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

}

2.匿名类方式

package lambda;

import charactor.Hero;

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

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 && damage<50的英雄");
        HeroChecker checker = new HeroChecker() {
            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方式

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("使用Lambda的方式，筛选出 hp>100 && damage<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表达式

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("使用Lambda的方式，筛选出 hp>100 && damage<50的英雄");
        HeroChecker c4 = h -> h.hp > 100 && h.damage < 50;
        filter(heros, c4);
    }

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

5.Lambda的弊端

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

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

知识点2:Lambda方法引用

1.引用静态方法

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);
        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, s -> s.hp > 100 && s.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.引用对象方法

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("使用引用对象方法的过滤结果:");
        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. 引用容器中的对象的方法

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

4.引用构造器

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++) {
            // 通过随机值实例化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) -> TestCollection.compare(h1, h2));
        Collections.sort(heros, TestCollection::compare);

        System.out.println("按照血量排序后的集合：");

        System.out.println(heros);
    }

    public static int compare(Hero h1, Hero h2) {
        return h1.hp >= h2.hp ? 1 : -1;
    }
}

知识点3:JAVA集合的聚合操作

1.传统方式与聚合操作方式遍历数据

package lambda;

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

import charactor.Hero;

public class TestAggregate {
    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&&damage<50");
        System.out.println("通过传统操作方式找出满足条件的数据：");

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

2.Stream和管道的概念

要了解聚合操作，首先要建立Stream和管道的概念
Stream 和Collection结构化的数据不一样，Stream是一系列的元素，就像是生产线上的罐头一样，一串串的出来。
管道指的是一系列的聚合操作。

管道又分3个部分
管道源：在这个例子里，源是一个List
中间操作： 每个中间操作，又会返回一个Stream，比如.filter()又返回一个Stream, 中间操作是“懒”操作，并不会真正进行遍历。
结束操作：当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。 结束操作不会返回Stream，但是会返回int、float、String、 Collection或者像forEach，什么都不返回, 结束操作才进行真正的遍历行为，在遍历的时候，才会去进行中间操作的相关判断

注： 这个Stream和I/O章节的InputStream,OutputStream是不一样的概念。

3.管道源

把Collection切换成管道源很简单，调用stream()就行了。

heros.stream()

但是数组却没有stream()方法，需要使用

Arrays.stream(hs)

或者

Stream.of(hs)

package lambda;

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

import charactor.Hero;

public class TestAggregate {
    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.stream().filter(h -> h.hp > 100 && h.damage < 50).forEach(h -> System.out.println(h.name));

        Hero hs[] = heros.toArray(new Hero[heros.size()]);
        Arrays.stream(hs).forEach(h -> System.out.println(h.name));
    }
}

4.中间操作

每个中间操作，又会返回一个Stream，比如.filter()又返回一个Stream, 中间操作是“懒”操作，并不会真正进行遍历。
中间操作比较多，主要分两类
对元素进行筛选 和 转换为其他形式的流
对元素进行筛选：
filter 匹配
distinct 去除重复(根据equals判断)
sorted 自然排序
sorted(Comparator<T>) 指定排序
limit 保留
skip 忽略
转换为其他形式的流
mapToDouble 转换为double的流
map 转换为任意类型的流

package lambda;

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

import charactor.Hero;

public class TestAggregate {

    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));
        System.out.println("初始化集合后的数据 (最后一个数据重复)：");
        System.out.println(heros);
        System.out.println("满足条件hp>100&&damage<50的数据");

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

        System.out.println("去除重复的数据，去除标准是看equals");
        heros.stream().distinct().forEach(h -> System.out.print(h));
        System.out.println("按照血量排序");
        heros.stream().sorted((h1, h2) -> h1.hp >= h2.hp ? 1 : -1).forEach(h -> System.out.print(h));

        System.out.println("保留3个");
        heros.stream().limit(3).forEach(h -> System.out.print(h));

        System.out.println("忽略前3个");
        heros.stream().skip(3).forEach(h -> System.out.print(h));

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

        System.out.println("转换任意类型的Stream");
        heros.stream().map((h) -> h.name + " - " + h.hp + " - " + h.damage).forEach(h -> System.out.println(h));

    }
}