跳至主要內容

Java 8 新特性详解

Jastar Wang原创2018/8/23大约 24 分钟技术手记JavaJava

Java 8 新特性详解

先上图：

JDK8新特性
JDK8新特性

Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本。 Oracle 公司于 2014 年 3 月 18 日发布 Java 8 ，它支持函数式编程，新的 JavaScript 引擎，新的日期 API，新的 Stream API 等等很多新特性。官网地址：https://www.oracle.com/java/technologies/javase/8-whats-new.html

笔者原来一直用的 1.7，后来项目中才用到了 1.8，熟悉了之后才有一种相见恨晚的感觉，1.8 的版本确实做了很大的改变，还是值得升级的，今天就来做一下新特性的总结。

1、Lambda 表达式

Java 8 引入了一个新的操作符 ->，该操作符成为箭头操作符或者 Lambda 操作符，箭头操作符将 Lambda 表达式拆分成两部分：

  • 左侧：参数列表
  • 右侧：所需执行的功能，即 Lambda 体

1.1、语法一：无参数，无返回值

// old style
Runnable r1 = new Runnable() {
	@Override
	public void run() {
		System.out.println("hello lambda1!");
	}
};
r1.run();

// new style
Runnable r2 = () -> System.out.println("hello lambda2!");
r2.run();

1.2、语法二：有一个参数，无返回值

(x) -> System.out.println(x);

1.3、语法三：只有一个参数，可省略小括号

x -> System.out.println(x);

1.4、语法四：有多个参数，有返回值，Lambda 体中有多条语句

List<Integer> list = Arrays.asList(1, 8, 5, 6);
System.out.println("before:" + Arrays.toString(list.toArray()));
list.sort((o1, o2) -> {
	System.out.println("o1:" + o1 + ",o2:" + o2);
	return o1.compareTo(o2);
});
System.out.println("behind:" + Arrays.toString(list.toArray()));

1.5、语法五：Lambda 体中只有一条语句，return 和大括号（及分号）都可以省略不写

// 接上栗子
(o1, o2) -> o1.compareTo(o2)

1.6、语法六：参数列表的数据类型可以省略不写

因为 JVM 编译器可以通过上下文进行类型推断出数据类型，既“类型推断”。

(Integer o1,Integer o2) -> o1.compareTo(o2);

2、方法引用

方法引用提供了非常实用的语法，如果 Lambda 表达式的内容已经有方法实现了，我们可以直接用名字引用已有的类或对象的方法或构造器；方法引用使语言的构造更紧凑简洁，减少冗余代码。

2.1、语法

  • 构造器引用：Class::new
  • 静态方法引用：Class::static_method
  • 特定类的任意对象方法引用：Class::method
  • 特定对象的方法引用：instance::method

2.2、栗子

先看一下 1.8 自带的这个函数接口：

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

创建一个码农类，用于测试方法引用的调用：

import java.util.function.Supplier;

/**
 * 码农
 *
 * @author jastar
 * @date 2018-08-29
 * @since 1.0.0
 */
public class Coder {
	/**
	 * 诞生了一个搬砖的
	 */
	public static Coder create(Supplier<Coder> supplier) {
		return supplier.get();
	}

	public static void sayHello(Coder coder) {
		System.out.println("Hello I'm " + coder);
	}

	public void sayBye(Coder coder) {
		System.out.println("Goodbye I'm " + coder);
	}

	public void coding() {
		System.out.println(this + " is coding...");
	}
}

调用示例：

public static void main(String[] args) {
	/**
	 * 1、构造方法引用
	 */
	// 方法引用版
	Coder coder1 = Coder.create(Coder::new);
	// Lambda版
	Coder coder2 = Coder.create(() -> new Coder());

	List<Coder> coders = Arrays.asList(coder1, coder2);
	System.out.println("————————————我是分割线：静态引用————————————");

	/**
	 * 2、静态方法引用
	 */
	// 方法引用版
	coders.forEach(Coder::sayHello);
	// Lambda版
	coders.forEach(coder -> Coder.sayHello(coder));

	System.out.println("————————————我是分割线：类引用————————————");

	/**
	 * 3、特定类的任意对象方法引用
	 */
	// 方法引用版
	coders.forEach(Coder::coding);
	// Lambda版
	coders.forEach(coder -> coder.coding());

	System.out.println("————————————我是分割线：对象引用————————————");

	/**
	 * 4、特定对象的方法引用（注意这里不太好理解，不过看了Lambda的写法之后就会恍然大悟）
	 */
	// 方法引用版
	coders.forEach(coder1::sayBye);
	// Lambda版
	coders.forEach(coder -> coder1.sayBye(coder));

}

