Java自学-Lambda 概念

2020-02-17 16:03:04来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

Java自学-Lambda 概念

Java Lambda 表达式概念

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

步骤 1 : 普通方法

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

hp>100 && damage<50

普通方法

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);
        }
    }
  
}
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 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);
        }
    }
   
}
package lambda;
 
import charactor.Hero;
 
public interface HeroChecker {
    public boolean test(Hero h);
}

步骤 3 : Lambda方式

使用Lambda方式筛选出数据

filter(heros,(h)->h.hp>100 && h.damage<50);

同样是调用filter方法,从上一步的传递匿名类对象,变成了传递一个Lambda表达式进去

h->h.hp>100 && h.damage<50

乍一看Lambda表达式似乎不好理解,其实很简单,下一步讲如何从一个匿名类一点点演变成Lambda表达式

Lambda方式

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 : 设置eclipse以支持Lambda

如果你的eclipse能够正常识别Lambda,那么就可以跳过这个章节了。
因为Lambda是JDK8的内容,除了JDK需要使用1.8以上版本外(在JDK环境变量配置下载的就是1.8了),还需要在eclipse中把编译器设置为1.8才能够正常识别Lambda.

设置办法:
菜单->Window->Preferences->Java-Compiler->Compiler compliance leve: 设置为1.8即可

设置eclipse以支持Lambda
步骤 5 : 从匿名类演变成Lambda表达式

Lambda表达式可以看成是匿名类一点点演变过来

  1. 匿名类的正常写法

    HeroChecker c1 = new HeroChecker() {
    public boolean test(Hero h) {
    return (h.hp>100 && h.damage<50);
    }
    };

  2. 把外面的壳子去掉
    只保留方法参数方法体
    参数和方法体之间加上符号 ->
    HeroChecker c2 = (Hero h) ->{
    return h.hp>100 && h.damage<50;
    };

  3. 把return和{}去掉
    HeroChecker c3 = (Hero h) ->h.hp>100 && h.damage<50;

  4. 把 参数类型和圆括号去掉(只有一个参数的时候,才可以去掉圆括号)
    HeroChecker c4 = h ->h.hp>100 && h.damage<50;

  5. 把c4作为参数传递进去
    filter(heros,c4);

  6. 直接把表达式传递进去
    filter(heros, 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("使用匿名类的方式,筛选出 hp>100 && damange<50的英雄");
             // 匿名类的正常写法
             HeroChecker c1 = new HeroChecker() {
                 @Override
                 public boolean test(Hero h) {
                     return (h.hp > 100 && h.damage < 50);
                 }
             };
             // 把new HeroChcekcer,方法名,方法返回类型信息去掉
             // 只保留方法参数和方法体
             // 参数和方法体之间加上符号 ->
             HeroChecker c2 = (Hero h) -> {
                 return h.hp > 100 && h.damage < 50;
             };
    
             // 把return和{}去掉
         HeroChecker c3 = (Hero h) -> h.hp > 100 && h.damage < 50;
    
         // 把 参数类型和圆括号去掉
         HeroChecker c4 = h -> h.hp > 100 && h.damage < 50;
    
         // 把c4作为参数传递进去
         filter(heros, c4);
    
         // 直接把表达式传递进去
         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);
         }
        }
    }

步骤 6 : 匿名方法

与匿名类 概念相比较,
Lambda 其实就是匿名方法,这是一种把方法作为参数进行传递的编程思想。

虽然代码是这么写

filter(heros, h -> h.hp > 100 && h.damage < 50);

但是,Java会在背后,悄悄的,把这些都还原成匿名类方式。
引入Lambda表达式,会使得代码更加紧凑,而不是各种接口和匿名类到处飞。

步骤 7 : Lambda的弊端

Lambda表达式虽然带来了代码的简洁,但是也有其局限性。

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

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


原文链接:https://www.cnblogs.com/jeddzd/p/12323181.html
如有疑问请与原作者联系

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:Java连载84-Collection的常用方法、迭代器

下一篇:JCL、SLF4J、Log4J、Log4J2、LogBack和JUL之间的关系,你搞清楚