1 Java 8 新特性简介
Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本。Java 8 是oracle公司于2014年3月发布,可以看成是自Java 5 以来最具革命性的版本。 Java 8为Java语言、编译器、类库、开发工具与JVM带来了大量新特性。
2 Lambda表达式
Lambda 是一个匿名函数,可以把 Lambda 表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格,使Java的语言表达能力得到了提升。
语法:
操作符为 “->” , 该操作符被称为 Lambda 操作符或箭头操作符。它将 Lambda 分为两个部分:
- 匿名内部类实现的接口一定是函数接口(只有一个抽象方法的接口)
- 左侧: 指定了 Lambda 表达式需要的参数列表
- 右侧: 指定了 Lambda 体, 是抽象方法的实现逻辑,也即Lambda 表达式要执行的功能。
从匿名类到 Lambda 的转换示例1
public class LambDaDemo {
public static void main(String[] args) {
// Runnable myTask = new Runnable() {
// @Override
// public void run() {
// for (int i = 1; i <= 100; i++) {
// System.out.println(Thread.currentThread().getName() + " " + i);
// }
// }
// };
Runnable myTask = () -> {
for (int i = 1; i <= 100; i++) {
System.out.println(Thread.currentThread().getName() + " " + i);
}
};
for (int i = 0; i < 4; i++) {
new Thread(myTask).start();
}
System.out.println("main task");
}
}
从匿名类到 Lambda 的转换示例2
public class LambDaDemo1 {
public static void show(A a) {
a.f1();
}
public static void main(String[] args) {
// A a = new A() {
// @Override
// public void f1() {
// System.out.println("a f1");
// }
//
// @Override
// public void f2() {
// System.out.println("a f2");
// }
//
// };
// show(a);
//如果2个抽象方法不能使用lambda表达式
show(() -> {
System.out.println("a lambda f1");
});
}
@FunctionalInterface
interface A {
void f1();
}
interface B {
void f2();
}
}
类型推断:
Lambda 表达式中的参数类型都是由编译器推断得出的。 Lambda表达式中无需指定类型,程序依然可以编译,这是因为 javac 根据程序的上下文,在后台推断出了参数的类型。 Lambda 表达式的类型依赖于上下文环境,是由编译器推断出来的。这就是所谓的“类型推断” 。
一个参数语法:
public class LamDaDemo3 {
/**
* 一个参数的语法
*/
public static void show(B b) {
b.f1("hello lambda 表达式");
}
/**
* 匿名内部类
*/
@Test
public void test1() {
//匿名内部类
B b = new B() {
@Override
public void f1(String s) {
System.out.println(s);
}
};
show(b);
}
/**
* lambda表达式
*/
@Test
public void test2() {
show((String str) -> {
System.out.println(str);
});
}
/**
* lambda表达式左边参数列表,可以根据上下文判断参数类型
*/
@Test
public void test3() {
show((str) -> {
str += " hello abc";
System.out.println(str);
});
}
/**
* 只有一个参数
*/
@Test
public void test4() {
show(str -> {
str += " hello abc";
System.out.println(str);
});
}
@FunctionalInterface
interface B {
void f1(String s);
}
}
两个参数语法:
public class LambDaDemo4 {
public static void show(C c) {
c.f1(10, 20);
}
@Test
public void test1(){
show((x, y) -> {
System.out.println(x>y ? x : y);
});
}
@FunctionalInterface
interface C {
void f1(int x, int y);
}
}
3 函数式接口
在Java中,任何拥有单个抽象方法的接口都可以被认为是函数式接口。为了确保一个接口是函数式接口,可以使用@FunctionalInterface
注解进行标记。这个注解不是强制性的,但它可以帮助编译器检查接口是否满足函数式接口的要求。
Java从诞生日起就是一直倡导“一切皆对象”, 在Java里面面向对象(OOP)编程是一切。但是随着python、 scala等语言的兴起和新技术的挑战, Java不得不做出调整以便支持更加广泛的技术要求,也即Java不但可以支持OOP还可以支持OOF(面向函数编程)。
在函数式编程语言当中,函数被当做一等公民对待。在将函数作为一等公民的编程语言中, Lambda表达式的类型是函数。但是在Java8中,有所不同。在Java8中, Lambda表达式是对象,而不是函数,它们必须依附于一类特别的对象类型——函数式接口。
简单的说,在Java8中, Lambda表达式就是一个函数式接口的实例。 这就是Lambda表达式和函数式接口的关系。也就是说,只要一个对象是函数式接口的实例,那么该对象就可以用Lambda表达式来表示。 所以以前用匿名实现类表示的现在都可以用Lambda表达式来写 。
函数式接口的特点:
- 只有一个抽象方法。
- 可以有默认方法和静态方法。
- 可以用Lambda表达式来创建该接口的实例。
- 可以使用方法引用来引用接口的实例。
以下是一个简单的函数式接口的示例:
@FunctionalInterface
public interface MyInterface {
void method1();
default void method2();
}
Java 内置函数式接口:
1.Predicate< T >:断定型接口,接受一个输入参数,返回一个布尔值结果。常用于过滤操作。
public class PredicateTest {
public static List<String> filterList(List<String> list, Predicate<String> p) {
List<String> result = new ArrayList<>();
for (String s : list) {
if (p.test(s)) { //对s进行判断
result.add(s);
}
}
return result;
}
@Test
public void test() {
List<String> list = new ArrayList<>();
list.add("welcome abc");
list.add("hello world");
list.add("你好 abc");
list.add("hello mickey");
filterList(list, s -> {
return s.contains("hello");
}).forEach(s -> System.out.println(s));
}
}
结果:
hello world
hello mickey
2.Consumer< T >:消费接口,接受一个输入参数,没有返回值。常用于对输入参数进行处理。
public class ConsumerTest {
@Test
public void test1(){
List<User> list = new ArrayList<>();
list.add(new User(1,"kong",20));
list.add(new User(2,"de",18));
list.add(new User(4,"dai",19));
Consumer<User> consumer = o -> System.out.println(o);
list.forEach(consumer);
}
@Test
public void test2() {
Consumer<String> c = s -> System.out.println(s);
Consumer<String> c2 = s -> {
System.out.println(s.substring(6));
};
c.accept("hello world");
c2.accept("hello world");
}
public void f1(Consumer<Double> c, Double money) {
c.accept(money);
}
@Test
public void test3(){
f1(m -> {
DecimalFormat decimalFormat = new DecimalFormat("#,###.##");
System.out.println(decimalFormat.format(m));
},15489526.9856);
f1(m -> {
DecimalFormat decimalFormat = new DecimalFormat("0,000.000");
System.out.println(decimalFormat.format(m));
},15489526.9856);
}
}
test1结果:
User{id=1, name='kong', age=20}
User{id=2, name='de', age=18}
User{id=4, name='dai', age=19}
test2结果:
hello world
world
test3结果:
15,489,526.99
15,489,526.986
3.Function<T, R>:函数接口,接受一个输入参数,返回一个结果。常用于映射或转换操作。
public class FunctionTest {
public Object performUser(Function<User, Object> f, User u) {
return f.apply(u);
}
@Test
public void test() {
User user = new User(1, "mickey", 18);
System.out.println(performUser(u -> {
return u.getName();
}, user));//mickey
}
}
4.Supplier< T >:供给型接口,不接受输入参数,返回一个结果。常用于生成值的操作。
public class SupplierTest {
public static void f1(Supplier supplier){
System.out.println(supplier.get());
}
@Test
public void test1(){
f1(() -> new User(1,"kong",18));
f1(() -> "kong");
}
}
结果:
User{id=1, name='kong', age=18}
kong
4 方法引用
方法引用可以看做是Lambda表达式深层次的表达。换句话说,方法引用就是Lambda表达式,也就是函数式接口的一个实例,通过方法的名字来指向一个方法,可以认为是Lambda表达式的一个语法糖。当要传递给Lambda体的操作,已经有实现的方法了,可以使用方法引用。
要求: 实现接口的抽象方法的参数列表和返回值类型,必须与方法引用的方法的参数列表和返回值类型保持一致!
格式: 使用操作符 ::
将类(或对象) 与 方法名分隔开来。
如下三种主要使用情况:
- 对象
::
实例方法名 - 类
::
静态方法名 - 类
::
实例方法名
示例:
public class Test1 {
public static int f1(BiFunction<Integer, Integer, Integer> biFunction,Integer d1,Integer d2){
return biFunction.apply(d1,d2);
}
@Test
public void test() {
//匿名内部类
int i1 = f1(new BiFunction<Integer, Integer, Integer>() {
@Override
public Integer apply(Integer d1, Integer d2) {
return Integer.max(d1, d2);
}
}, 12, 15);
//lambda表达式
int i2 = f1((d1, d2) -> Integer.max(d1, d2), 12, 15);
//方法引用-lambda表达式的语法糖
int i3 = f1(Integer::max, 12, 15);
System.out.println(i1 + " " + i2 + " " + i3);
}
}
结果:
15 15 15
5 Stream API
Java8中有两大最为重要的改变。第一个是 Lambda 表达式;另外一个则是 Stream API。
Stream 是 Java8 中处理集合的关键抽象概念,它可以指定你希望对集合进行的操作,可以执行非常复杂的查找、过滤和映射数据等操作。 使用Stream API 对集合数据进行操作,就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简言之, Stream API 提供了一种高效且易于使用的处理数据的方式。
Stream到底是什么呢?是数据渠道,用于操作数据源(集合、数组等)所生成的元素序列。“集合讲的是数据, Stream讲的是计算!”
- Stream 自己不会存储元素。
- Stream 不会改变源对象。相反,他们会返回一个持有结果的新Stream。
- Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
Stream 和 Collection 集合的区别: Collection 是一种静态的内存数据结构,而 Stream 是有关计算的。
前者是主要面向内存,存储在内存中,后者主要是面向 CPU,通过 CPU 实现计算。
1.Stream使用
(1)创建 Stream:通过一个数据源(如:集合、数组),获取一个流。
(2)中间操作:一个中间操作链,对数据源的数据进行处理。
(3)终止操作(终端操作):一旦执行终止操作, 就执行中间操作链,并产生结果,之后,不会再被使用 。
2.创建 Stream 方式
(1)Collection 接口,提供了两个获取流的方法:
- default Stream stream() : 返回一个顺序流
- default Stream parallelStream() : 返回一个并行流
(2)Arrays 的静态方法 stream() 可以获取数组流
- static Stream stream(T[ ] array): 返回一个流
(3)通过Stream的of() 获取
- public static Stream< T > of(T… values) : 返回一个流
3.Stream 的中间操作
多个中间操作可以连接起来形成一个流水线,除非流水线上触发终止操作,否则中间操作不会执行任何的处理!而在终止操作时一次性全部处理,称为“惰性求值” 。
- filter(Predicate p):接收 Lambda , 从流中排除某些元素
- map(Function f):接收一个函数作为参数,该函数会被应用到每个元 素上,并将其映射成一个新的元素。
- flatMap(Function f):接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流
- sorted():产生一个新流,其中按自然顺序排序
- sorted(Comparator com) :产生一个新流,其中按比较器顺序排序
4.Stream 的终止操作
终端操作会从流的流水线生成结果。其结果可以是任何不是流的值,例如: List、 Integer,甚至是 void 。流进行了终止操作后,不能再次使用。
- allMatch(Predicate p):检查是否匹配所有元素
- forEach(Consumer c):内部迭代(使用 Collection 接口需要用户去做迭代, 称为外部迭代。相反, Stream API 使用内部迭代)
- reduce(T iden, BinaryOperator b) :可以将流中元素反复结合起来,得到一个值。返回 T
- reduce(BinaryOperator b):可以将流中元素反复结合起来,得到一个值。返回 Optional
- collect(Collector c):将流转换为其他形式。接收一个 Collector 接口的实现,用于给Stream中元素做汇总 的方法
示例:
@Test
public void test1(){
List<User> list = new ArrayList<>();
list.add(new User(1, "mickey", 22));
list.add(new User(2, "johna", 33));
list.add(new User(3, "doca", 19));
list.add(new User(4, "cat", 20));
list.add(new User(5, "toma", 20));
list.add(new User(6, "tomcat", 70));
list.add(new User(7, "mysqla", 73));
list.add(new User(8, "java", 84));
Set<Integer> set = new HashSet<>();
for (User user : list) {
if(user.getAge() >= 30){
set.add(user.getId());
}
}
System.out.println(set);
//Stream写法
Set s2 = list.stream().filter(u -> u.getAge() >= 30).map(u -> u.getId()).collect(Collectors.toSet());
System.out.println(s2);
System.out.println(list.stream().allMatch(user -> user.getName().contains("a")));
}
结果:
[2, 6, 7, 8]
[2, 6, 7, 8]
false
6 Optional类
Optional 类(java.util.Optional) 是一个容器类, 它可以保存类型T的值, 代表这个值存在。或者仅仅保存null,表示这个值不存在。原来用 null 表示一个值不存在,现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。
Optional类的Javadoc描述如下:这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。
创建Optional类对象的方法:
- Optional.of(T t) : 创建一个 Optional 实例, t必须非空;
- Optional.empty() : 创建一个空的 Optional 实例
- Optional.ofNullable(T t): t可以为null
判断Optional容器中是否包含对象:
- boolean isPresent() : 判断是否包含对象
- void ifPresent(Consumer<? super T> consumer) : 如果有值,就执行Consumer接口的实现代码,并且该值会作为参数传给它。
获取Optional容器的对象:
- T get(): 如果调用对象包含值,返回该值,否则抛异常
- T orElse(T other) : 如果有值则将其返回,否则返回指定的other对象。
- T orElseGet(Supplier<? extends T> other) : 如果有值则将其返回,否则返回由Supplier接口实现提供的对象。
- T orElseThrow(Supplier<? extends X> exceptionSupplier) : 如果有值则将其返回,否则抛出由Supplier接口实现提供的异常。