输出结果：

————————————我是分割线：静态引用————————————
Hello I'm com.jastar.test.jdk8.Coder@87aac27
Hello I'm com.jastar.test.jdk8.Coder@3e3abc88
Hello I'm com.jastar.test.jdk8.Coder@87aac27
Hello I'm com.jastar.test.jdk8.Coder@3e3abc88
————————————我是分割线：类引用————————————
com.jastar.test.jdk8.Coder@87aac27 is coding...
com.jastar.test.jdk8.Coder@3e3abc88 is coding...
com.jastar.test.jdk8.Coder@87aac27 is coding...
com.jastar.test.jdk8.Coder@3e3abc88 is coding...
————————————我是分割线：对象引用————————————
Goodbye I'm com.jastar.test.jdk8.Coder@87aac27
Goodbye I'm com.jastar.test.jdk8.Coder@3e3abc88
Goodbye I'm com.jastar.test.jdk8.Coder@87aac27
Goodbye I'm com.jastar.test.jdk8.Coder@3e3abc88

注意：在方法引用时不需要括号，因为你没有实际调用这个方法；例如 Apple::getWeight，其实它就是 (Apple a) -> a.getWeight() 的快捷写法。另外数组引用为：Type[]::new

3、函数接口

为了更友好方便的使用 Lambda 表达式，JDK 设计了函数接口，函数接口是只有一个抽象方法（但可以有多个非抽象方法）的接口， Lambda 表达式可以被隐式转换为函数接口。

jdk1.8 之前已有的函数接口：

  • java.lang.Runnable
  • java.util.concurrent.Callable
  • java.security.PrivilegedAction
  • java.util.Comparator
  • java.io.FileFilter
  • java.nio.file.PathMatcher
  • java.lang.reflect.InvocationHandler
  • java.beans.PropertyChangeListener
  • java.awt.event.ActionListener
  • javax.swing.event.ChangeListener

jdk1.8 新增的函数接口：

  • java.util.function

注意：此包下包含了很多类，用来支持 Java 的函数式编程，文章末尾附有函数式接口类表格。

另外，在实际使用过程中，函数式接口是容易出错的：如有某个人在接口中增加了另一个抽象方法，这时这个接口就不再是函数式的了，并且编译过程也会失败；为了克服函数接口的这种脆弱性并且能够明确声明接口作为函数式接口的意图，Java 8 增加了一种特殊的注解：@FunctionalInterface（Java 8 中所有类库的已有接口都添加了 @FunctionalInterface 注解）

3.1、举个栗子

package com.jastar.test.jdk8;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class FunctionInterface {
	public static void main(String args[]) {
		List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

		// Predicate<Integer> predicate = n -> true
		// n 是一个参数传递到 Predicate 接口的 test 方法
		// n 如果存在则 test 方法返回 true

		System.out.println("输出所有数据:");

		// 传递参数 n
		eval(list, n -> true);

		// Predicate<Integer> predicate1 = n -> n%2 == 0
		// n 是一个参数传递到 Predicate 接口的 test 方法
		// 如果 n%2 为 0 test 方法返回 true

		System.out.println("输出所有偶数:");
		eval(list, n -> n % 2 == 0);

		// Predicate<Integer> predicate2 = n -> n > 3
		// n 是一个参数传递到 Predicate 接口的 test 方法
		// 如果 n 大于 3 test 方法返回 true

		System.out.println("输出大于 3 的所有数字:");
		eval(list, n -> n > 3);
	}

	public static void eval(List<Integer> list, Predicate<Integer> predicate) {
		for (Integer n : list) {
			if (predicate.test(n)) {
				System.out.println(n + " ");
			}
		}
		System.out.println();
	}
}

输出结果：

输出所有数据:
1 2 3 4 5 6 7 8 9
输出所有偶数:
2 4 6 8
输出大于 3 的所有数字:
4 5 6 7 8 9

3.2、附：函数接口类表格

