文章目录
Hello Lambda
1. 普通方法
在for循环遍历中进行条件判断，筛选出满足条件的数据。在for循环遍历中进行条件判断，筛选出满足条件的数据。
hp>100 && damage<50.
// An highlighted block
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 && damange<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);
}
}
}
// An highlighted block
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;
}
//初始化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 + "]\r\n";
}
}
2. 匿名类方式
首先准备一个接口HeroChecker，提供一个test(Hero)方法，然后通过匿名类的方式，实现这个接口。首先准备一个接口HeroChecker，提供一个test(Hero)方法，然后通过匿名类的方式，实现这个接口。
HeroChecker checker = new HeroChecker() {
public boolean test(Hero h) {
return (h.hp>100 && h.damage<50);
}
};
接着调用filter，传递这个checker进去进行判断，这种方式就很像通过Collections.sort在对一个Hero集合排序，需要传一个Comparator的匿名类对象进去一样。
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("使用匿名类的方式，筛选出 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方式
首先准备一个接口HeroChecker，提供一个test(Hero)方法，然后通过匿名类的方式，实现这个接口。首先准备一个接口HeroChecker，提供一个test(Hero)方法，然后通过匿名类的方式，实现这个接口。
使用Lambda方式筛选出数据。
filter(heros,(h)->h.hp>100 && h.damage<50);
同样是调用filter方法，从上一步的传递匿名类对象，变成了传递一个Lambda表达式进去。
h->h.hp>100 && h.damage<50；
package lambda;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import charactor.Hero;
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 其实就是匿名方法，这是一种把方法作为参数进行传递的编程思想。
虽然代码是这么写
filter(heros, h -> h.hp > 100 && h.damage < 50);
但是，Java会在背后，悄悄的，把这些都还原成匿名类方式。
引入Lambda表达式，会使得代码更加紧凑，而不是各种接口和匿名类到处飞。
5. Lambda的弊端
Lambda表达式虽然带来了代码的简洁，但是也有其局限性。
（1）可读性差，与啰嗦的但是清晰的匿名类代码结构比较起来，Lambda表达式一旦变得比较长，就难以理解
（2）不便于调试，很难在Lambda表达式中增加调试信息，比如日志
（3）版本支持，Lambda表达式在JDK8版本中才开始支持，如果系统使用的是以前的版本，考虑系统的稳定性等原因，而不愿意升级，那么就无法使用。
Lambda比较适合用在简短的业务代码中，并不适合用在复杂的系统中，会加大维护成本。
方法引用
1. 引用静态方法
首先为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. 引用对象方法
与引用静态方法很类似，只是传递方法的时候，需要一个对象的存在。
TestLambda testLambda = new TestLambda();
filter(heros, testLambda::testHero);
这种方式叫做引用对象方法。
3. 引用容器中的对象方法
首先为Hero添加一个方法首先为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);
这种方式就叫做引用容器中的对象的方法。
4. 引用构造器
有的接口中的方法会返回一个对象，比如java.util.function.Supplier提供
了一个get方法，返回一个对象。
public interface Supplier<T> {
T get();
}
设计一个方法，参数是这个接口
public static List getList(Supplier<List> s){
return s.get();
}
为了调用这个方法，有3种方式：
（1）匿名类：
Supplier<List> s = new Supplier<List>() {
public List get() {
return new ArrayList();
}
};
List list1 = getList(s);
（2）Lambda表达式：
List list2 = getList(()->new ArrayList());
（3）引用构造器：
List list3 = getList(ArrayList::new);
聚合操作
1. 传统方式与聚合操作方式遍历数据
遍历数据的传统方式就是使用for循环，然后条件判断，最后打印出满足条件的数据。
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));
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)
4. 中间操作
每个中间操作，又会返回一个Stream，比如.filter()又返回一个Stream, 中间操作是“懒”操作，并不会真正进行遍历。
中间操作比较多，主要分两类：
对元素进行筛选 和 转换为其他形式的流
对元素进行筛选：
filter 匹配
distinct 去除重复(根据equals判断)
sorted 自然排序
sorted(Comparator) 指定排序
limit 保留
skip 忽略
转换为其他形式的流
mapToDouble 转换为double的流
map 转换为任意类型的流
5. 结束操作
当进行结束操作后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。 结束操作不会返回Stream，但是会返回int、float、String、 Collection或者像forEach，什么都不返回,。
结束操作才真正进行遍历行为，前面的中间操作也在这个时候，才真正的执行。
常见结束操作如下：
forEach() 遍历每个元素
toArray()转换为数组
min(Comparator<T>) 取最小的元素
max(Comparator<T>)取最大的元素
count() 总数
findFirst()第一个元素
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
