以前的程序员（知道jdk1.5的特性）：
泛型、枚举、反射和注解
新时代的程序员（因为jdk的版本都已经到13了）：
所以要在这个三个基础上，必须掌握4个：lambda表达式、链式编程、函数式接口、Stream流式计算
接口上面有@FunctionalInterface（功能接口）的注解标注
比如Runnable接口
@FunctionalInterface public interface Runnable { public abstract void run(); }
简化编程模型，在新版本的框架底层大量应用！
foreach(消费者类的函数式接口)
四大函数式接口
使用代码
package com.zxh.pool; import java.util.function.Consumer; // consumer：消费型接口：只有输入，没有输出 public class FunctionInterfaceDemo { public static void main(String[] args) { // Consumer consumer = new Consumer<String>(){ // @Override // public void accept(String str){ // System.out.println(str); // } // }; // consumer.accept("123"); // 使用lambda表达式 Consumer<String> consumer = (str)->{System.out.println(str);}; consumer.accept("123"); } }
提供型接口：没有输入，只有输出
使用代码
package com.zxh.pool; import java.util.function.Supplier; /** * 1、Consumer：消费型接口：只有输入，没有输出 * 2、Supplier：提供型接口：只有输出，没有输入 */ public class FunctionInterfaceDemo { public static void main(String[] args) { // Supplier<Integer> supplier = new Supplier<Integer>() { // @Override // public Integer get() { // return 1024; // } // }; // 使用lambda表达式 Supplier<Integer> supplier = ()->{return 1024;}; System.out.println(supplier.get()); } }
可以有输入，可以有输出
使用代码
package com.zxh.function; import java.util.function.Function; /** * 1、Consumer：消费型接口：只有输入，没有输出 * 2、Supplier：提供型接口：只有输出，没有输入 * 3、Function：有输入，也有输出 */ public class Demo03 { public static void main(String[] args) { // Function<String, String> function = new Function<String, String>() { // @Override // public String apply(String s) { // return s; // } // }; // lambda表达式 Function function = (str)->{return str;}; System.out.println(function.apply("123")); } }
断定型接口
可以输入，输出boolean类型参数
使用测试
package com.zxh.function; import java.util.function.Predicate; /** * 1、Consumer：消费型接口：只有输入，没有输出 * 2、Supplier：提供型接口：只有输出，没有输入 * 3、Function：有输入，也有输出 * 4、Predicate：断定型接口：有输入，返回布尔型 */ public class Demo04 { public static void main(String[] args) { // Predicate<String> predicate = new Predicate<String>() { // @Override // public boolean test(String str) { // return str.isEmpty(); // } // }; // 使用lambda表达式 Predicate<String> predicate = (str)->{return str.isEmpty();}; System.out.println(predicate.test("123")); System.out.println(predicate.test("")); } }
在大数据中：会有存储 + 计算
而储存的过程就交给流操作！
jdk1.8文档中有Stream接口
import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; @Data @NoArgsConstructor @AllArgsConstructor public class User { private int id; private String name; private int age; }
/** * 题目要求：一分钟内完成此题，只能用一行代码实现！ * 现在有5个用户！筛选： * 1、ID 必须是偶数 * 2、年龄必须大于23岁 * 3、用户名转为大写字母 * 4、用户名字母倒着排序 * 5、只输出一个用户！ */ public class Test { public static void main(String[] args) { User u1 = new User(1,"a",21); User u2 = new User(2,"b",22); User u3 = new User(3,"c",23); User u4 = new User(4,"d",24); User u5 = new User(6,"e",25); // 集合就是存储 List<User> users = Arrays.asList(u1, u2, u3, u4, u5); } }
Stream接口，涉及到的方法
filter()：参数Predicate，就是段定型的函数式接口
该接口的参数可以进行判断，并返回布尔型
就可以做到过滤、筛选
map()：参数Function，就是只可以指定输入输出类型的函数式接口
输入小写字母：转为大写字母并返回。
sorted()：参数Comparator，就是可以比较大小的函数式接口
该接口的参数可以传入两个相同的类型的参数，进行比较，并且返回int类型的值。
如果返回
Comparator函数式接口测试：
public class MyTest { public static void main(String[] args) { Comparator<Integer> comparator = (u1, u2)->{return u1 - u2;}; /* u1 - u2：u1和比u2是升序排列， 当 u1 - u2 < 0：也就是u1 < u2，不动 当 u1 - u2 > 0：也就是u1 > u2，换一下顺序 u2 - u1：u2和比u1是降序排列， 当 u1 - u2 < 0：也就是u1 < u2，换一下顺序 当 u1 - u2 > 0：也就是u1 > u2，不动 */ Arrays.asList(3, 1, 2).stream() .sorted((u1, u2) -> {return u1 - u2;}) .forEach(System.out::println); } }
limit()：从上往下截取截取多少个参数
// stream流式计算，管理数据 // 应用的到了：lambda表达式、函数式接口、链式编程、Stream流式计算 users.stream() .filter((u)->{return u.getId()%2==0;}) // 过滤 ID 必须是偶数 .forEach(System.out::println);
// stream流式计算，管理数据 // 应用的到了：lambda表达式、函数式接口、链式编程、Stream流式计算 users.stream() .filter((u)->{return u.getId()%2==0;}) // 过滤方法： ID 必须是偶数 .filter((u)->{return u.getAge() > 23;}) // 过滤方法： 年龄必须大于23岁 .forEach(System.out::println);
users.stream() // lambda表达式：如果参数只有一个可以省略括号 .filter((u) -> {return u.getId()%2==0;}) // 过滤方法： ID 必须是偶数 .filter(u ->{return u.getAge() > 23;}) // 过滤方法： 年龄必须大于23岁 .map(u->{u.setName(u.getName().toUpperCase()); return u;}) // 转换方法：用户名转为大写字母 .forEach(System.out::println);
users.stream() // lambda表达式：如果参数只有一个可以省略括号 .filter((u) -> {return u.getId()%2==0;}) // 过滤方法： ID 必须是偶数 .filter(u ->{return u.getAge() > 23;}) // 过滤方法： 年龄必须大于23岁 .map(u->{u.setName(u.getName().toUpperCase()); return u;}) // 转换方法：用户名转为大写字母 .sorted((uu1, uu2)->{return uu2.getName().compareTo(uu1.getName());}) // 排序方法： 用户名字母倒着排序 .forEach(System.out::println);
users.stream() // lambda表达式：如果参数只有一个可以省略括号 .filter((u) -> {return u.getId()%2==0;}) // 过滤方法： ID 必须是偶数 .filter(u ->{return u.getAge() > 23;}) // 过滤方法： 年龄必须大于23岁 .map(u->{u.setName(u.getName().toUpperCase()); return u;}) // 转换方法：用户名转为大写字母 .sorted((uu1, uu2)->{return uu2.getName().compareTo(uu1.getName());}) // 排序方法： 用户名字母倒着排序 .limit(1) // 取指定个数：输出一个用户 .forEach(System.out::println);
package com.zxh.Stream; import java.util.Arrays; import java.util.List; /** * 题目要求：一分钟内完成此题，只能用一行代码实现！ * 现在有5个用户！筛选： * 1、ID 必须是偶数 * 2、年龄必须大于23岁 * 3、用户名转为大写字母 * 4、用户名字母倒着排序 * 5、只输出一个用户！ */ public class Test { public static void main(String[] args) { User u1 = new User(1,"a",21); User u2 = new User(2,"b",22); User u3 = new User(3,"c",23); User u4 = new User(4,"d",24); User u5 = new User(6,"e",25); // 集合就是存储 List<User> users = Arrays.asList(u1, u2, u3, u4, u5); // stream流式计算，管理数据 // 应用的到了：lambda表达式、函数式接口、链式编程、Stream流式计算 users.stream() // lambda表达式：如果参数只有一个可以省略括号 .filter((u) -> {return u.getId()%2==0;}) // 过滤方法： ID 必须是偶数 .filter(u ->{return u.getAge() > 23;}) // 过滤方法： 年龄必须大于23岁 .map(u->{u.setName(u.getName().toUpperCase()); return u;}) // 转换方法：用户名转为大写字母 .sorted((uu1, uu2)->{return uu2.getName().compareTo(uu1.getName());}) // 排序方法： 用户名字母倒着排序 .limit(1) // 取指定个数：输出一个用户 .forEach(System.out::println); } }
原文：https://www.cnblogs.com/zxhbk/p/12968726.html