序号接口 & 描述
1BiConsumer<T,U>；代表了一个接受两个输入参数的操作，并且不返回任何结果
2BiFunction<T,U,R>；代表了一个接受两个输入参数的方法，并且返回一个结果
3BinaryOperator<T>；代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的结果
4BiPredicate<T,U>；代表了一个两个参数的 boolean 值方法
5BooleanSupplier；代表了 boolean 值结果的提供方
6Consumer<T>；代表了接受一个输入参数并且无返回的操作
7DoubleBinaryOperator；代表了作用于两个 double 值操作符的操作，并且返回了一个 double 值的结果。
8DoubleConsumer；代表一个接受 double 值参数的操作，并且不返回结果。
9DoubleFunction<R>；代表接受一个 double 值参数的方法，并且返回结果
10DoublePredicate；代表一个拥有 double 值参数的 boolean 值方法
11DoubleSupplier；代表一个 double 值结构的提供方
12DoubleToIntFunction；接受一个 double 类型输入，返回一个 int 类型结果。
13DoubleToLongFunction；接受一个 double 类型输入，返回一个 long 类型结果
14DoubleUnaryOperator；接受一个参数同为类型 double,返回值类型也为 double 。
15Function<T,R>；接受一个输入参数，返回一个结果。
16IntBinaryOperator；接受两个参数同为类型 int,返回值类型也为 int 。
17IntConsumer；接受一个 int 类型的输入参数，无返回值 。
18IntFunction<R>；接受一个 int 类型输入参数，返回一个结果 。
19IntPredicate；接受一个 int 输入参数，返回一个布尔值的结果。
20IntSupplier；无参数，返回一个 int 类型结果。
21IntToDoubleFunction；接受一个 int 类型输入，返回一个 double 类型结果 。
22IntToLongFunction；接受一个 int 类型输入，返回一个 long 类型结果。
23IntUnaryOperator；接受一个参数同为类型 int,返回值类型也为 int 。
24LongBinaryOperator；接受两个参数同为类型 long,返回值类型也为 long。
25LongConsumer；接受一个 long 类型的输入参数，无返回值。
26LongFunction<R>；接受一个 long 类型输入参数，返回一个结果。
27LongPredicate；R 接受一个 long 输入参数，返回一个布尔值类型结果。
28LongSupplier；无参数，返回一个结果 long 类型的值。
29LongToDoubleFunction；接受一个 long 类型输入，返回一个 double 类型结果。
30LongToIntFunction；接受一个 long 类型输入，返回一个 int 类型结果。
31LongUnaryOperator；接受一个参数同为类型 long,返回值类型也为 long。
32ObjDoubleConsumer<T>；接受一个 object 类型和一个 double 类型的输入参数，无返回值。
33ObjIntConsumer<T>；接受一个 object 类型和一个 int 类型的输入参数，无返回值。
34ObjLongConsumer<T>；接受一个 object 类型和一个 long 类型的输入参数，无返回值。
35Predicate<T>；接受一个输入参数，返回一个布尔值结果。
36Supplier<T>；无参数，返回一个结果。
37ToDoubleBiFunction<T,U>；接受两个输入参数，返回一个 double 类型结果
38ToDoubleFunction<T>；接受一个输入参数，返回一个 double 类型结果
39ToIntBiFunction<T,U>；接受两个输入参数，返回一个 int 类型结果。
40ToIntFunction<T>；接受一个输入参数，返回一个 int 类型结果。
41ToLongBiFunction<T,U>；接受两个输入参数，返回一个 long 类型结果。
42ToLongFunction<T>；接受一个输入参数，返回一个 long 类型结果。
43UnaryOperator<T>；接受一个参数为类型 T,返回值类型也为 T。

4、default 及 static 默认方法

java 8 中新增了接口的默认方法，即接口可以有默认的实现方法，而且不需要实现类去实现，只需要在方法名前面加个 default 关键字修即可。

为什么需要这个特性？

答：首先，之前的接口是个双刃剑，好处是面向抽象而不是面向具体编程，缺陷是，当需要修改接口时候，需要修改全部实现该接口的类，目前的 Java 8 之前的集合框架没有 foreach 方法，通常能想到的解决办法是在 JDK 里给相关的接口添加新的方法及实现。然而，对于已经发布的版本，是没法在给接口添加新方法的同时不影响已有的实现。所以引进的默认方法。他们的目的是为了解决接口的修改与现有的实现不兼容的问题。

4.1、语法

public interface IUser {
	default void sayHello(String name) {
		System.out.println("hello," + name);
	}
}

4.2、多个默认方法

存在这样一种场景，一个类实现了多个接口，而这些接口中有相同的默认方法，此时就需要实现类来解决这个问题。

接口：

public interface IUser {
	default void sayHello(String name) {
		System.out.println("[IUser]hello," + name);
	}
}

public interface IPeople {
	default void sayHello(String name) {
		System.out.println("[IPeople]hello," + name);
	}
}

4.2.1、方案一：实现类自定义实现

public class ZhangSan implements IUser, IPeople {
	@Override
	public void sayHello(String name) {
		System.out.println("Hello 艾维巴蒂，I'm " + name);
	}
}

Hello 艾维巴蒂，I'm 张三

4.2.2、方案二：实现类中指定父接口实现

public class ZhangSan implements IUser, IPeople {
	@Override
	public void sayHello(String name) {
		IUser.super.sayHello(name);
	}
}

