【Java】jdk1.8新特性及用法总结
Java8新特性及用法总结
-
- 1. 接口中的实现方法
- 2. Lambda 表达式
- 3. 方法引用 ::
- 4. 函数式接口 × 4
-
-
- ① Predicate 接口（断言、返回真假）
- ② Consumer 接口（消费、有去无回）
- ③ Supplier 接口（创造、无中生有）
- ④ Function 接口（传递、返回数据）
-
- 5. Stream (流)接口 API
-
-
- 5.1 stream 基本操作
- 5.2 stream 中间操作
- 5.3 stream 终止操作
-
1. 接口中的实现方法
① 使用 default 关键字就可以给接口增加一个非抽象的方法实现；
② 接口还可以存在 static 静态方法实现，使用 接口名.静态方法名 的形式直接调用；
包括声明@FunctionalInterface限制接口只有1个抽象方法时，也可以增加①或②。
代码示例：
public class TestInterface {
public static void main(String[] args) {
TestInter ti = new TestInter() {
@Override
public void m1() {
System.out.println("m1():匿名内部类实现该接口，只需要覆盖m1()");
}
};
ti.m1();
ti.m2();
TestInter.m3();
}
}
/**
* 接口
* 测试Java8新特性，default和static在接口中定义的场景
* @FunctionalInterface 声明为函数式接口，只能有 1 个公开抽象方法
*/
@FunctionalInterface
interface TestInter {
void m1(); // 公开抽象方法
default void m2() {
System.out.println("m2():default修饰的方法实现，在接口中...");
}
public static void m3() {
System.out.println("m3():static修饰的方法实现，在接口中...");
}
}
2. Lambda 表达式
概念：允许把函数作为一个方法的参数，代码简洁紧凑（函数作为参数传递到方法中）
语法：
函数式接口 变量名 = (参数1,参数2...)->{
//方法体
};
新的操作符：-> （箭头操作符）
- 箭头操作符左侧 (参数1,参数2,…)-> 表示参数列表
- 箭头操作符右侧 ->{…} 表示方法体
Lambda 表达式特点：
- 形参列表的数据类型会自动推断
- 如果形参列表为空，只需保留()
- 如果形参列表只有1个参数，可以省略()，只要参数名字即可
- 如果执行语句只有1句，且无返回值，{}可以省略
- 若有返回值，仍想省略{}，return也省略，必须保证执行语句为1句
- Lambda表达式不会生成单独的内部类.class文件
- Lambda表达式访问局部变量时，变量要修饰为 final，如果没加会隐式自动添加
示例代码：
public class TestBasicLambda {
public static void main(String[] args) {
// 普通方式
List<String> list1 = Arrays.asList("aaa", "ddd", "ccc", "bbb");
list1.sort(new Comparator<String>() {
@Override // 按首字符排序规则
public int compare(String o1, String o2) {
return o1.charAt(0) > o2.charAt(0) ? 1 : -1;
}
});
System.out.println(list1); // aaa bbb ccc ddd
// Lambda表达式方式：实现接口中唯一1个方法的匿名内部类
List<String> list2 = Arrays.asList("aaa", "ddd", "ccc", "bbb");
list2.sort( (s1, s2)->{
return s1.charAt(0)>s2.charAt(0) ? 1 : -1; });
System.out.println(list2); // aaa bbb ccc ddd
}
}
3. 方法引用 ::
Lambda表达式的一种简写形式。
如果Lambda表达式方法体中只是调用一个特定的已存在的方法，则可以使用方法引用。
使用 :: 操作符将对象或类和方法的名字分割开，有 4 种形式：
① 对象::实例方法
② 类::静态方法
③ 类::实例方法
④ 类::new
注意：调用的方法的参数列表与返回值类型，都与函数式接口中的方法参数列表与返回值类型一致。
代码示例（使用到了函数式编程的 4 个核心接口）：
public class TestMethodRef {
public static void main(String[] args) {
// Lambda表达式简化了匿名内部类，方法引用简化了Lambda表达式
// 1.对象::方法名
Consumer<String> con = (s)->System.out.println(s); // lambda
con.accept("hello,world"); // hello,world
Consumer<String> con2 = System.out::println; // 方法引用
con2.accept("哈哈哈"); // 哈哈哈
// String也可以是自定义类
String s = new String("hello,world");
//Supplier sup = ()->s.length(); // lambda
Supplier<Integer> sup = s::length; // 方法引用
System.out.println(sup.get()); // 11
// 2.类名::静态方法(不常用)
//Comparator com = (x,y)->Integer.compare(x,y); // lambda
Comparator<Integer> com = Integer::compare; // 方法引用
System.out.println( com.compare(1, 2) ); // -1: 1 < 2
TreeSet<Integer> ts = new TreeSet<Integer>(com);
System.out.println(ts); // ts就会遵循com指向的 Integer中的Compare方法进行排序
// 3.类名::实例方法名
//Function fun = s->s.hashCode(); // lambda
Function<String, Integer> fun = String::hashCode; // 方法引用
Integer hash = fun.apply(s);
System.out.println(hash); // 2137655864
// 4.类::new 即 类名::构造方法
//Supplier supp = ()->new String(); // lambda
Supplier<String> supp = String::new; // 方法引用
System.out.println(supp.get().getClass()); // class java.lang.String
}
}
4. 函数式接口 × 4
函数式编程：函数的参数也是函数，函数返回的也是函数。
概念：如果一个接口只有 1 个公开抽象方法，则该接口为函数式接口。
- 为了确保接口达到只有1个方法的要求，接口名上添加注解 @FunctionalInterface
- Java8内置 4 个核心函数式接口interface。
位置：java.util.function
public class TestMethodInterface {
public static void main(String[] args) {
// 接口引用 指向 Lambda表达式的匿名内部类对象
Interface t = ()->System.out.println("函数式编程...");
t.m(); // 函数式编程...
}
}
@FunctionalInterface
interface Interface {
void m();
}
① Predicate 接口（断言、返回真假）
根据赋值的Lambda表达式逻辑，用作一个参数的断言（布尔值函数）
成员方法：
boolean test(T t)
在给定的参数上执行这个断言逻辑。
default Predicate<T> and(Predicate<? super T> other)
返回一个组合的断言，表示该断言与另一个断言的短路逻辑AND。
static <T> Predicate<T> isEqual(Object targetRef)
返回根据 Objects.equals(Object, Object)测试两个参数是否相等的 断言 。
default Predicate<T> negate()
返回表示此断言的逻辑否定的断言。
default Predicate<T> or(Predicate<? super T> other)
返回一个组合的断言，表示该断言与另一个断言的短路逻辑或。
基本使用：
Predicate<String> p1 = str -> str.length() == 9; // 字符串长度是否等于9
Predicate<String> p2 = str -> str.startsWith("j"); // 是否以j开头
Predicate<String> p3 = p1.and(p2); // 字符串是否长度为9并且以j开头
Predicate<String> p4 = p1.or(p2); // 字符串是否长度为9或者以j开头
Predicate<String> p5 = p1.negate(); // 字符串长度是否不等于9
Predicate<String> p6 = Predicate.isEqual("Java"); // 字符串是否等于Java
System.out.println(p1.test("aaa")); // false
System.out.println(p2.test("java")); // true
System.out.println(p3.test("jjjaaabbb"));// true
System.out.println(p4.test("ja"));// true
System.out.println(p5.test("123456789"));// false
System.out.println(p6.test("java"));// false
函数传参：
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
public class TestPredicate {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("zhangsan");
list.add("lisi");
list.add("wangwu");
list.add("zhaoliu");
list.add("zhangqi");
// Predicate断言：过滤出来已zhang开头的元素
List<String> ls = filter(list, (s)->s.startsWith("zhang"));
for (String string : ls) {
System.out.print(string + " "); // zhangsan zhangqi
}
}
public static List<String> filter(List<String> list, Predicate<String> p) {
List<String> l = new ArrayList<String>();
for (String s : list) {
if (p.test(s)) {
l.add(s);
}
}
return l;
}
}
② Consumer 接口（消费、有去无回）
根据赋值的Lambda表达式逻辑，接受单个输入参数并且不返回结果的操作。
成员方法：
void accept(T t)
对给定的参数执行此操作。
default Consumer<T> andThen(Consumer<? super T> after)
返回一个组合的 Consumer ，按顺序执行该操作，然后执行 after操作。
基本使用：
// 消费：给其内容，不关心其作何使用，没有返回值
Consumer<String> c = s->System.out.println(s);;
c.accept("hello world!"); // hello world!
// andThen后执行
c.andThen(s->System.out.println("hello," + s)).accept("world"); // world hello,world
函数传参：
import java.util.function.Consumer;
public class TestConsumer {
public static void main(String[] args) {
m1(100, (a)->System.out.println("今天挣钱了：" + a)); // 今天挣了100
m2(10, (a)->{
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
}); // 0 1 2 3 4 5 6 7 8 9
}
public static void m1(double money, Consumer<Double> consumer) {
consumer.accept(money);
}
public static void m2(int num, Consumer<Integer> consumer) {
consumer.accept(num);
}
}
③ Supplier 接口（创造、无中生有）
根据赋值的Lambda表达式逻辑，根据只有1个抽象方法T get()，没有参数，返回一个T类型的结果。
成员方法：
T get()
获得结果。
基本使用：
Supplier<Double> sup = ()->new Double(Math.random());
System.out.println( sup.get() ); // 输出1个随机<1的小数
函数传参：
import java.util.Random;
import java.util.function.Supplier;
public class TestSupplier {
public static void main(String[] args) {
int result = getSum(10, ()->new Random().nextInt(100));
System.out.println(result); // 10个100以内随机整数的和
Supplier<Integer> sup = ()->{
int sum = 0;
for (int i = 0; i <= 100; i++) {
sum += i;
}
return sum;
};
System.out.println("1-100的和：" + sup.get()); // 5050
}
public static int getSum(int num, Supplier<Integer> supplier) {
int sum = 0;
for (int i = 0; i <= num; i++) {
sum += supplier.get();
}
return sum;
}
}
④ Function 接口（传递、返回数据）
根据赋值的Lambda表达式逻辑，计算T类型的值，返回R类型的值。
成员方法：
R apply(T t)
将此函数应用于给定的参数。
default <V> Function<T,V> andThen(Function<? super R,? extends V> after)
返回一个组合函数，首先将该函数应用于其输入，然后将 after函数应用于结果。
default <V> Function<V,R> compose(Function<? super V,? extends T> before)
返回一个组合函数，首先将 before函数应用于其输入，然后将此函数应用于结果。
static <T> Function<T,T> identity()
返回一个总是返回其输入参数的函数。
基本使用：
// String 为传入 Lambda 表达式参数的类型T，Integer 为返回值的类型R
Function<String, Integer> up1 = (s)->s.length();
System.out.println( up1.apply("hello") ); // 5
// 将 up1 的 lambda 运行后，作为结果再执行 up2，组合在一起
Function<String, String> up2 = (s)->"aaa" + s;
System.out.println( up1.compose(up2).apply("12345") ); // 3+5==8
// 将 up2 的 lambda 运行后，作为结果然后再执行 apply
Function<String, String> up3 = (s)->"bbb" + s;
System.out.println( up3.andThen(up2).apply("11111") ); // aaabbb11111
// identity() 静态方法，总是返回其输入的参数
Function<String, String> up4 = Function.identity();
System.out.println( up4.apply("Jerry") );
函数传参：
import java.util.function.Function;
public class TestFunction {
public static void main(String[] args) {
String up = stringUpper("hello,world", (s)->s.toUpperCase());
System.out.println(up); // HELLO,WORLD
}
public static String stringUpper(String s, Function<String, String> fun) {
return fun.apply(s);
}
}
5. Stream (流)接口 API
Stream 接口: 支持对一系列元素进行顺序和并行的聚合操作功能接口，是Java8中处理数组、集合的抽象概念。
- 可以执行非常复杂的查找、过滤、映射等操作。
public interface Stream<T>
extends BaseStream<T,Stream<T>>
5.1 stream 基本操作
public class TestStream {
public static void main(String[] args) {
// Stream --> 数组、集合
List<String> list = Arrays.asList("zhangsan", "lisi", "wangwu", "zhaoliu", "lucy");
// Stream 中存储的是数据的操作，自身不保存数据。
// 1.创建 Stream
Stream<String> stream = list.stream();
// 2.中间操作
Stream<String> center = stream.filter((s)->s.length()>=5);
// 3.最终操作
System.out.println("名字长度>=5的是：");
center.forEach(System.out::println);
// 一行套娃版：
System.out.println();
list.stream().filter(s->s.length()>=5).forEach(System.out::println);
}
}
// zhangsan wangwu zhaoliu
5.2 stream 中间操作
常用API： filter limit distinct map sorted
Stream<T> filter(Predicate<? super T> predicate)
返回由与此给定谓词匹配的此流的元素组成的流。
Stream<T> limit(long maxSize)
返回由此流的元素组成的流，截短长度不能超过 maxSize 。
Stream<T> distinct()
返回由该流的不同元素（根据 Object.equals(Object) ）组成的流。
<R> Stream<R> map(Function<? super T,? extends R> mapper)
返回由给定函数应用于此流的元素的结果组成的流。
Stream<T> sorted()
返回由此流的元素组成的流，根据自然顺序排序。
Stream<T> sorted(Comparator<? super T> comparator)
返回由该流的元素组成的流，根据提供的 Comparator进行排序。
中间操作示例：
public class TestStreamAPI {
public static void main(String[] args) {
List<String> list = Arrays.asList("zhangsan", "lisi", "wangwu", "zhaoliu", "zuee", "zhangsan");
// filter：过滤，指定规则
System.out.println("--------------filter---------------");
list.stream().filter(s->s.startsWith("z")).filter(s->s.contains("an")).forEach(System.out::println); // zhangsan ×2
// limit：截断，返回不超过指定数量
System.out.println("--------------limit---------------");
list.stream().limit(2).forEach(System.out::println); // zhangsan lisi
// distinct：筛选，利用 hashCode 和 equals，不会影响原数据
System.out.println("--------------distinct---------------");
List<String> ls = new ArrayList<String>();
list.stream().distinct().forEach(s->ls.add(s));
ls.stream().forEach(System.out::println); // 过滤掉了重复的1个 zhangsan
// map：给到T返回R，自动推断类型。不是集合！不是集合！不是集合！
System.out.println("--------------map---------------");
list.stream().map(s->s.toUpperCase()).forEach(System.out::println); // 全转大写
list.stream().map(String::toUpperCase).forEach(System.out::println); // 全转大写(方法引用)
// sorted：自然排序，默认升序(基本类型直接排序，引用类型需要实现 Comparable 接口中的 compareTo)
System.out.println("--------------sorted---------------");
list.stream().sorted().forEach(System.out::println);
System.out.println("--------------sorted()---------------");
// sorted(Comparator comparator)：定制排序
list.stream().sorted((x,y)->x.charAt(0) - y.charAt(0)).forEach(System.out::println); // 实现 Comparable 接口的匿名内部类
}
}
5.3 stream 终止操作
常用API： count forEach anyMatch allMatch noneMatch findFirst findAny min max
long count()
返回流中的元素个数。
void forEach(Consumer<? super T> action)
对此流的每个元素执行遍历操作。
boolean anyMatch(Predicate<? super T> predicate)
或，流中是否有包含指定规则的元素
boolean allMatch(Predicate<? super T> predicate)
且，流中是否全部包含指定规则的元素
boolean noneMatch(Predicate<? super T> predicate)
非，流中是否都不包含指定规则的元素
Optional<T> findFirst()
返回流的第一个元素的Optional，如果流为空，则返回一个空的Optional 。
Optional<T> findAny()
返回流的任意一个随机元素的Optional，如果流为空，则返回一个空的Optional 。
Optional<T> max(Comparator<? super T> comparator)
根据提供的 Comparator 返回此流的最大元素。
Optional<T> min(Comparator<? super T> comparator)
根据提供的 Comparator 返回此流的最小元素。
终止操作示例：
public class TestStreamEnd {
public static void main(String[] args) {
List<String> list = Arrays.asList("changsan", "lisi", "wangwu", "zhaoliu", "zuee");
// 1.forEach: 遍历
list.stream().forEach(System.out::println); // changsan lisi wangwu zhaoliu zuee
// 2.count: 流中元素的个数
long count = list.stream().filter(s->s.length()>4).count();
System.out.println("流中长度>4元素个数：" + count); // 3
// 3.anymatch: 或，是否有包含的元素
boolean bool1 = list.stream().filter(s->s.length()>4).anyMatch(s->s.startsWith("w"));
System.out.println("流中是否是有包含 w 开头的元素：" + bool1); // true
// 4.allmatch: 且，是否全部都包含的元素
boolean bool2 = list.stream().filter(s->s.length()>4).allMatch(s->s.startsWith("w"));
System.out.println("流中是否全是包含 w 开头的元素：" + bool2); // false
// 5.noneMatch: 非，是否没有匹配的元素
boolean bool3 = list.stream().filter(s->s.length()>4).noneMatch(s->s.startsWith("a"));
System.out.println("流中是否没有包含 a 开头的元素：" + bool3); // true
// 6.findFirst: 返回流中第一个元素
String s1 = list.stream().filter(s->s.length()>4).findFirst().get();
System.out.println("流中的第一个元素是：" + s1); // changsan
// 7.findAny: 返回流中任意一个元素
String s2 = list.stream().findAny().get();
String s3 = list.parallelStream().findAny().get(); // 并行流
System.out.println("流中的随机1个元素是：" + s2 + " " + s3); // changsan wangwu
// 8.max/min: 返回流中的一个最大/最小的元素，需要在max/min中指定 Comparable 接口的比较规则
String max = list.stream().max((e1, e2)->e1.charAt(0)-e2.charAt(0)).get();
System.out.println("首字母最大的是：" + max); // zhaoliu
}
}
串行与并行的 Stream 效率对比：
public class TestStreamOther {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
for (int i = 0; i < 1000000; i++) {
list.add(UUID.randomUUID().toString());
}
// stream串行：一条执行路径，单线程
System.out.println("串行运行时间：");
long start = System.currentTimeMillis();
long count = list.stream().sorted().count();
System.out.println("排序的元素数量：" + count);
System.out.println("用时：" + (System.currentTimeMillis() - start)); // ≈1050毫秒
// parallelStream 并行：多条执行路径，多线程
System.out.println("并行运行时间：");
start = System.currentTimeMillis();
count = list.parallelStream().sorted().count();
System.out.println("排序的元素数量：" + count);
System.out.println("用时：" + (System.currentTimeMillis() - start)); // ≈520毫秒
}
}