JDK8新特性01 Lambda表达式01_设计的由来

1.java bean

public class Employee {

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

    public Employee() {
    }

    public Employee(String name) {
        this.name = name;
    }

    public Employee(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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;
    }

    public String show() {
        return "测试方法引用!";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + id;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        long temp;
        temp = Double.doubleToLongBits(salary);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Employee other = (Employee) obj;
        if (age != other.age)
            return false;
        if (id != other.id)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + "]";
    }

}

2.早期Java版本的设计策略和8版本的Lambda的接口类:

public interface MyPredicate<T> {
    public boolean test(T t);

}

//2.策略模式的接口实现类1
public class FilterEmployeeForAge implements MyPredicate<Employee>{
    @Override
    public boolean test(Employee t) {
        return t.getAge() <= 35;
    }

}

//3.策略模式的接口实现类2
public class FilterEmployeeForSalary implements MyPredicate<Employee> {
    @Override
    public boolean test(Employee t) {
        return t.getSalary() >= 5000;
    }

}

//4.lambda表达式定义的接口
@FunctionalInterface
public interface MyFun {
    public Integer getValue(Integer num);

}

3.原来的实现以及现在的Lambda的优化

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

import org.junit.Test;

public class TestLambda1 {

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

        TreeSet<String> ts = new TreeSet<>(com);

        TreeSet<String> ts2 = new TreeSet<>(new Comparator<String>(){
            @Override
            public int compare(String o1, String o2) {
                return Integer.compare(o1.length(), o2.length());
            }

        });
    }

    //现在的 Lambda 表达式
    @Test
    public void test2(){
        Comparator<String> com = (x, y) -> Integer.compare(x.length(), y.length());
        TreeSet<String> ts = new TreeSet<>(com);
    }

    List<Employee> emps = Arrays.asList(
            new Employee(101, "张三", 18, 9999.99),
            new Employee(102, "李四", 59, 6666.66),
            new Employee(103, "王五", 28, 3333.33),
            new Employee(104, "赵六", 8, 7777.77),
            new Employee(105, "田七", 38, 5555.55)
    );

    //需求:获取公司中年龄小于 35 的员工信息
    public List<Employee> filterEmployeeAge(List<Employee> emps){
        List<Employee> list = new ArrayList<>();

        for (Employee emp : emps) {
            if(emp.getAge() <= 35){
                list.add(emp);
            }
        }

        return list;
    }

    @Test
    public void test3(){
        List<Employee> list = filterEmployeeAge(emps);

        for (Employee employee : list) {
            System.out.println(employee);
        }
    }

    //需求:获取公司中工资大于 5000 的员工信息
    public List<Employee> filterEmployeeSalary(List<Employee> emps){
        List<Employee> list = new ArrayList<>();

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

        return list;
    }

    //优化方式一:策略设计模式
    public List<Employee> filterEmployee(List<Employee> emps, MyPredicate<Employee> mp){
        List<Employee> list = new ArrayList<>();

        for (Employee employee : emps) {
            if(mp.test(employee)){
                list.add(employee);
            }
        }

        return list;
    }

    //策略模式的调用
    @Test
    public void test4(){
        //策略1
        List<Employee> list = filterEmployee(emps, new FilterEmployeeForAge());
        for (Employee employee : list) {
            System.out.println(employee);
        }

        System.out.println("------------------------------------------");

        //策略2
        List<Employee> list2 = filterEmployee(emps, new FilterEmployeeForSalary());
        for (Employee employee : list2) {
            System.out.println(employee);
        }
    }

    //优化方式二:匿名内部类.(策略模式每次都需要创建新的实现类,麻烦)
    @Test
    public void test5(){
        List<Employee> list = filterEmployee(emps, new MyPredicate<Employee>() {
            @Override
            public boolean test(Employee t) {
                return t.getId() <= 103;
            }
        });

        for (Employee employee : list) {
            System.out.println(employee);
        }
    }

    //优化方式三:Lambda 表达式
    //精简匿名内部类的实现,将方法的实现在方法的参数中传递,不再new
    @Test
    public void test6(){
        List<Employee> list = filterEmployee(emps, (e) -> e.getAge() <= 35);
        list.forEach(System.out::println);

        System.out.println("------------------------------------------");

        List<Employee> list2 = filterEmployee(emps, (e) -> e.getSalary() >= 5000);
        list2.forEach(System.out::println);
    }

    //优化方式四:Stream API
    @Test
    public void test7(){
        emps.stream()
            .filter((e) -> e.getAge() <= 35)
            .forEach(System.out::println);

        System.out.println("----------------------------------------------");

        emps.stream()
            .map(Employee::getName)
            .limit(3)
            .sorted()
            .forEach(System.out::println);
    }
}