[IUser]hello,张三

4.3、静态默认方法

Java 8 的另一个特性是接口可以声明（并且可以提供实现）静态方法。例如：

public interface IUser {
	default void sayHello(String name) {
		System.out.println("[IUser]hello," + name);
	}
	static void sayHi() {
		System.out.println("Hi~~~~");
	}
}

注意：静态方法不能由实现类继承，跟普通静态方法一样需要用 类名.方法名 调用

5、重复注解&类型注解

5.1、重复注解

java 8 以前，注解在同一个位置只能声明一次；而在 java 8 中，允许在同一类型（类，属性，或方法）前多次声明同一个注解。

重复注解机制本身必须用 @Repeatable 注解。事实上，这并不是语言层面上的改变，更多的是编译器的技巧，底层的原理保持不变。

举个栗子：

public class Annoations {

	/**
	 * 使用Repeatable注解声明可重复，及其容器类
	 *
	 * @author jastar
	 * @date 2018-08-29
	 * @since 1.0.0
	 */
	@Repeatable(Authoritys.class)
	public @interface Authority {
		String role();
	}

	/**
	 * 注解容器类
	 *
	 * @author jastar
	 * @date 2018-08-29
	 * @since 1.0.0
	 */
	public @interface Authoritys {
		Authority[] value();
	}

	/**
	 * java8之前：需要对注解使用容器进行包装
	 *
	 * @author jastar
	 * @date 2018-08-29
	 * @since 1.0.0
	 */
	@Authoritys({ @Authority(role = "admin"), @Authority(role = "manager") })
	public void beforeJava8() {

	}

	/**
	 * java8：直接声明多次注解即可
	 *
	 * @author jastar
	 * @date 2018-08-29
	 * @since 1.0.0
	 */
	@Authority(role = "admin")
	@Authority(role = "manager")
	public void InJava8() {

	}
}

从上面例子看出，java 8 里面做法更适合常规的思维，可读性强一点。但是，仍然需要定义容器注解。两种方法获得的效果相同。重复注解只是一种简化写法，这种简化写法是一种假象：多个重复注解其实会被作为“容器”注解的 value 成员的数组元素处理。

5.2、类型注解

Java 8 为 ElementType 枚举增加了 TYPE_PARAMETER、TYPE_USE 两个枚举值，从而可以使用 @Target(ElementType_TYPE_USE) 修饰注解定义，这种注解被称为类型注解，可以用在任何使用到类型的地方。

  • TYPE_PARAMETER：表示该注解能写在类型参数的声明语句中。 类型参数声明如： <T>、<T extends Person>
  • TYPE_USE：表示注解可以在任何用到类型的地方使用，比如允许在如下位置使用：
    • 创建对象（用 new 关键字创建）
    • 类型转换
    • 使用 implements 实现接口
    • 使用 throws 声明抛出异常

举个栗子：

public class TargetAnnoation {

	@Target(ElementType.TYPE_USE)
	public @interface NotNull {

	}

	// 定义类使用
	@NotNull
	class TestTargetAnnoation {

		// 方法形参中使用
		// 在throws时使用
		public void test(@NotNull Object fileName) throws @NotNull IOException {
			// 强制类型转换时使用
			String name = (@NotNull String) fileName;

			// 创建对象时使用
			File file = new @NotNull File(name);
			file.createNewFile();
		}

		// 泛型使用
		public void foo(List<@NotNull String> info) {

		}
	}
}

6、Stream 流

Java 8 API 添加了一个新的抽象称为流 Stream，可以让你以一种声明的方式处理数据。

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。

Stream API 可以极大提高 Java 程序员的生产力，让程序员写出高效率、干净、简洁的代码。

这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。

元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

+--------------------+       +------+   +------+   +---+   +-------+
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
+--------------------+       +------+   +------+   +---+   +-------+

以上的流程转换为 Java 代码为：

List<Integer> transactionsIds =
widgets.stream()
             .filter(b -> b.getColor() == RED)
             .sorted((x,y) -> x.getWeight() - y.getWeight())
             .mapToInt(Widget::getWeight)
             .sum();

6.1、什么是 Stream

Stream（流）是一个来自数据源的元素队列并支持聚合操作

  • 元素是特定类型的对象，形成一个队列。Java 中的 Stream 并不会存储元素，而是按需计算。
  • 数据源 流的来源。 可以是集合，数组，I/O channel，产生器 generator 等。
  • 聚合操作 类似 SQL 语句一样的操作， 比如 filter, map, reduce, find, match, sorted 等。

