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流入门、使用