java8新特性-lambda表达式入门学习心得

(parameters) -> expression
或
(parameters) ->{ statements; }

// java 8之前的写法
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " >---Lambda");
    }
};
// 使用lambda的写法
Runnable r = () -> System.out.println(Thread.currentThread().getName() + " >---Lambda");

// java 8 之前的写法
Consumer<String> consumer = new Consumer<String>() {
     @Override
    public void accept(String s) {
         System.out.println(s);
       }
    };
 // Lambda表达式的写法
Consumer<String> consumer = (par)->System.out.println(par);
consumer.accept("xixi");
一个参数的小括号可以省略，简化如下：
Consumer<String> consumer = par->System.out.println(par);

// java 8之前的写法
Comparator<Integer> comparator = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
       return o1.compareTo(o2);
     }
 };
 // 使用Lambda表达式的方法 ，当只有一条语句的时候，大括号和return都可以省略
  Comparator<Integer> comparator=(x,y) -> x.compareTo(y);

Comparator<Integer> comparator=(x,y) -> x.compareTo(y);

package com.codegeek.lambda;
import lombok.*;

@Setter
@Getter
@NoArgsConstructor
@ToString
public class Employee {
    /**
     * 员工姓名
     */
    private String name;
    /**
     * 员工年龄
     */
    private int age;
    /**
     * 基本薪水
     */
    private double basicSalary;

    /**
     * 订单成交总额
     */
    private double dealTotalPrice;

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

    /**
     * 员工总薪资
     *
     * @return Double
     */
    public Double getTotalSalary() {
        return this.basicSalary + this.dealTotalPrice * 0.04;
    }
}

Employee qingLong = new Employee("青龙", 25, 5500, 7500);
Employee baiHu = new Employee("白虎", 27, 5000, 9000);
Employee zhuQue = new Employee("朱雀", 22, 3800, 4500);
Employee xuanWu = new Employee("玄武", 24, 3300, 3300);
List<Employee> employees = Arrays.asList(qingLong, baiHu, zhuQue, xuanWu);

// 员工列表先进行排序
employees.sort(new Comparator<Employee>() {
  @Override
  public int compare(Employee o1, Employee o2) {
     Integer age1 = o1.getAge();
     Integer age2 = o2.getAge();
     return age1.compareTo(age2);
 }
});
// 遍历排序后的列表并输出员工姓名
  for (Employee employee : employees) {
    System.out.println(employee.getName());
 }

employees.stream().sorted((o1, o2) -> o1.getAge().compareTo(o2.getAge()))
.forEach(o -> System.out.println(o.getName()));

Consumer<String> consumer = par->System.out.println(par);

public class FourFunctionsTest {

    // 消费式接口
    @Test
    public void testConsumer() {
        Consumer<Integer> consumer = x -> System.out.println(x);
        consumer.accept(1);
    }

    // 供给式接口
    @Test
    public void testSupplier() {
        Supplier<String> supplier = () -> {
            StringBuffer sb = new StringBuffer();
            return sb.append("我").append(520).append("you").toString();
        };
        System.out.println(supplier.get());
    }

    // 断言式接口
    @Test
    public void testPredicate() {
        Predicate<Long> predicate = x -> x == 1L;
        System.out.println(predicate.test(2L));
    }

    // 函数式接口
    @Test
    public void testFunction() {
        Function<Integer, Boolean> function = x -> x > 3;
        System.out.println(function.apply(4));
    }
}

// 使用策略式接口
@FunctionalInterface // 函数式接口（检查）只能有一个抽象方法
public interface MyFilter<T> {
    /**
     * 获取指定想要的employee对象
     *
     * @param t
     * @return
     */
    boolean getWant(T t);
}
    /**
     * 策略设计模式
     */
public List<Employee> needEmployee(List<Employee> employeeList, MyFilter<Employee> filter) {
   List<Employee> employees = new ArrayList<>();
     for (Employee employee : employeeList) {
        if (filter.getWant(employee)) {
            employees.add(employee);
        }
     }
      return employees;
 }
// 匿名内部类
List<Employee> employees1 = needEmployee(employees, new MyFilter<Employee>() {
  @Override
  public boolean getWant(Employee employee) {
      return employee.getTotalSalary() >= 5000;
   }
});
// 使用策略者设计模式Lambda简化
needEmployee(employees, employee -> mployee.getTotalSalary() >= 5000);

employees.stream().filter(e -> e.getTotalSalary() > 5000d).map(Employee::getName).forEach(System.out::println);

// 对象::实例方法
    @Test
    public void testConsumer() {
        Employee emp = new Employee();
        // 函数式接口Supplier是空参，返回是Integer类型的接口，
        // 而对应emp的实例方法getAge()刚刚好是空参且返回Integer类型的数据，符合上面注意事项1的要求
        Supplier<Integer> supplier = () -> emp.getAge();
        Supplier<Double> sup2 = emp::getSalary;
        System.out.println(supplier.get());
    }

    // 类::方法名
    @Test
    public void testSupplier() {
        Comparator<String> comparator = (x, y) -> x.compareTo(y);
        // 要求参数第一个值作为方法体的调用者，第二个参数值作为方法体的被调用者（参数）符合注意事项2的要求
        Comparator<String> compString = String::compareTo;
        System.out.println(comparator.compare("2", "3"));
        
        Comparator<Integer> com = Integer::compare;
        System.out.println(com.compare(1, 2));

        BiPredicate<String, String> predicate = String::equals;
        System.out.println(predicate.test("we", "eq"));
    }

// 当Employee有下面的构造时候
    public Employee(int age) {
        this.age = age;
    }

Function<Integer,Employee> fun = i -> new Employee(i)
System.out.println(fun.apply(13));

// 使用构造器引用简化后：
Function<Integer,Employee> fun = Employee::new
System.out.println(fun.apply(15));