和以前的 Collection 操作不同， Stream 操作还有两个基础的特征：

  • Pipelining: 中间操作都会返回流对象本身。这样多个操作可以串联成一个管道，如同流式风格（fluent style）。这样做可以对操作进行优化，比如延迟执行(laziness)和短路( short-circuiting)。
  • 内部迭代： 以前对集合遍历都是通过 Iterator 或者 For-Each 的方式,显式的在集合外部进行迭代， 这叫做外部迭代。Stream 提供了内部迭代的方式，通过访问者模式(Visitor)实现。

6.2、生成流

在 Java 8 中, 集合接口有两个方法来生成流：

  • stream() − 为集合创建串行流。
  • parallelStream() − 为集合创建并行流。
List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

6.3、forEach

Stream 提供了新的方法 forEach 来迭代流中的每个数据。以下代码片段使用 forEach 输出了 10 个随机数：

Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

6.4、map

map 方法用于映射每个元素到对应的结果，以下代码片段使用 map 输出了元素对应的平方数：

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
// 获取对应的平方数
List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());

6.5、filter

filter 方法用于通过设置的条件过滤出元素。以下代码片段使用 filter 方法过滤出空字符串：

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
// 获取空字符串的数量
int count = strings.stream().filter(string -> string.isEmpty()).count();

6.6、limit

limit 方法用于获取指定数量的流。 以下代码片段使用 limit 方法打印出 10 条数据：

Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

6.7、sorted

sorted 方法用于对流进行排序。以下代码片段使用 sorted 方法对输出的 10 个随机数进行排序：

Random random = new Random();
random.ints().limit(10).sorted().forEach(System.out::println);

6.8、parallel（并行）

parallelStream 是流并行处理程序的代替方法。以下实例我们使用 parallelStream 来输出空字符串的数量：

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
// 获取空字符串的数量
int count = strings.parallelStream().filter(string -> string.isEmpty()).count();

我们可以很容易的在顺序运行和并行直接切换。

6.9、Collectors

Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。Collectors 可用于返回列表或字符串：

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

System.out.println("筛选列表: " + filtered);
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("合并字符串: " + mergedString);

6.10、统计

另外，一些产生统计结果的收集器也非常有用。它们主要用于 int、double、long 等基本类型上，它们可以用来产生类似如下的统计结果。

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);

IntSummaryStatistics stats = integers.stream().mapToInt((x) -> x).summaryStatistics();

System.out.println("列表中最大的数 : " + stats.getMax());
System.out.println("列表中最小的数 : " + stats.getMin());
System.out.println("所有数之和 : " + stats.getSum());
System.out.println("平均数 : " + stats.getAverage());

6.11、完整实例

import java.util.ArrayList;
import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.Map;

public class Java8Tester {
   public static void main(String args[]){
      System.out.println("使用 Java 7: ");

      // 计算空字符串
      List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
      System.out.println("列表: " +strings);
      long count = getCountEmptyStringUsingJava7(strings);

      System.out.println("空字符数量为: " + count);
      count = getCountLength3UsingJava7(strings);

      System.out.println("字符串长度为 3 的数量为: " + count);

      // 删除空字符串
      List<String> filtered = deleteEmptyStringsUsingJava7(strings);
      System.out.println("筛选后的列表: " + filtered);

      // 删除空字符串，并使用逗号把它们合并起来
      String mergedString = getMergedStringUsingJava7(strings,", ");
      System.out.println("合并字符串: " + mergedString);
      List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);

      // 获取列表元素平方数
      List<Integer> squaresList = getSquares(numbers);
      System.out.println("平方数列表: " + squaresList);
      List<Integer> integers = Arrays.asList(1,2,13,4,15,6,17,8,19);

      System.out.println("列表: " +integers);
      System.out.println("列表中最大的数 : " + getMax(integers));
      System.out.println("列表中最小的数 : " + getMin(integers));
      System.out.println("所有数之和 : " + getSum(integers));
      System.out.println("平均数 : " + getAverage(integers));
      System.out.println("随机数: ");

      // 输出10个随机数
      Random random = new Random();

      for(int i=0; i < 10; i++){
         System.out.println(random.nextInt());
      }

      System.out.println("使用 Java 8: ");
      System.out.println("列表: " +strings);

      count = strings.stream().filter(string->string.isEmpty()).count();
      System.out.println("空字符串数量为: " + count);

      count = strings.stream().filter(string -> string.length() == 3).count();
      System.out.println("字符串长度为 3 的数量为: " + count);

