Lambda方法引用

• 引用静态方法
  首先为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);
          }
      }
     
  }

• 引用对象方法
  与引用静态方法很类似，只是传递方法的时候，需要一个对象的存在
   
  TestLambda testLambda = new TestLambda();
  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);
       
          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);
          }
      }
   
  }

• 引用容器中的对象的方法
  首先为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.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("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);
          }
      }
     
  }

• 引用构造器
  有的接口中的方法会返回一个对象，比如java.util.function.Supplier提供
  了一个get方法，返回一个对象。
   
  public interface Supplier<T> {
      T get();
  }
   
  
  
  设计一个方法，参数是这个接口
   
  public static List getList(Supplier<List> s){
    return s.get();
  }
   
  
  
  为了调用这个方法，有3种方式
  第一种匿名类：
   
  Supplier<List> s = new Supplier<List>() {
  public List get() {
  return new ArrayList();
  }
  };
  List list1 = getList(s);
   
  
  
  
  第二种：Lambda表达式
   
  List list2 = getList(()->new ArrayList());
   
  
  
  
  第三种：引用构造器
   
  List list3 = getList(ArrayList::new);
  

  package lambda;
   
  import java.util.ArrayList;
  import java.util.List;
  import java.util.function.Supplier;
   
  public class TestLambda {
      public static void main(String[] args) {
      Supplier<List> s = new Supplier<List>() {
          public List get() {
              return new ArrayList();
          }
      };
   
      //匿名类
      List list1 = getList(s);
       
      //Lambda表达式
      List list2 = getList(()->new ArrayList());
       
      //引用构造器
      List list3 = getList(ArrayList::new);
   
      }
       
      public static List getList(Supplier<List> s){
          return s.get();
      }
        
  }