原文地址:https://www.cnblogs.com/guchunchao/p/10301897.html

时间: 2024-10-13 06:05:54

JDK8新特性01 Lambda表达式01_设计的由来的相关文章

JDK8新特性02 Lambda表达式02_Lambda语法规则

//函数式接口:只有一个抽象方法的接口称为函数式接口. 可以使用注解 @FunctionalInterface 修饰 @FunctionalInterface public interface MyFun { public Integer getValue(Integer num); } import java.util.ArrayList; import java.util.Comparator; import java.util.HashMap; import java.util.List;

jdk8新特性--使用lambda表达式的延迟执行特性优化性能

使用lambda表达式的延迟加载特性对代码进行优化: 原文地址:https://www.cnblogs.com/niwotaxuexiba/p/10850339.html

C++11 新特性之 Lambda表达式

lambda表达式可以用于创建并定义匿名的函数对象,以简化编程工作 Lambda的语法如下: [函数对象参数](操作符重载函数参数)->返回值类型{函数体} []内的参数指的是Lambda表达式可以取得的变量.(2)函数中的param就是指函数可以得到在Lambda表达式外的全局变量, 如果在[]中传入=的话,即是可以取得所有的外部变量,如(1)和(3)Lambda表达式 ()内的参数是每次调用函数时传入的参数. ->后加上的是Lambda表达式返回值的类型,如(3)中返回了一个int类型的变

C++11新特性(3) lambda表达式(1)

C++11添加了一项名为lambda表达式的新功能.通过这项功能能编写内嵌的匿名函数,而不必编写独立函数或函数对象,使得代码更加理解. lambda表达式包含以下部分. [capture_block](parameters) mutable exception_specification->return_type {body} 现在分析各个部分的内容: (capture_block)捕捉块:指定如何捕捉所在作用域的变量,并供给lambda主体部分使用. (parameter)参数(可选):lam

JDK1.8新特性(二): Lambda表达式 (参数列表) -&gt; { } 和函数式接口@FunctionalInterface

Lambda表达式 二:简介 JDK的升级的目的有以下几个:增加新的功能.修复bug.性能优化.简化代码等几个方面,Lambda表达式就是属于简化代码,用于简化匿名实现类,提供一种更加简洁的写法.Lambda表达式在Swift语言中称之为代码块,Lambda表达式可以认为是一种特殊的接口,该接口必须只有一个抽象方法. 语法 (参数类型 参数名, 数参数类型 参数名2...) -> { // code }; 小括号()中的内容就是方法中的参数列表包括参数类型.参数名,其中参数类型是可以省略的,当参

2020了你还不会Java8新特性?Lambda表达式及API(二)

lambda表达式 为什么要使用lambda表示式 在Java中无法将函数座位参数传递给一个方法,也无法返回一个函数的方法. 在js中,函数的参数是一个函数.返回值是另一个函数的情况是非常常见的.是一门经典的函数式语言. Java匿名内部类. 匿名内部类的介绍 Gradle的使用.可以完全使用maven的中央仓库. 进行安卓的开发时,gradle已经成为标配了. lambda: 匿名内部类 my_jButton.addActionListener(new ActionListener() { @

jdk8新特性之Lambda

Lambda体验Lambda是一个匿名函数,可以理解为一段可以传递的代码.Lambda表达式写法,代码如下:借助Java 8的全新语法,上述 Runnable 接口的匿名内部类写法可以通过更简单的Lambda表达式达到相同的效果 /** * 从匿名类到Lambda表达式的转变 */ @Test public void testLambdaHelloWorld() { // 匿名类01 new Thread(new Runnable() { @Override public void run()

jdk8新特性之lambda expressions

本文分两部分: 语法简单说明 lambda的使用 注:这两部分内容均以类+注释的方式进行说明,并且内容均来自官方教程(https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html). 第一部分: /** * 语法说明类 * * lambda表达式包含下面几个要素: * 1.逗号分隔的参数列表,如CheckPerson.test(Person p),其中p表示一个Person的对象实例 * 2.向右箭头 →,

jdk1.8新特性之lambda表达式

lambda表达式其实就是指一个匿名函数,应用最广泛的就是匿名内部类.在jdk1.8之前,我们定义一个匿名内部类可能需要写一大坨代码,现在有了lambda之后,可以写的很简洁了.但不是说lambda只能用来简化匿名内部类,从lambda的实际作用和表现上来看,就是一个变量指代一个代码块.而能够使用lambda表达式的一个前提要求是,该变量必须实现某个函数式接口.啥是函数式接口?参考jdk1.8新特性之函数式接口.看例子: 1.函数式接口 * Copyright (c) 1994, 2013, O