      filtered = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.toList());
      System.out.println("筛选后的列表: " + filtered);

      mergedString = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.joining(", "));
      System.out.println("合并字符串: " + mergedString);

      squaresList = numbers.stream().map( i ->i*i).distinct().collect(Collectors.toList());
      System.out.println("Squares List: " + squaresList);
      System.out.println("列表: " +integers);

      IntSummaryStatistics stats = integers.stream().mapToInt((x) ->x).summaryStatistics();

      System.out.println("列表中最大的数 : " + stats.getMax());
      System.out.println("列表中最小的数 : " + stats.getMin());
      System.out.println("所有数之和 : " + stats.getSum());
      System.out.println("平均数 : " + stats.getAverage());
      System.out.println("随机数: ");

      random.ints().limit(10).sorted().forEach(System.out::println);

      // 并行处理
      count = strings.parallelStream().filter(string -> string.isEmpty()).count();
      System.out.println("空字符串的数量为: " + count);
   }

   private static int getCountEmptyStringUsingJava7(List<String> strings){
      int count = 0;

      for(String string: strings){

         if(string.isEmpty()){
            count++;
         }
      }
      return count;
   }

   private static int getCountLength3UsingJava7(List<String> strings){
      int count = 0;

      for(String string: strings){

         if(string.length() == 3){
            count++;
         }
      }
      return count;
   }

   private static List<String> deleteEmptyStringsUsingJava7(List<String> strings){
      List<String> filteredList = new ArrayList<String>();

      for(String string: strings){

         if(!string.isEmpty()){
             filteredList.add(string);
         }
      }
      return filteredList;
   }

   private static String getMergedStringUsingJava7(List<String> strings, String separator){
      StringBuilder stringBuilder = new StringBuilder();

      for(String string: strings){

         if(!string.isEmpty()){
            stringBuilder.append(string);
            stringBuilder.append(separator);
         }
      }
      String mergedString = stringBuilder.toString();
      return mergedString.substring(0, mergedString.length()-2);
   }

   private static List<Integer> getSquares(List<Integer> numbers){
      List<Integer> squaresList = new ArrayList<Integer>();

      for(Integer number: numbers){
         Integer square = new Integer(number.intValue() * number.intValue());

         if(!squaresList.contains(square)){
            squaresList.add(square);
         }
      }
      return squaresList;
   }

   private static int getMax(List<Integer> numbers){
      int max = numbers.get(0);

      for(int i=1;i < numbers.size();i++){

         Integer number = numbers.get(i);

         if(number.intValue() > max){
            max = number.intValue();
         }
      }
      return max;
   }

   private static int getMin(List<Integer> numbers){
      int min = numbers.get(0);

      for(int i=1;i < numbers.size();i++){
         Integer number = numbers.get(i);

         if(number.intValue() < min){
            min = number.intValue();
         }
      }
      return min;
   }

   private static int getSum(List numbers){
      int sum = (int)(numbers.get(0));

      for(int i=1;i < numbers.size();i++){
         sum += (int)numbers.get(i);
      }
      return sum;
   }

   private static int getAverage(List<Integer> numbers){
      return getSum(numbers) / numbers.size();
   }
}

7、Optional 类

Optional 类是一个可以为 null 的容器对象。如果值存在则 isPresent() 方法会返回 true，调用 get() 方法会返回该对象。

Optional 是个容器：它可以保存类型 T 的值，或者仅仅保存 null。Optional 提供很多有用的方法，这样我们就不用显式进行空值检测。

Optional 类的引入很好的解决空指针异常。

举个栗子：

public static void main(String args[]) {

	Integer value1 = null;
	Integer value2 = new Integer(10);

	// Optional.ofNullable - 允许传递为 null 参数
	Optional<Integer> a = Optional.ofNullable(value1);

	// Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException
	Optional<Integer> b = Optional.of(value2);
	System.out.println(sum(a, b));
}

public static Integer sum(Optional<Integer> a, Optional<Integer> b) {

	// Optional.isPresent - 判断值是否存在

	System.out.println("第一个参数值存在: " + a.isPresent());
	System.out.println("第二个参数值存在: " + b.isPresent());

	// Optional.orElse - 如果值存在，返回它，否则返回默认值
	Integer value1 = a.orElse(new Integer(0));

	// Optional.get - 获取值，值需要存在
	Integer value2 = b.get();
	return value1 + value2;
}

输出结果：

第一个参数值存在: false
第二个参数值存在: true
10

8、新的日期时间 API

8.1、之前的问题

  • 非线程安全 ：java.util.Date 是非线程安全的，所有的日期类都是可变的，这是 Java 日期类最大的问题之一。
  • 设计很差 ：Java 的日期/时间类的定义并不一致，在 java.util 和 java.sql 的包中都有日期类，此外用于格式化和解析的类在 java.text 包中定义。java.util.Date 同时包含日期和时间，而 java.sql.Date 仅包含日期，将其纳入 java.sql 包并不合理。另外这两个类都有相同的名字，这本身就是一个非常糟糕的设计。
  • 时区处理麻烦 ：日期类并不提供国际化，没有时区支持，因此 Java 引入了 java.util.Calendar 和 java.util.TimeZone 类，但他们同样存在上述所有的问题。

