## 步驟 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.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
public class TestLambda4 {
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 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 -> TestLambda4.testHero(h));
System.out.println("直接引用靜態方法");
filter(heros, TestLambda4::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.println(hero);
}
}
}
}
```
## 步驟 2 : 引用對象方法
與引用靜態方法很類似，只是傳遞方法的時候，需要一個對象的存在
```
TestLambda testLambda = new TestLambda();
filter(heros, testLambda::testHero);
```
這種方式叫做引用對象方法
```
package lambda;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
public class TestLambda5 {
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 c = new HeroChecker() {
public boolean test(Hero h) {
return h.hp > 100 && h.damage < 50;
}
};
//使用類的對象方法
TestLambda5 testLambda = new TestLambda5();
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.println(hero);
}
}
}
}
```
## 步驟 3 : 引用容器中的對象的方法
首先為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);
```
這種方式就叫做引用容器中的對象的方法
```
package lambda;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
public class TestLambda6 {
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 c = new HeroChecker() {
public boolean test(Hero h) {
return h.hp > 100 && h.damage < 50;
}
};
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.println(hero);
}
}
}
}
```
