Lambda表达式------java8 新特性（1）

一、案例分析

1、创建实体类 Employee

package com.lambda1;

public class Employe {

    private String name;
    private int age;
    private double salary;

    public Employe() {
    }

    public Employe(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employe{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}

2、创建测试类 TestLambda2.java

package com.lambda1;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class TestLambda2 {

    List<Employe> employes = Arrays.asList(
            new Employe("张三", 18,9999.99),
            new Employe("李四", 38,5555.99),
            new Employe("王五", 50,6666.66),
            new Employe("赵六", 16,3333.33),
            new Employe("田七", 10,7777.77)
    );

    @Test
    public void test1(){
        //按年龄过滤
        List<Employe> list = filterEmployee(employes);
        list.forEach(System.out::println);

        System.out.println("--------------------------------------------------");
        //按工资过滤
        List<Employe> list2 = filterEmployee2(employes);
        list2.forEach(System.out::println);
    }


    //需求1：获取当前公司中员工年龄大于35的员工信息
    public List<Employe> filterEmployee(List<Employe> list){
        List<Employe> emps = new ArrayList<>();

        for (Employe emp: list){
            if (emp.getAge() >= 35){
                emps.add(emp);
            }
        }
        return emps;
    }

    //需求2：获取当前公司中员工工资大于5000的员工信息
    public List<Employe> filterEmployee2(List<Employe> list){
        List<Employe> emps = new ArrayList<>();

        for (Employe emp: list){
            if (emp.getSalary() >= 5000){
                emps.add(emp);
            }
        }
        return emps;
    }
}

分析：上述需求中每增加一个类似的需求就要创建一个新的对应的处理方法，方法中真正有作用的地方在 if(...) 的判断中，这样造成代码冗余。

3、对 TestLambda2.java中代码优化方式《一》

优化方案一： 采用设计者模式优化

3.1创建公共接口 MyPredicate.java 接口
package com.lambda1;

public interface MyPredicate<T> {
    public boolean test(T t);
}
3.2 创建FilterEmployeeByAge.java 过滤年龄的方法，实现接口 MyPredicate.java
package com.lambda1;

public class FilterEmployeeByAge implements MyPredicate<Employe>{
    @Override
    public boolean test(Employe t) {
        return t.getAge() >= 35;
    }
}
3.3 创建FilterEmployeeBySalary.java 过滤薪水的方法，实现接口 MyPredicate.java
package com.lambda1;

public class FilterEmployeeBySalary implements MyPredicate<Employe>{
    @Override
    public boolean test(Employe t) {
        return t.getSalary()>=5000;
    }
}
3.4 优化后的 TestLambda2.java 类
package com.lambda1;


import org.junit.Test;

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

public class TestLambda2 {

    List<Employe> employes = Arrays.asList(
            new Employe("张三", 18,9999.99),
            new Employe("李四", 38,5555.99),
            new Employe("王五", 50,6666.66),
            new Employe("赵六", 16,3333.33),
            new Employe("田七", 10,7777.77)
    );

    //优化方式一：策略设计者模式
    @Test
    public void test2(){
        //按年龄过滤
        List<Employe> list = filterEmployee(this.employes, new FilterEmployeeByAge());
        list.forEach(System.out::println);

        System.out.println("--------------------------------------------------");
        //按工资过滤
        List<Employe> list2 = filterEmployee(this.employes, new FilterEmployeeBySalary());
        list2.forEach(System.out::println);
    }

    public List<Employe> filterEmployee(List<Employe> list, MyPredicate<Employe> mp){
        List<Employe> emps = new ArrayList<>();

        for (Employe employe : list){
            if (mp.test(employe)){
                emps.add(employe);
            }
        }
        return emps;
    }
}

优化方式一存在的问题：每次添加一个需求方法，都要添加一个对应实现接口 MyPredicate.java 的 FilterEmployeeByXxx.java类；

4、对 TestLambda2.java中代码优化方式《二》

优化方案二：采用匿名内部类方式

    //优化方式二：匿名内部类
    @Test
    public void test3(){
        List<Employe> list = filterEmployee(this.employes, new MyPredicate<Employe>() {
            @Override
            public boolean test(Employe t) {
                return t.getAge() >= 30;
            }
        });
        list.forEach(System.out::println);

        System.out.println("---------------------------------------");
        List<Employe> list2 = filterEmployee(this.employes, new MyPredicate<Employe>() {
            @Override
            public boolean test(Employe t) {
                return t.getSalary() >= 5000;
            }
        });
        list2.forEach(System.out::println);
    }

   public List<Employe> filterEmployee(List<Employe> list, MyPredicate<Employe> mp){
        List<Employe> emps = new ArrayList<>();

        for (Employe employe : list){
            if (mp.test(employe)){
                emps.add(employe);
            }
        }
        return emps;
    }

优化方式二中存在的问题：代码中关键部位只有 t.getAge() >= 30 和 t.getSalary() >= 5000，其余部分都是多余的；

4、对 TestLambda2.java中代码优化方式《三》

    //优化方式三：采用Lambda表达式
    @Test
    public void test4(){
        List<Employe> list = filterEmployee(this.employes, t -> t.getAge() >= 30);
        list.forEach(System.out::println);

        System.out.println("---------------------------------------");
        List<Employe> list2 = filterEmployee(this.employes, t -> t.getSalary() >= 5000);
        list2.forEach(System.out::println);
    }

   public List<Employe> filterEmployee(List<Employe> list, MyPredicate<Employe> mp){
        List<Employe> emps = new ArrayList<>();

        for (Employe employe : list){
            if (mp.test(employe)){
                emps.add(employe);
            }
        }
        return emps;
    }

优化方式三中存在的问题：在过滤的过程中需要创建接口 MyPredicate.java 并且需要方法 filterEmployee()。

4、对 TestLambda2.java中代码优化方式《五》

优化方式五：采用 Stream API

    //优化方式四
    @Test
    public void test5(){
        this.employes.stream()
                .filter(x->x.getAge()>=30)
                .forEach(System.out::println);
        
        System.out.println("--------------------------------------");
        this.employes.stream()
                .filter(x->x.getSalary()>=5000)
                .forEach(System.out::println);
    }

二、Lambda 表达式语法

   Lambda 是一个匿名函数，可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。

   Java8引入了一个新的操作符 “->” 该操作符称为箭头符或lambda 操作符，箭头操作符将 Lambda 表达式拆分成两部分：
   左侧：Lambda 表达式的参数列表；
   右侧：Lambda 表达式中所需要执行的功能，即 Lambda 体；

例子1：

package com.lambda1;

import org.junit.Test;

import java.util.Comparator;
import java.util.TreeSet;

public class TestLambda {

    //原来匿名内部类
    @Test
    public void test1(){
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        TreeSet<Integer> ts = new TreeSet<>(com);
    }

    //Lambda表达式
    @Test
    public void test2(){
        Comparator<Integer> com = (o1, o2) -> Integer.compare(o1, o2);
        TreeSet<Integer> ts = new TreeSet<>(com);
    }
}

三、Lambda 表达式练习

package com.lambda2;

import com.lambda1.Employe;
import org.junit.Test;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
 * Lambda表达式练习
 */
public class TestLambda1 {


    List<Employe> emps = Arrays.asList(
            new Employe("张三", 18,9999.99),
            new Employe("李四", 38,5555.99),
            new Employe("王五", 50,6666.66),
            new Employe("赵六", 16,3333.33),
            new Employe("田七", 10,7777.77),
            new Employe("田八", 10,7777.77)
    );


    //需求：按员工年龄排序，年龄相同按姓名排序
    @Test
    public void test1(){
        Collections.sort(emps, (x, y) -> {
            if (x.getAge() == y.getAge()){
                return x.getName().compareTo(y.getName());
            }else{
                return -Integer.compare(x.getAge(),y.getAge());
            }
        });

        emps.forEach(System.out::println);
    }
}

存在问题：使用 Lambda 表达式需要函数式接口的支持；
函数式接口：接口中只有一个抽象方法（Object类中的方法忽略）。或者使用了@FunctionInterface 注解的接口，为函数式接口。

四、Java8中内置的四大核心函数式接口

java8 内置的四大核心函数式接口
1.Consumer<T>：消费型接口
  void accept(T t);

2.Supplier<T>: 供给型接口
  T get();

3.Function<T, R>：函数型接口
  R apply(T t);

4.Predicate<T>：断言型接口
  boolean test(T t);

package com.lambda2;

import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * java8 内置的四大核心函数式接口
 *
 *    1.Consumer<T>：消费型接口
 *      void accept(T t);
 *
 *    2.Supplier<T>: 供给型接口
 *      T get();
 *
 *    3.Function<T, R>：函数型接口
 *      R apply(T t);
 *
 *    4.Predicate<T>：断言型接口
 *      boolean test(T t);
 *
 */
public class TestLambda3 {

    //Consumer<T>：消费型接口
    @Test
    public void test1(){
        happy(1000, m-> System.out.println("吃饭消费："+m));
    }

    public void happy(double money, Consumer<Double> con){
        con.accept(money);
    }

    //Supplier<T>: 供给型接口
    @Test
    public void test2(){
        List<Integer> list = getNumList(10, () -> (int)(Math.random() * 100));
        list.forEach(System.out::println);
    }
    //需求：产生一个集合里面都是整数
    public List<Integer> getNumList(int num, Supplier<Integer> sup){
        List<Integer> list = new ArrayList<>();
        for (int i=0; i<num; i++){
            list.add(sup.get());
        }
        return list;
    }

    //Function<T, R>：函数型接口
    @Test
    public void test3(){
        String s1 = strHandle("\t\t\t 你好，中国！   ", s -> s.trim());
        System.out.println(s1);

        String s2 = strHandle("abcdf", s -> s.toUpperCase());
        System.out.println(s2);
    }
    //需求：用于处理字符串
    public String strHandle(String str, Function<String, String> fun){
        return fun.apply(str);
    }

    //Predicate<T>：断言型接口
    @Test
    public void test4(){
        List<String> list = Arrays.asList("hello","www","lambda","ok");
        List<String> resList = filterStr(list, s -> s.length() > 3);
        resList.forEach(System.out::println);
    }
    //取出满足条件的字符串
    public List<String> filterStr(List<String> list, Predicate<String> pred){
        List<String> strList = new ArrayList<>();
        for(String str : list){
            if (pred.test(str)){
                strList.add(str);
            }
        }
    /*  list.forEach(x-> {
            if (pred.test(x)){
                strList.add(x);
            }
        });
     */
        return strList;
    }
}

五、Java8 中方法引用

一、方法引用：若 Lambda 体内的内容有方法已经实现了， 我们可以使用“方法引用”
    （可以理解为方法引用时 Lambda 表达式的另外一种表现形式）

主要有三种语法格式：

   对象::实例方法名

   类::静态方法名

   类::实例方法名

注意：
  （1）Lambda 体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的函数式列表和返回值类型保持一致！
  （2）Lambda 参数列表中第一个参数是实例方法的调用者，而第二个参数是实例方法的参数时，可以使用 ClassName::method

二、构造器引用
   格式：ClassName::new
   注意：需要调用的构造器的参数列表要与函数式接口中抽象方法参数列表保持一致！

三、数组引用
   格式：Type::new

package com.TestMethodRef;

import com.lambda1.Employe;
import org.junit.Test;
import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * 一、方法引用：若 lambda 体内的内容有方法已经实现了， 我们可以使用“方法引用”
 *          （可以理解为方法引用时 Lambda 表达式的另外一种表现形式）
 *
 *  主要有三种语法格式：
 *
 *      对象::实例方法名
 *
 *      类::静态方法名
 *
 *      类::实例方法名
 *
 *    注意：（1）Lambda 体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的函数式列表和返回值类型保持一致！
 *         （2）Lambda 参数列表中第一个参数是实例方法的调用者，而第二个参数是实例方法的参数时，可以使用 ClassName::method
 *
 *  二、构造器引用
 *      格式：ClassName::new
 *      注意：需要调用的构造器的参数列表要与函数式接口中抽象方法参数列表保持一致！
 *
 * 三、数组引用
 *      格式：Type::new
 */
public class TestMethodRef {


    //对象::实例方法名
    @Test
    public void test1(){

        PrintStream ps = System.out;
        //Lambda表达式
        Consumer<String> con = x -> ps.println(x);
//        Consumer<String> con = System.out::println;

        PrintStream ps1 = System.out;
        //方法引用
        Consumer<String> con1 = ps1::println;
        Consumer<String> con2 = System.out::println;
        con2.accept("abcd");
    }

    @Test
    public void test2(){
        Employe emp = new Employe("赵云", 20,8888.88);

        //Lambda表达式
        Supplier<String> sup = ()-> emp.getName();
        String s = sup.get();
        System.out.println(s);

        //方法引用
        Supplier<Integer> sup2 = emp::getAge;
        Integer s2 = sup2.get();
        System.out.println(s2);
    }

    //类::静态方法名
    @Test
    public void test3(){
        //Lambda表达式
        Comparator<Integer> com = (x,y) -> Integer.compare(x,y);
        int r = com.compare(10, 5);
        System.out.println(r);

        //方法引用
        Comparator<Integer> com2 = Integer::compare;
        int r2 = com2.compare(5, 10);
        System.out.println(r2);
    }

    //类::实例方法名
    @Test
    public void test4(){
        //Lambda表达式
        BiPredicate<String, String> bp = (x, y) -> x.equals(y);

        //方法引用(规则：第一个参数是实例方法的调用者，第二个参数是实例方法的参数)
        BiPredicate<String, String> bp2 = String::equals;

    }

    //构造器引用
    @Test
    public void test5(){
        //Lambda 表达式
        Supplier<Employe> sup = ()-> new Employe();

        //构造器引用
        Supplier<Employe> sup2 = Employe::new;
    }

    //数组引用
    @Test
    public void test6(){
        //Lambda 表达式
        Function<Integer, String[]> fun = (x)-> new String[x];
        String[] strs = fun.apply(10);
        System.out.println(strs.length);

        //数组引用
        Function<Integer, String[]> fun2 = String[]::new;
        String[] strs2 = fun.apply(8);
        System.out.println(strs2.length);
    }

}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,185评论 6赞 493
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,445评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,684评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,564评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,681评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,874评论 1赞 290
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,025评论 3赞 408
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,761评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,217评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,545评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,694评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,351评论 4赞 332
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,988评论 3赞 315
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,778评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,007评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,427评论 2赞 360
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,580评论 2赞 349

推荐阅读更多精彩内容