8.2、设计原则

Java 8 日期/时间 API 是 JSR-310 的实现，它的实现目标是克服旧的日期时间实现中所有的缺陷，新的日期/时间 API 的一些设计原则是：

  • 不变性：新的日期/时间 API 中，所有的类都是不可变的，这对多线程环境有好处。
  • 关注点分离：新的 API 将人可读的日期时间和机器时间（unix timestamp）明确分离，它为日期（Date）、时间（Time）、日期时间（DateTime）、时间戳（unix timestamp）以及时区定义了不同的类。
  • 清晰：在所有的类中，方法都被明确定义用以完成相同的行为。举个例子，要拿到当前实例我们可以使用 now()方法，在所有的类中都定义了 format()和 parse()方法，而不是像以前那样专门有一个独立的类。为了更好的处理问题，所有的类都使用了工厂模式和策略模式，一旦你使用了其中某个类的方法，与其他类协同工作并不困难。
  • 实用操作：所有新的日期/时间 API 类都实现了一系列方法用以完成通用的任务，如：加、减、格式化、解析、从日期/时间中提取单独部分，等等。
  • 可扩展性：新的日期/时间 API 是工作在 ISO-8601 日历系统上的，但我们也可以将其应用在非 IOS 的日历上。

8.3、包结构

  • java.time：这是新的 Java 日期/时间 API 的基础包，所有的主要基础类都是这个包的一部分，如：LocalDate, LocalTime, LocalDateTime, Instant, Period, Duration 等等。所有这些类都是不可变的和线程安全的，在绝大多数情况下，这些类能够有效地处理一些公共的需求。
  • java.time.chrono：这个包为非 ISO 的日历系统定义了一些泛化的 API，我们可以扩展 AbstractChronology 类来创建自己的日历系统。
  • java.time.format：这个包包含能够格式化和解析日期时间对象的类，在绝大多数情况下，我们不应该直接使用它们，因为 java.time 包中相应的类已经提供了格式化和解析的方法。
  • java.time.temporal：这个包包含一些时态对象，我们可以用其找出关于日期/时间对象的某个特定日期或时间，比如说，可以找到某月的第一天或最后一天。你可以非常容易地认出这些方法，因为它们都具有“withXXX”的格式。
  • java.time.zone：这个包包含支持不同时区以及相关规则的类

8.4、举个栗子

public static void main(String args[]) {
	// 获取当前的日期时间
	LocalDateTime currentTime = LocalDateTime.now();
	System.out.println("当前时间: " + currentTime);

	LocalDate date1 = currentTime.toLocalDate();
	System.out.println("date1: " + date1);

	Month month = currentTime.getMonth();
	int day = currentTime.getDayOfMonth();
	int seconds = currentTime.getSecond();

	System.out.println("月: " + month + ", 日: " + day + ", 秒: " + seconds);

	LocalDateTime date2 = currentTime.withDayOfMonth(10).withYear(2012);
	System.out.println("date2: " + date2);

	// 12 december 2014
	LocalDate date3 = LocalDate.of(2014, Month.DECEMBER, 12);
	System.out.println("date3: " + date3);

	// 22 小时 15 分钟
	LocalTime date4 = LocalTime.of(22, 15);
	System.out.println("date4: " + date4);

	// 解析字符串
	LocalTime date5 = LocalTime.parse("20:15:30");
	System.out.println("date5: " + date5);
}

输出结果：

当前时间: 2018-08-29T17:14:20.474
date1: 2018-08-29
月: AUGUST, 日: 29, 秒: 20
date2: 2012-08-10T17:14:20.474
date3: 2014-12-12
date4: 22:15
date5: 20:15:30

9、Base64

在 Java 8 中，Base64 编码已经成为 Java 类库的标准。Java 8 内置了 Base64 编码的编码器和解码器。

Base64 工具类提供了一套静态方法获取下面三种 BASE64 编解码器：

  • 基本：输出被映射到一组字符 A-Za-z0-9+/，编码不添加任何行标，输出的解码仅支持 A-Za-z0-9+/。
  • URL：输出映射到一组字符 A-Za-z0-9+_，输出是 URL 和文件。
  • MIME：输出隐射到 MIME 友好格式。输出每行不超过 76 字符，并且使用'\r'并跟随'\n'作为分割。编码输出最后没有行分割。

9.1、内嵌类

