今天简单聊一下Stream的前世今生。
Lambda表达式我们现在已经用的很多了,而函数式接口则是为了支持Lambda表达式,Java8提供了很多内置的函数式接口,如Runnable,Comparator等是从原有的API升级来的,而有些是Java8新增的,如Consumer等。
@FunctionalInterface public interface Runnable { public abstract void run(); }
类上有注解@FunctionalInterface就可以认为这是一个函数式接口,可以用在Lambda表达式中。Lambda表达式极大的简化了我们的编程
// jdk1.8之前 new Thread(new Runnable() { @Override public void run() { System.out.println("yes"); } }).start(); // jdk1.8及以后 new Thread(() -> System.out.println("yes")).start();
为了方便我们使用Lambda表达式,Java8提供了一些内置的函数式接口
函数式接口 | 方法 | 用途 |
---|---|---|
Consumer<T> 消费型接口 | void accept(T t) | 输入参数为T,没有返回 |
Supplier 供给型接口 | T get() | 返回R |
Function<T, R> 函数型接口 | R apply(T t) | 输入参数为T,返回为R |
Predicate 判断型接口 | boolean test(T t) | 对象是否满足条件,true为满足,false为不满足 |
我举个例子你就明白了。
@Data @AllArgsConstructor public class Person { private String name; private int age; private int salary; }
员工对象为Person,此时老板发话了,给我找出年龄大于20的员工把,于是就有了下面的方法
public List<Person> filterByAge(List<Person> personList) { List<Person> resultList = Lists.newArrayList(); for (Person person : personList) { if (person.getAge() > 20) { resultList.add(person); } } return resultList; }
干的不错,再给我找一下工资大于2000的员工把。
public List<Person> filterBySalary(List<Person> personList) { List<Person> resultList = Lists.newArrayList(); for (Person person : personList) { if (person.getSalary() > 2000) { resultList.add(person); } } return resultList; }
再给我找一下,,, 老板等等,我需要优化一下这个实现。
你发现问题了吗?2个方法只有判断条件不同,其余的部分一模一样。而且可扩展性太差,该怎么优化呢?
额,我们可以定义一个如下的接口,判断的逻辑让接口的实现类去实现
public interface Predicate<T> { boolean test(T t); }
public List<Person> filter(List<Person> personList, Predicate<Person> predicate) { List<Person> resultList = Lists.newArrayList(); for (Person person : personList) { if (predicate.test(person)) { resultList.add(person); } } return resultList; }
上面的需求就可以用如下几行代码实现。
List<Person> filterByAgeList = filter(list, p -> p.getAge() > 20); List<Person> filterBySalaryList = filter(list, p -> p.getSalary() > 2000);
此时老板再加筛选需求也不怕了。
等等,我们定义的Predicate接口和Java8内置的函数式接口好像。 哈哈,基本上一模一样,因为类似的场景很多,所以Java8帮我们定义了一系列的接口。省的我们自己定义
函数式接口 | 方法 | 用途 |
---|---|---|
Consumer<T> 消费型接口 | void accept(T t) | 输入参数为T,没有返回 |
Supplier 供给型接口 | T get() | 返回R |
Function<T, R> 函数型接口 | R apply(T t) | 输入参数为T,返回为R |
Predicate 判断型接口 | boolean test(T t) | 对象是否满足条件,true为满足,false为不满足 |
@Test public void testCase1() { // 10 consumeTask(10, (m) -> System.out.println(m)); } public void consumeTask(int num, Consumer<Integer> consumer) { consumer.accept(num); } @Test public void testCase2() { // AAA System.out.println(strHandler("aaa", (str) -> str.toUpperCase())); } public String strHandler(String str, Function<String, String> function) { return function.apply(str); }
当然,为了方便我们的使用,还有很多其他的内置接口,看入参和返回值就能知道接口的作用
函数式接口 | 方法 |
---|---|
BiFunction<T, U, R> | R apply(T t, U u) |
BiConsumer<T, U> | void accept(T t, U u) |
ToIntFunction | int applyAsInt(T value) |
IntFunction | R apply(int value) |
在Java8之前,如果我们想对集合进行操作还是比较麻烦的。Java8设计了Stream API来简化对集合的操作,Stream API的设计基于函数式编程和lambda表达式,行云流水似的编程方式给人带来新的体验。
Stream操作分为如下三个步骤
注意当不执行终止操作的时候,中间操作不会执行
List<Integer> dataList = Arrays.asList(1, 2, 3, 4); // 没有输出 dataList.stream().map(x -> { System.out.println(x); return x;}); // 输出 1 2 3 4 // 正常是换行,我这用空格代替了,下同 dataList = dataList.stream().map(x -> { System.out.println(x); return x; }).collect(Collectors.toList());
// 1. Collection集合的stream()或者parallelStream() List<String> list = Lists.newArrayList(); Stream<String> stream1 = list.stream(); // 2. 调用Arrays.stream(T[] array)静态方法 Integer[] array = {1, 2, 3}; Stream<Integer> stream2 = Arrays.stream(array); // 3. 调用Stream.of(T... values)静态方法 Stream<String> stream3 = Stream.of("aa", "bb", "cc"); // 4. 调用Stream.iterate(final T seed, final UnaryOperator<T> f),创建无限流 // (x) -> x + 2 为函数式接口,传入x返回x+2,0为最开始的值 Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2); // 一直输出 0 2 4 6 8 10 12 ... stream4.forEach(System.out::println); // 5. 调用调用Stream.generate(),创建无限流 Stream<Integer> stream5 = Stream.generate(() -> 10); // 一直输出10,你可以用Random等类随机生成哈 stream5.forEach(System.out::println);
函数名 | 解释 |
---|---|
filter | 从流中排除某些元素 |
limit | 使元素不超过指定数量 |
skip | 跳过前n个元素,如果流中元素不超过n个,则返回一个空流 |
distinct | 通过hashCode()和equals()去除重复元素 |
List<Integer> list = Arrays.asList(1, 2, 3, 4); // 1 3 list.stream().filter(x -> x % 2 == 1).forEach(System.out::println); // 3 4 list.stream().skip(2).forEach(System.out::println);
看一下filter方法和forEach方法的定义
Stream.java
Stream<T> filter(Predicate<? super T> predicate); void forEach(Consumer<? super T> action);
这不就是我门上面介绍的函数式接口吗? 很多方法的入参其实就是一个函数式接口
函数名 | 解释 |
---|---|
map | 接收一个函数作为参数,该函数被应用到每个元素上,并将其映射成一个新的元素 |
flatMap | 接受一个函数作为参数,将流中的每一个值都转换成另一个流,然后将所有流连接成一个流 |
先看这2个方法的定义
<R> Stream<R> map(Function<? super T, ? extends R> mapper); <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
map方法的入参和返回值可以为任意值 flatMap方法的入参为任意值,返回值必须为Stream
List<String> list = Arrays.asList("abcd", "efgh"); // [Ljava.lang.String;@7b3300e5 [Ljava.lang.String;@2e5c649 list.stream().map(x -> x.split("")).forEach(System.out::println); // a b c d e f g h list.stream().flatMap(x -> Arrays.stream(x.split(""))).forEach(System.out::println);
解释一下这个输出,x.split("")后为数组,所以第一个输出的为数组的地址 第二个x.split("")后为数组,然后将数组转为多个流,将多个流合并后输出
函数名 | 解释 |
---|---|
sorted() | 自然排序,通过Comparable接口定义的规则来排序 |
sorted(Comparator) | 定制排序,通过Comparator接口定义的规则来排序 |
List<String> list = Arrays.asList("b", "a", "c"); // a b c list.stream().sorted().forEach(System.out::println); // c b a list.stream().sorted((x, y) -> y.compareTo(x)).forEach(System.out::println);
函数名 | 解释 |
---|---|
allMatch | 是否匹配所有元素 |
anyMatch | 是否至少匹配一个元素 |
noneMatch | 是否没有匹配所有元素 |
findFirst | 返回第一个元素 |
findAny | 返回当前流中的任意元素 |
count | 返回当前流中元素总个数 |
max | 返回流中最大值 |
min | 返回流中最小值 |
List<Integer> list = Arrays.asList(1, 2, 3, 4); // false // 当list都为1时才会返回true System.out.println(list.stream().allMatch(num -> num.equals(1))); // true System.out.println(list.stream().anyMatch(num -> num.equals(1))); // 4 System.out.println(list.stream().max((x, y) -> x.compareTo(y)).get());
函数名 | 解释 |
---|---|
reduce | 归约,将流中元素反复结合起来得到一个值 |
List<Integer> list = Arrays.asList(1, 2, 3, 4); int sum = list.stream().reduce(0, (x, y) -> x + y); // 10 // 初始值为0,执行过程为 // x = 0 y = 1 // x = 1 y = 2 // x = 3 y = 4 ... // 10 // 10 System.out.println(sum);
用collect方法来进行收集,方法定义如下
Stream.java
<R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner); <R, A> R collect(Collector<? super T, A, R> collector);
当然我一般不自己实现这个接口,可以直接用Collectors工具类
@Data @AllArgsConstructor public class Student { private String name; private int age; }
List<Student> studentList = Arrays.asList(new Student("张三", 30), new Student("李四", 20), new Student("王五", 20));
List<String> nameList = studentList.stream().map(Student::getName).collect(Collectors.toList()); // [张三, 李四, 王五] System.out.println(nameList); Set<Integer> ageSet = studentList.stream().map(Student::getAge).collect(Collectors.toSet()); // [20, 30] System.out.println(ageSet); LinkedHashSet<Integer> linkedHashSet = studentList.stream().map(Student::getAge).collect(Collectors.toCollection(LinkedHashSet::new)); // [30, 20] System.out.println(linkedHashSet);
// 总数 long count = studentList.stream().collect(Collectors.counting()); // 3 System.out.println(count); // 平均值 double ageAvg = studentList.stream().collect(Collectors.averagingDouble(Student::getAge)); // 23.3 System.out.println(ageAvg); // 总和 int totalAge = studentList.stream().collect(Collectors.summingInt(Student::getAge)); // 70 System.out.println(totalAge); // 最大值 Optional<Student> student = studentList.stream().collect(Collectors.maxBy((x, y) -> x.getAge() - y.getAge())); // Student(name=张三, age=30) System.out.println(student.get()); // 按照年龄分组 // 还可以多级分组,按照年龄分组后,再按照其他条件分组,不再演示 Map<Integer, List<Student>> listMap = studentList.stream().collect(Collectors.groupingBy(Student::getAge)); // {20=[StreamDemo.Student(name=李四, age=20), StreamDemo.Student(name=王五, age=20)], 30=[StreamDemo.Student(name=张三, age=30)]} System.out.println(listMap);
项目中有很多单选项需要定义相关的枚举值,前端传入后需要校验这些值是否在枚举范围内
public enum MSG_TYPE { IMAGE((byte) 0, "图片"), TEXT((byte) 1, "文本"); public final byte value; public final String name; MSG_TYPE(byte value, String name) { this.value = value; this.name = name; } }
// 模拟前端传入的参数为1 boolean isExist = Arrays.stream(MSG_TYPE.values()).anyMatch(v -> v.value == 1); // true System.out.println(isExist); isExist = Arrays.stream(MSG_TYPE.values()).anyMatch(v -> v.value == 5); // false System.out.println(isExist);
根据学生姓名获取学生的其他信息
List<Student> studentList = Lists.newArrayList(); for (int i = 0; i < 3; i++) { Student student = Student.builder().name("学生" + i).age(i).build(); studentList.add(student); } // {学生0=Student(name=学生0, age=0), 学生2=Student(name=学生2, age=2), 学生1=Student(name=学生1, age=1)} Map<String, Student> studentMap = studentList.stream().collect(Collectors.toMap(Student::getName, student -> student)); System.out.println(studentMap);
Copyright © QY Network Company Ltd. All Rights Reserved. 2003-2018 群英 版权所有 茂名市群英网络有限公司
增值电信经营许可证 : B1.B2-20140078 粤ICP备09006778号-36 粤公网安备 44090202000006号 粤工商备P091701000595