Java中的Lambda表达式、stream流

Lamdba表达式

作用：用来简化匿名内部类的代码写法，只能简化函数式接口的匿名内部类

（函数式接口：有且只能有一个抽象方法的接口）

格式：

(被重写方法的形参列表) -> {
	被重写方法的方法体代码
}

省略规则：

• 参数类型可以省略不写
• 如果只有一个参数，参数类型可以省略，同时括号也可以省略
• 如果表达式中的方法体代码只有一行，可以省略大括号不写，同时也要省略分号，如果这行代码是return语句，也必须去掉returen不写。

//函数式接口
interface Swimming {
    String swim(int number);
}

	//普通写法
	Swimming s0 = new Swimming() {
	    @Override
	    public String swim(int number) {
	        return "小狗在游泳，序号：" + number;
	    }
	};
	s0.swim(0);
	
	//Lambda写法
	Swimming s1 = (int number) -> {
	    return "小猫在游泳，序号：" + number;
	};
	s1.swim(1);
	
	//简化参数类型，只有一个参数简化参数括号
	Swimming s2 = number -> {
	    return "小猪在游泳，序号：" + number;
	};
	s2.swim(2);
	
	//方法体只有一行，简化大括号和return
	Swimming s3 = number -> "小鸡在游泳，序号：" + number;
	s3.swim(3);

视频链接：Lambda表达式

方法引用简化

方法引用简化
如果某个Lamdba表达式里只是调用一个方法，并且前后参数的形式一致，就可以使用方法引用简化。

	
	Student s1 = new Student("张飞", 13);
	Student s2 = new Student("刘备", 22);
	Student s3 = new Student("关羽", 17);
	Student s4 = new Student("赵云", 9);
	
	ArrayList<Student> students = new ArrayList<>();
	Collections.addAll(students, s1, s2, s3, s4);
	
	//按照年龄升序排列
	Collections.sort(students, new Comparator<Student>() {
	    @Override
	    public int compare(Student o1, Student o2) {
	        return o1.getAge() - o2.getAge();
	    }
	});
	
	//lambda简化
	Collections.sort(students, (o1, o2) -> CompareByDate.compareByAgeTool(o1, o2));
	
	//静态方法引用简化
	Collections.sort(students, CompareByDate::compareByAgeTool);
	
	//实例方法引用简化
	CompareByDate compare = new CompareByDate();
	Collections.sort(students, compare::compareByAge);
	

/**
 * 自定义比较类
 */
public class CompareByDate {

    public static int compareByAgeTool(Student s1, Student s2) {
        return s1.getAge() - s2.getAge();
    }

    public int compareByAge(Student s1, Student s2) {
        return s1.getAge() - s2.getAge();
    }
}

特定类型的方法引用
如果某个Lambda表达式只是调用一个实例方法，并且前面的参数列表中的第一个参数是作为方法的主调，后面的所有参数都是作为该实例方法的入参的，则此时就可以使用特定类型的方法引用。

    String[] names = {"Ben", "angela", "Bob", "Andy"};

    Arrays.sort(names, new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            //忽略首字符大小写比较
            return o1.compareToIgnoreCase(o2);
        }
    });

    //lambda简化
    Arrays.sort(names, (o1, o2) -> o1.compareToIgnoreCase(o2));

    //特定类型的方法引用简化
    Arrays.sort(names, String::compareToIgnoreCase);
        

构造器引用
如果某个Lambda表达式里只是在创建对象，并且前后参数情况一致，就可以使用构造器引用。
（用到的地方不多）

interface CreateStudent {
    Student create(String name, int age);
}

	//匿名内部类实现接口，接口创建对象
    CreateStudent cs = new CreateStudent() {
        @Override
        public Student create(String name, int age) {
            return new Student(name, age);
        }
    };
    Student stu = cs.create("小明", 15);

    //Lambda简化
    CreateStudent cs2 = (name, age) -> new Student(name, age);

    //构造器引用简化
    CreateStudent cs3 = Student::new;
    

Stream流

是jdk8开始新增的一套API，可以用于操作集合或者数组的数据。

优点： Stream流大量的结合了Lambda的语法风格来编程，提供了一种更加强大，更加简单的方式操作集合或者数组中的数据，代码更简洁，可读性更好。

实例：

    List<String> names = new ArrayList<>();
    Collections.addAll(names, "张三丰", "张无忌", "周杰伦", "赵敏", "张杰");

    //需求把姓张的和三个字的存到新集合

	//普通的写法
    List<String> list = new ArrayList<>();
    for (String name : names) {
        if (name.startsWith("张") && name.length() == 3) {
            list.add(name);
        }
    }

	//stream流写法
    List<String> list2 = names.stream().filter(s -> s.startsWith("张"))
            .filter(s -> s.length() == 3).collect(Collectors.toList());

stream流使用示意图：

主要就是三点：获取Stream流、中间处理、终结操作

1. 获取Stream流

分为集合获取和数组获取

    //获取Collection集合stream流
    Stream<String> stream1 = list.stream();

    //获取数组的stream流
    Stream<String> stream2 = Arrays.stream(array);

2. 常用的中间处理方法

	//找出年龄大于30并且小于60，并按照升序排列
	stuList.stream().filter(s -> s.getAge() > 30 && s.getAge() < 60)
	        .sorted((o1, o2) -> o1.getAge() - o2.getAge())
	        .forEach(s -> {
	            System.out.println(s);
	        });
	
	//找出身高最高的前三名
	stuList.stream().sorted((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()))
	        .limit(3)
	        .forEach(s -> System.out.println(s));
	
	//去除身高大于175的同学的名字，要求去重
	stuList.stream().filter(s -> s.getHeight() > 175)
	        .map(s -> s.getName())
	        .distinct()
	        .forEach(s -> System.out.println(s));

3. 常用终结操作

	//找出身高最高的学生
	Student student = stuList.stream().max((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
	System.out.println(student);
	

	
	//找出身高超过175的学生放到新的list中
	List<Student> list1 = stuList.stream().filter(s -> s.getHeight() > 175).collect(Collectors.toList());
	
	//找出身高超过175的学生放到新的set中
	Set<Student> stuSet = stuList.stream().filter(s -> s.getHeight() > 175).collect(Collectors.toSet());
	
	//找出身高超过175的学生放到新的map中
	Map<String, Student> stuMap = stuList.stream()
	        .filter(s -> s.getHeight() > 175)
	        .distinct()
	        .collect(Collectors.toMap(a -> a.getName(), a -> a));

分组操作 Collectors.groupingBy()

	//按照年龄去进行分类，每个年龄是一个list
	Map<Integer, List<Student>> groupMap = stuList.stream().collect(Collectors.groupingBy(Student::getAge));

视频链接：Stream流入门、使用