序号内嵌类 & 描述
1static class Base64.Decoder 该类实现一个解码器用于，使用 Base64 编码来解码字节数据。
2static class Base64.Encoder 该类实现一个编码器，使用 Base64 编码来编码字节数据。

9.2、方法

序号方法名 & 描述
1static Base64.Decoder getDecoder() 返回一个 Base64.Decoder，解码使用基本型 base64 编码方案。
2static Base64.Encoder getEncoder() 返回一个 Base64.Encoder ，编码使用基本型 base64 编码方案。
3static Base64.Decoder getMimeDecoder() 返回一个 Base64.Decoder ，解码使用 MIME 型 base64 编码方案。
4static Base64.Encoder getMimeEncoder() 返回一个 Base64.Encoder ，编码使用 MIME 型 base64 编码方案。
5static Base64.Encoder getMimeEncoder(int lineLength, byte[] lineSeparator) 返回一个 Base64.Encoder，编码使用 MIME 型 base64 编码方案，可以通过参数指定每行的长度及行的分隔符。
6static Base64.Decoder getUrlDecoder() 返回一个 Base64.Decoder ，解码使用 URL 和文件名安全型 base64 编码方案。
7static Base64.Encoder getUrlEncoder() 返回一个 Base64.Encoder ，编码使用 URL 和文件名安全型 base64 编码方案。

9.3、栗子

public static void main(String args[]) {
	try {
		// 使用基本编码
		String base64encodedString = Base64.getEncoder().encodeToString("jastar-wang?java8".getBytes("utf-8"));
		System.out.println("Base64 编码字符串 (基本) :" + base64encodedString);

		// 解码
		byte[] base64decodedBytes = Base64.getDecoder().decode(base64encodedString);

		System.out.println("原始字符串: " + new String(base64decodedBytes, "utf-8"));
		base64encodedString = Base64.getUrlEncoder().encodeToString("jastar-wang?java8".getBytes("utf-8"));
		System.out.println("Base64 编码字符串 (URL) :" + base64encodedString);

		StringBuilder stringBuilder = new StringBuilder();

		for (int i = 0; i < 10; ++i) {
			stringBuilder.append(UUID.randomUUID().toString());
		}

		byte[] mimeBytes = stringBuilder.toString().getBytes("utf-8");
		String mimeEncodedString = Base64.getMimeEncoder().encodeToString(mimeBytes);
		System.out.println("Base64 编码字符串 (MIME) :" + mimeEncodedString);

	} catch (UnsupportedEncodingException e) {
		e.printStackTrace();
	}
}

输出结果：

Base64 编码字符串 (基本) :amFzdGFyLXdhbmc/amF2YTg=
原始字符串: jastar-wang?java8
Base64 编码字符串 (URL) :amFzdGFyLXdhbmc_amF2YTg=
Base64 编码字符串 (MIME) :YjU5ODMyM2UtOWE3ZC00YTc5LThkNmUtMDZhMzMyNjc4Y2Q1YTE0NmIxZDAtODU1Ni00NDg3LWI2
ODYtMDg0YzFkYmIyZGQwZGQxNWFlMGUtNDU5Ny00NzY3LWEwZDMtNGI0NWFiYjJhMjYxZjc5OTYy
NmMtMWJhMS00ZGI0LTlmNGUtNzQ5OTdiZjZhNjRiMmY3ODhkYzktMzFkMC00NDQ4LTkzMjQtZWMw
OWJmNTA4MmM1YWVkNGE0YTAtYmJiZC00MjkwLTgwOGItZGRhNDY4OGJmZjMyZjhhOTQ4NGItYmVk
Mi00Yzg2LWIwNGUtMGQxYzQ2YjcyOGE0NDgwYTQ5ODAtNzRlYS00N2EzLTg2ZGYtOWUyMjQ3Mjgx
NWFlODFmNThkYWItZmE4Yi00ZGRmLWJjNTItZmU0NzMxNGYxZDIwOWM1MTJkNWMtYjFlYS00OTc3
LWE0N2EtNmIyNmVkN2I3MzU5

10、最后

不总结不知道，一总结还真吓一跳，java 8 的内容确实多，就先总结到这里吧（累的不行了 o(╥﹏╥)o），这些特性还需要在以后的工作中慢慢的实践和学习，这里还有很多没有提到，比如:

  • HashMap 中的红黑树
  • 并发（Concurrency）
  • JVM 的堆内存优化
  • Nashorn 引擎: jjs
  • ······
最近更新:
贡献者: jastar-wang
本站内容除特殊说明外均为原创，采用 CC BY-NC-SA 4.0 许可协议，转载请注明出处。
Copyright © 2026 Jastar Wang