Lambda简介
Lambda表达式是推动 Java 8 发布的最重要新特性。Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)。使用 Lambda 表达式可以使代码变的更加简洁紧凑。
注:要使用Lambda表达式的写法类 该接口必须只有一个方法并且带有@FunctionalInterface注解
四大函数接口
1. Function<T, R>:函数型接口(R apply(T t)
package Safe;
import org.junit.jupiter.api.DynamicTest;
import java.util.function.Function;
public class Test634 {
public static void main(String[] args) {
String name = "我是老王,你是 谁 ";
String handler = handler(name, (str) -> str.substring(0, 2));
String handler1 = handler(name, (str) -> str.trim());
System.out.println(handler);
System.out.println(handler1);
}
/**
* 13 * 字符串操作
* 14 * @param str 需要处理得字符串
* 15 * @param fun Function接口
* 16 * @return 处理之后得字符传
* 17
*/
public static String handler(String str, Function<String, String> function) {
return function.apply(str);
}
}
2. Consumer:消费型接口(void accept(T t))
package Safe;
import org.junit.jupiter.api.DynamicTest;
import java.util.function.Consumer;
import java.util.function.Function;
public class Test634 {
public static void main(String[] args) {
//吃冰糕 一次1快
consumo(10, (money) -> {
money--;
System.out.println(money);
});
}
public static void consumo(double money, Consumer<Double> c) {
c.accept(money);
}
}
3.Supplier:供给型接口(T get())
package Safe;
import org.junit.jupiter.api.DynamicTest;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
public class Test634 {
public static void main(String[] args) {
Random ran = new Random();
List<Integer> list = supplier(10, () -> ran.nextInt(10));
for (Integer i : list) {
System.out.println(i);
}
}
/**
* 随机产生sum个数量得集合
*
* @param sum 集合内元素个数
* @param sup
* @return
*/
public static List<Integer> supplier(int sum, Supplier<Integer> sup) {
List<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < sum; i++) {
list.add(sup.get());
}
return list;
}
}
4.Predicate:断言型接口(boolean test(T t))
package Safe;
import org.junit.jupiter.api.DynamicTest;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
public class Test634 {
public static void main(String[] args) {
List<Integer> l = new ArrayList<>();
l.add(102);
l.add(172);
l.add(13);
l.add(82);
l.add(109);
List<Integer> list = filterInt(l, x -> (x > 100));
for (Integer integer : list) {
System.out.println(integer);
}
}
/**
* 过滤集合
*
* @param list
* @param pre
* @return
*/
public static List<Integer> filterInt(List<Integer> list, Predicate<Integer> pre) {
List<Integer> l = new ArrayList<>();
for (Integer integer : list) {
if (pre.test(integer))
l.add(integer);
}
return l;
}
}
Stream流介绍
Stream API可以极大提高Java程序员的生产力,让程序员写出高效率、干净、简洁的代码。 流在管道中传输,可以简洁高效的用一串代码进行筛选、排序、聚合、分组、去重等操作。
Stream对流的操作分为两种:
- 中间操作,每次返回一个新的流,可以有多个。
- 终端操作,每个流只能进行一次终端操作,终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值。
Stream有几个特性:
- stream不存储数据,而是按照特定的规则对数据进行计算,一般会输出结果。
- stream不会改变数据源,通常情况下会产生一个新的集合或一个值。
- stream具有延迟执行特性,只有调用终端操作时,中间操作才会执行。
创建流
List<String> list = Arrays.asList("a", "b", "c");
// 创建一个顺序流
Stream<String> stream = list.stream();
// 创建一个并行流
Stream<String> parallelStream = list.parallelStream();
stream和parallelStream的区分:
-
stream:stream是顺序流,由主线程按顺序对流执行操作。
-
parallelStream是并行流,内部以多线程并行执行的方式对流进行操作,但前提是流中的数据处理没有顺序要求
对数据处理顺序没有要求用parallelStream 性能快,如果要按照流程来需要用stream
Stream示例操作
注意:为了防止流操作返回空对象避免空指针异常,数据都会由Optional 类包裹,如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。
测试数据
@Data
@NoArgsConstructor
@AllArgsConstructor
class Student {
private String name;
private String sex;
private Integer age;
private String school;
private String myclass;
private String chinesPoints;
private String mathPoints;
private String englishPoints;
public List<Student> getData() {
List<Student> data = new ArrayList<Student>();
data.add(new Student("老王", "男", 18, "二中", "A班", "98", "28", "37"));
data.add(new Student("老黑", "女", 28, "二中", "B班", "44", "25", "77"));
data.add(new Student("老白", "男", 41, "二中", "A班", "44", "88", "100"));
data.add(new Student("老紫", "女", 18, "一中", "A班", "98", "28", "37"));
data.add(new Student("老蓝", "男", 28, "一中", "A班", "100", "100", "100"));
data.add(new Student("老橙", "男", 38, "一中", "B班", "98", "28", "37"));
return data;
}
}
class Person {
private String name; // 姓名
private int salary; // 薪资
private int age; // 年龄
private String sex; //性别
private String area; // 地区
// 构造方法
public Person(String name, int salary, int age,String sex,String area) {
this.name = name;
this.salary = salary;
this.age = age;
this.sex = sex;
this.area = area;
}
}
4.1 遍历/匹配(foreach/find/match)
public static void main(String[] args) {
Student student = new Student();
List<Student> data = student.getData();
//遍历
data.stream().forEach(datas -> {
System.out.println(datas.getName());
});
// 获取第一个元素
Student student1 = data.stream().findFirst().get();
// 获取任意一个值(适用于并行流)
Student student2 = data.parallelStream().findAny().get();
boolean b = data.stream().anyMatch(sures -> sures.getEnglishPoints().equals("100"));
System.out.println("获取第一个值" + student1.getName());
System.out.println("获取任意一个值" + student2.getName());
System.out.println("是否有英语满分的人嘛" + b);
}
4.2 筛选(filter)
public static void main(String[] args) {
Student student = new Student();
List<Student> data = student.getData();
//英语满分100的人名
data.stream().filter(datas -> Integer.valueOf(datas.getEnglishPoints()) >= 100).forEach(datas -> System.out.println(datas.getName()));
}
4.3 聚合(max/min/count)
public static void main(String[] args) {
Student student = new Student();
List<Student> data = student.getData();
//获取数学考的最好的人(自定义排序 data1在前是升序,,data1在后是降序)
String name = data.stream().max((data1, data2) -> Integer.valueOf(data1.getMathPoints()).compareTo(Integer.valueOf(data2.getMathPoints()))).get().getName();
String names = data.stream().min((data1, data2) -> Integer.valueOf(data1.getMathPoints()).compareTo(Integer.valueOf(data2.getMathPoints()))).get().getName();
long count = data.stream().filter(datas -> datas.getEnglishPoints().equals("100")).count();
System.out.println("获取数学考的最好的人"+name);
System.out.println("获取数学考的最差的人"+names);
System.out.println("英语考满分的人有"+count);
}
4.4 映射(map/flatMap)
- map:接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素。
- flatMap:接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流。
public static void main(String[] args) {
Student student = new Student();
List<Student> data = student.getData();
//获取所有人的名字 map
List<String> collect = data.stream().map(datas -> datas.getName()).collect(Collectors.toList());
System.out.println(collect);
//flatMap
List<String> datass = new ArrayList<>();
datass.add("A-b-c-c-l");
datass.add("C-CS-S-ss-S");
List<String> collect1 = datass.stream().flatMap(datas -> {
String[] split = datas.split("-");
return Arrays.stream(split);
}).collect(Collectors.toList());
System.out.println(collect1);
}
4.5归约(reduce)
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4);
// 求和方式1
Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
// 求和方式2
Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
// 求和方式3
Integer sum3 = list.stream().reduce(0, Integer::sum);
// 求乘积
Optional<Integer> product = list.stream().reduce((x, y) -> x * y);
// 求最大值方式1
Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
// 求最大值写法2
Integer max2 = list.stream().reduce(1, Integer::max);
System.out.println("list求和:" + sum.get() + "," + sum2.get() + "," + sum3);
System.out.println("list求积:" + product.get());
System.out.println("list求和:" + max.get() + "," + max2);
}
4.6 收集(collect)
4.6.1 归集(toList/toSet/toMap)
public static void main(String[] args) {
Student student = new Student();
List<Student> data = student.getData();
//获取所有的名字
List<String> collect = data.stream().map(datas -> datas.getName()).collect(Collectors.toList());
//去重获取所有的学校
Set<String> collect1 = data.stream().map(datas -> datas.getSchool()).collect(Collectors.toSet());
//转map结构
Map<String, List<Student>> collect2 = data.stream().collect(Collectors.toMap(dats -> dats.getName(), dats -> data));
}
4.6.2 统计(count/averaging)
Collectors提供了一系列用于数据统计的静态方法:
- 计数:count
- 平均值:averagingInt、averagingLong、averagingDouble
- 最值:maxBy、minBy
- 求和:summingInt、summingLong、summingDouble
- 统计以上所有:summarizingInt、summarizingLong、summarizingDouble
案例:统计员工人数、平均工资、工资总额、最高工资。
public static void main(String[] args) {
Student student = new Student();
List<Student> data = student.getData();
Long collect = data.stream().collect(Collectors.counting());
Double collect1 = data.stream().collect(Collectors.averagingDouble(dats -> Integer.valueOf(dats.getEnglishPoints())));
Integer integer = data.stream().map(dats -> Integer.valueOf(dats.getChinesPoints())).collect(Collectors.maxBy(Integer::compare)).get();
Integer sum = data.stream().map(dats -> Integer.valueOf(dats.getChinesPoints())).collect(Collectors.summingInt(dars-> dars));
//一次性统计所有信息 count sum min max
DoubleSummaryStatistics collec = data.stream().collect(Collectors.summarizingDouble(dars-> Integer.valueOf(dars.getEnglishPoints())));
System.out.println("所有员工的数量"+collect);
System.out.println("求英语的平均成绩"+collect1);
System.out.println("求语文成绩最高"+integer);
System.out.println("语文求和"+sum);
}
4.6.3 分组(partitioningBy/groupingBy)
- partitioningBy 分区:将stream按条件分为两个Map,比如员工按薪资是否高于8000分为两部分。
- groupingBy分组:将集合分为多个Map,比如员工按性别分组。有单级分组和多级分组。
public static void main(String[] args) {
Student student = new Student();
List<Student> data = student.getData();
//将语文大于50的人进行分组 大于50 的是一组 小于50 的是一组
Map<Boolean, List<Student>> collect = data.stream().collect(Collectors.partitioningBy(x -> Integer.valueOf(x.getChinesPoints()) > 50));
//根据学校进行分组
Map<String, List<Student>> collect1 = data.stream().collect(Collectors.groupingBy(datas -> datas.getSchool()));
//根据学校班级进行分组
Map<String, Map<String, List<Student>>> collect2 = data.stream().collect(Collectors.groupingBy(datas -> datas.getSchool(), Collectors.groupingBy(datas -> datas.getMyclass())));
}
4.7 排序(sorted)
sorted,中间操作。有两种排序:
- sorted():自然排序,流中元素需实现Comparable接口
- sorted(Comparator com):Comparator排序器自定义排序
案例:将员工按工资由高到低(工资一样则按年龄由大到小)排序
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Sherry", 9000, 24, "female", "New York"));
personList.add(new Person("Tom", 8900, 22, "male", "Washington"));
personList.add(new Person("Jack", 9000, 25, "male", "Washington"));
personList.add(new Person("Lily", 8800, 26, "male", "New York"));
personList.add(new Person("Alisa", 9000, 26, "female", "New York"));
// 按工资升序排序(自然排序)
List<String> newList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName)
.collect(Collectors.toList());
// 按工资倒序排序
List<String> newList2 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed())
.map(Person::getName).collect(Collectors.toList());
// 先按工资再按年龄升序排序
List<String> newList3 = personList.stream()
.sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge)).map(Person::getName)
.collect(Collectors.toList());
// 先按工资再按年龄自定义排序(降序)
List<String> newList4 = personList.stream().sorted((p1, p2) -> {
if (p1.getSalary() == p2.getSalary()) {
return p2.getAge() - p1.getAge();
} else {
return p2.getSalary() - p1.getSalary();
}
}).map(Person::getName).collect(Collectors.toList());
System.out.println("按工资升序排序:" + newList);
System.out.println("按工资降序排序:" + newList2);
System.out.println("先按工资再按年龄升序排序:" + newList3);
System.out.println("先按工资再按年龄自定义降序排序:" + newList4);
}
}
4.8 提取/组合
public static void main(String[] args) {
String[] arr1 = { "a", "b", "c", "d" };
String[] arr2 = { "d", "e", "f", "g" };
Stream<String> stream1 = Stream.of(arr1);
Stream<String> stream2 = Stream.of(arr2);
// concat:合并两个流 distinct:去重
List<String> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());
// limit:限制从流中获得前n个数据
List<Integer> collect = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
// skip:跳过前n个数据
List<Integer> collect2 = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());
System.out.println("流合并:" + newList);
System.out.println("limit:" + collect);
System.out.println("skip:" + collect2);
}