后端学习日记-Java-Jdk1.8新特性-Lamda表达式

JDK1.8新特性-Lamda表达式

1、函数式接口

先创建出ILike接口，带上@FunctionalInterface注解，表明这个接口只允许一个方法存在

@FunctionalInterface
public interface ILike {
   void printData();
}

实现出这个接口两种方法，一种是传统的匿名内部类，一种是使用lamda表达式来实现，显而易见，lamda表达式相比传统的代码风格更加简洁明了

public class test {

    public static void execute(ILike like){
        like.printData();
    }

    public static void main(String[] args) {
    	//匿名内部类实现
        execute(new ILike() {
            @Override
            public void printData() {
                System.out.println("old print data");
            }
        });
		//lamda表达式实现
        execute(()-> System.out.println("lamda print data"));
    }
}

2、forEach

相比较传统的for循环，新增forEach

public static void main(String[] args) {

    List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
    //old
    for (Integer i : list){
        System.out.println(i);
    }
    //new
    list.forEach(i->{
        System.out.println(i);
    });
    //new
    list.forEach(System.out::println);

}

3、Stream()流

3.1 stream().map()

map相当于遍历所有对象的同时，对对象进行改造并重新返回

List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
list.stream().map(item->item*item).forEach(System.out::println);

3.2 stream.filter()

filter相当于过滤的方法，常见的有startsWith、contains

List<String> list = Arrays.asList("a1","ba2","c3");
//判断是以什么开头的
list.stream().filter((s)->s.startsWith("a")).forEach(System.out::println);
//判断包含了什么
list.stream().filter((s)>s.contains("a")).forEach(System.out::println);

我们还可以自定义过滤器

//自定义过滤器
Predicate<String> filterA = (p)->(p.contains("a"));
List<String> list = Arrays.asList("a1","ba2","c3");
//调用过滤器
list.stream().filter(filterA).forEach(System.out::println);

sorted排序、limit限制个数

创建一个Person实体，具备name->名字和salary->薪水两个属性

package com.example.entity;

public class Person {
    private int Salary;
    private String name;

    public Person(int salary, String name) {
        Salary = salary;
        this.name = name;
    }

    public int getSalary() {
        return Salary;
    }

    public void setSalary(int salary) {
        Salary = salary;
    }

    public String getName() {
        return name;
    }

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

    public static void main(String[] args) {
        List<Person> list = generateData();
		list.stream().sorted(Comparator.comparing(Person::getName).reversed()).limit(4).forEach(item->System.out.println(item.getName()));
    }
    public static List<Person> generateData(){
        List<Person> list = new LinkedList<>();
        list.add(new Person(100,"a"));
        list.add(new Person(110,"t"));
        list.add(new Person(90,"e"));
        list.add(new Person(125,"g"));
        list.add(new Person(105,"k"));
        return list;
    }

getName就是根据名字排序，getSalary就是根据薪水来排序

Collectors.minBy()获取到最小值

List<Person> list = generateData();
Optional<Person> person = list.stream().collect(Collectors.minBy(Comparator.comparingInt(Person::getSalary)));

Collectors.minBy()获取到最大值

List<Person> list = generateData();
Optional<Person> person = list.stream().collect(Collectors.maxBy(Comparator.comparingInt(Person::getSalary)));

Collectors.averagingDouble()获取平均值

List<Person> list = generateData();
list.stream().collect(Collectors.averagingDouble(Person::getSalary));

拼接字符串

list.stream().map(Person::getName).collect(Collectors.joining(","));

转成List

list.stream().map(Person::getName).collect(Collectors.toList());

groupingBy分组（转成Map对象）类似sql操作，可以减轻数据库压力

list.stream().collect(Collectors.groupingBy(Person::getName));