Java 8 - 快速指南

Java 8 - 概述

JAVA 8 是 JAVA 编程语言开发的主要功能版本。它的初始版本于 2014 年 3 月 18 日发布。随着 Java 8 的发布，Java 提供了对函数式编程、新 JavaScript 引擎、新的日期时间操作 API、新的流 API 等的支持。

新功能

Lambda 表达式 − 为 Java 添加函数式处理能力。
方法参考 − 通过名称引用函数，而不是直接调用它们。使用函数作为参数。
默认方法 − 具有默认方法实现的接口。
新工具 − 添加了新的编译器工具和实用程序，如“jdeps”以找出依赖关系。
流 API − 新的流API，方便管道处理。
日期时间 API − 改进的日期时间 API。
可选 − 强调正确处理空值的最佳实践。
Nashorn，JavaScript 引擎 − 用于执行 JavaScript 代码的基于 Java 的引擎。

考虑以下代码片段。

现场演示

import java.util.Collections;
import java.util.List;
import java.util.ArrayList;
import java.util.Comparator;

public class Java8Tester {

   public static void main(String args[]) {
   
      List<String> names1 = new ArrayList<String>();
      names1.add("Mahesh ");
      names1.add("Suresh ");
      names1.add("Ramesh ");
      names1.add("Naresh ");
      names1.add("Kalpesh ");
		
      List<String> names2 = new ArrayList<String>();
      names2.add("Mahesh ");
      names2.add("Suresh ");
      names2.add("Ramesh ");
      names2.add("Naresh ");
      names2.add("Kalpesh ");
		
      Java8Tester tester = new Java8Tester();
      System.out.println("Sort using Java 7 syntax: ");
		
      tester.sortUsingJava7(names1);
      System.out.println(names1);
      System.out.println("Sort using Java 8 syntax: ");
		
      tester.sortUsingJava8(names2);
      System.out.println(names2);
   }
   
   //sort using java 7
   private void sortUsingJava7(List<String> names) {   
      Collections.sort(names, new Comparator<String>() {
         @Override
         public int compare(String s1, String s2) {
            return s1.compareTo(s2);
         }
      });
   }
   
   //sort using java 8
   private void sortUsingJava8(List<String> names) {
      Collections.sort(names, (s1, s2) -> s1.compareTo(s2));
   }
}

运行程序，得到如下结果。

Sort using Java 7 syntax:
[ Kalpesh Mahesh Naresh Ramesh Suresh ]
Sort using Java 8 syntax:
[ Kalpesh Mahesh Naresh Ramesh Suresh ]

这里是 sortUsingJava8() 方法使用带有 lambda 表达式的 sort 函数作为参数来获取排序条件。

Java 8 - 环境设置

本地环境设置

如果您想为 Java 编程语言设置自己的环境，那么本节将指导您完成整个过程。请按照以下步骤设置您的 Java 环境。

Java SE 可以从以下链接免费下载 -

https://www.oracle.com/technetwork/java/javase/downloads/index-jsp-138363.html

你根据你的操作系统下载一个版本。

按照说明下载 Java，然后运行 .exe 在您的机器上安装 Java。在您的机器上安装 Java 后，您需要设置环境变量以指向正确的安装目录。

为 Windows 2000/XP 设置路径

假设你已经在 c:\Program Files\java\jdk 目录下安装了 Java -

右键单击“我的电脑”并选择“属性”。
点击“高级”选项卡下的“环境变量”按钮。
现在，更改“路径”变量，使其还包含 Java 可执行文件的路径。例如，如果路径当前设置为“C:\WINDOWS\SYSTEM32”，则将路径更改为“C:\WINDOWS\SYSTEM32;c:\Program Files\java\jdk\bin”。

为 Windows 95/98/ME 设置路径

假设你已经在 c:\Program Files\java\jdk 目录下安装了 Java -

编辑 'C:\autoexec.bat' 文件并在末尾添加以下行 -

SET PATH=%PATH%;C:\Program Files\java\jdk\bin

为 Linux、UNIX、Solaris、FreeBSD 设置路径

环境变量 PATH 应设置为指向 Java 二进制文件的安装位置。如果您在执行此操作时遇到问题，请参阅您的 shell 文档。

例如，如果你使用 bash 作为你的 shell，那么你应该在 '.bashrc 的末尾添加以下行：export PATH=/path/to/java:$PATH'

流行的 Java 编辑器

要编写 Java 程序，您需要一个文本编辑器。市场上还有更复杂的 IDE。但是现在，您可以考虑以下之一 -

记事本 − 在 Windows 机器上，您可以使用任何简单的文本编辑器，如记事本（本教程推荐）或 TextPad。
Netbeans − 它是一个开源和免费的Java IDE。可以从 https://netbeans.org/index.html 下载。
日食 − 也是Eclipse开源社区开发的Java IDE，可以从https://www.eclipse.org/下载。

Java 8 - Lambda 表达式

Lambda表达式是Java 8引入的，被吹捧为Java 8最大的特点。Lambda表达式方便了函数式编程，大大简化了开发。

语法

lambda 表达式具有以下语法特征。

parameter -> expression body

以下是 lambda 表达式的重要特征。

可选类型声明 − 无需声明参数的类型。编译器可以从参数的值中推断出相同的值。
参数周围的可选括号 − 无需在括号中声明单个参数。对于多个参数，括号是必需的。
可选的花括号 − 如果表达式主体包含单个语句，则无需在表达式主体中使用花括号。
可选的返回关键字 − 如果主体有一个表达式返回值，编译器会自动返回值。需要大括号来表示表达式返回一个值。

Lambda 表达式示例

使用您选择的任何编辑器创建以下 Java 程序，例如 C:\> JAVA。

Java8Tester.java

现场演示

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester tester = new Java8Tester();
		
      //with type declaration
      MathOperation addition = (int a, int b) -> a + b;
		
      //with out type declaration
      MathOperation subtraction = (a, b) -> a - b;
		
      //with return statement along with curly braces
      MathOperation multiplication = (int a, int b) -> { return a * b; };
		
      //without return statement and without curly braces
      MathOperation division = (int a, int b) -> a / b;
		
      System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
      System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
      System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
      System.out.println("10 / 5 = " + tester.operate(10, 5, division));
		
      //without parenthesis
      GreetingService greetService1 = message ->
      System.out.println("Hello " + message);
		
      //with parenthesis
      GreetingService greetService2 = (message) ->
      System.out.println("Hello " + message);
		
      greetService1.sayMessage("Mahesh");
      greetService2.sayMessage("Suresh");
   }
	
   interface MathOperation {
      int operation(int a, int b);
   }
	
   interface GreetingService {
      void sayMessage(String message);
   }
	
   private int operate(int a, int b, MathOperation mathOperation) {
      return mathOperation.operation(a, b);
   }
}

验证结果

使用 javac 编译类编译器如下-

C:\JAVA>javac Java8Tester.java

现在按如下方式运行 Java8Tester -

C:\JAVA>java Java8Tester

它应该产生以下输出 -

10 + 5 = 15
10 - 5 = 5
10 x 5 = 50
10 / 5 = 2
Hello Mahesh
Hello Suresh

以下是上述示例中需要考虑的要点。

Lambda 表达式主要用于定义功能接口的内联实现，即仅具有单个方法的接口。在上面的例子中，我们使用了各种类型的 lambda 表达式来定义 MathOperation 接口的操作方法。然后我们定义了 GreetingService 的 sayMessage 的实现。
Lambda 表达式消除了匿名类的需要，为 Java 提供了非常简单但功能强大的函数式编程能力。

范围

使用 lambda 表达式，您可以引用任何最终变量或有效的最终变量（仅分配一次）。如果第二次为变量赋值，则 Lambda 表达式会引发编译错误。

范围示例

使用您选择的任何编辑器创建以下 Java 程序，例如 C:\> JAVA。

Java8Tester.java

现场演示

public class Java8Tester {

   final static String salutation = "Hello! ";
   
   public static void main(String args[]) {
      GreetingService greetService1 = message -> 
      System.out.println(salutation + message);
      greetService1.sayMessage("Mahesh");
   }
	
   interface GreetingService {
      void sayMessage(String message);
   }
}

验证结果

使用 javac 编译类编译器如下-

C:\JAVA>javac Java8Tester.java

现在按如下方式运行 Java8Tester -

C:\JAVA>java Java8Tester

它应该产生以下输出 -

Hello! Mahesh

Java 8 - 方法参考

方法引用有助于通过名称指向方法。使用“::”符号描述方法引用。方法引用可用于指向以下类型的方法 -

静态方法
实例方法
使用 new 运算符 (TreeSet::new) 的构造函数

方法参考示例

使用您选择的任何编辑器创建以下 Java 程序，例如 C:\> JAVA。

Java8Tester.java

import java.util.List;
import java.util.ArrayList;

public class Java8Tester {

   public static void main(String args[]) {
      List names = new ArrayList();
		
      names.add("Mahesh");
      names.add("Suresh");
      names.add("Ramesh");
      names.add("Naresh");
      names.add("Kalpesh");
		
      names.forEach(System.out::println);
   }
}

这里我们传递了 System.out::println 方法作为静态方法引用。

验证结果

使用 javac 编译类编译器如下-

C:\JAVA>javac Java8Tester.java

现在按如下方式运行 Java8Tester -

C:\JAVA>java Java8Tester

它应该产生以下输出 -

Mahesh
Suresh
Ramesh
Naresh
Kalpesh

Java 8 - 功能接口

函数式接口只有一个功能可以展示。例如，具有单个方法“compareTo”的 Comparable 接口用于比较目的。 Java 8 定义了许多函数式接口，可在 lambda 表达式中广泛使用。以下是java.util.Function包中定义的功能接口列表。

下面是Java8中的接口列表。

Sr.No.	界面和说明
1	BiConsumer 表示接受两个输入参数且不返回结果的操作。
2	BiFunction 表示一个接受两个参数并产生结果的函数。
3	二元运算符表示对两个相同类型的操作数进行操作，产生与操作数相同类型的结果。
4	双谓词表示两个参数的谓词（布尔值函数）。
5	布尔供应商表示布尔值结果的供应商。
6	消费者表示接受单个输入参数且不返回结果的操作。
7	DoubleBinaryOperator 表示对两个双值操作数进行操作并产生双值结果。
8	双重消费者表示接受单个双值参数且不返回结果的操作。
9	双功能表示一个接受双值参数并产生结果的函数。
10	双谓词表示一个双值参数的谓词（布尔值函数）。
11	双供应商代表双值结果的供应商。
12	DoubleToIntFunction 表示一个接受双值参数并产生 int 值结果的函数。
13	DoubleToLongFunction 表示一个接受双值参数并产生长值结果的函数。
14	双元运算符表示对产生双值结果的单个双值操作数的操作。
15	函数表示接受一个参数并产生结果的函数。
16	IntBinaryOperator 表示对两个 int 值操作数的操作并产生一个 int 值结果。
17	内部消费者表示接受单个 int 值参数且不返回结果的操作。
18	IntFunction 表示一个接受 int 值参数并产生结果的函数。
19	IntPredicate 表示一个 int 值参数的谓词（布尔值函数）。
20	内部供应商表示一个 int 值结果的供应商。
21	IntToDoubleFunction 表示一个接受 int 值参数并产生双值结果的函数。
22	IntToLongFunction 表示一个接受 int 值参数并产生 long 值结果的函数。
23	IntUnaryOperator 表示对单个 int 值操作数的操作，该操作产生 int 值结果。
24	LongBinaryOperator 表示对两个长值操作数的操作并产生一个长值结果。
25	长期消费者表示接受单个长值参数且不返回结果的操作。
26	长函数表示一个接受长值参数并产生结果的函数。
27	长谓词表示一个长值参数的谓词（布尔值函数）。
28	长期供应商代表长期价值结果的供应商。
29	LongToDoubleFunction 表示一个接受长值参数并产生双值结果的函数。
30	LongToIntFunction 表示一个接受长值参数并产生 int 值结果的函数。
31	LongUnaryOperator 表示对单个长值操作数的操作，该操作产生一个长值结果。
32	ObjDoubleConsumer 表示接受对象值和双值参数且不返回结果的操作。
33	ObjIntConsumer 表示接受对象值和 int 值参数的操作，并且不返回任何结果。
34	ObjLongConsumer 表示接受对象值和长值参数且不返回结果的操作。
35	谓词表示一个参数的谓词（布尔值函数）。
36	供应商代表结果的提供者。
37	ToDoubleBiFunction 表示接受两个参数并产生双值结果的函数。
38	ToDoubleFunction 表示产生双值结果的函数。
39	ToIntBiFunction 表示一个接受两个参数并产生一个 int 值结果的函数。
40	ToIntFunction 表示产生 int 值结果的函数。
41	ToLongBiFunction 表示一个接受两个参数并产生一个长值结果的函数。
42	ToLongFunction 表示产生长值结果的函数。
43	一元运算符表示对单个操作数的操作，该操作产生与其操作数相同类型的结果。

功能接口示例

Predicate 接口是一个函数接口，带有一个方法 test(Object) 返回一个布尔值。这个接口表示一个对象被测试为真或假。

使用您选择的任何编辑器创建以下 Java 程序，例如 C:\> JAVA。

Java8Tester.java

现场演示

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

public class Java8Tester {

   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 is passed as parameter to test method of Predicate interface
      // test method will always return true no matter what value n has.
		
      System.out.println("Print all numbers:");
		
      //pass n as parameter
      eval(list, n->true);
		
      // Predicate<Integer> predicate1 = n -> n%2 == 0
      // n is passed as parameter to test method of Predicate interface
      // test method will return true if n%2 comes to be zero
		
      System.out.println("Print even numbers:");
      eval(list, n-> n%2 == 0 );
		
      // Predicate<Integer> predicate2 = n -> n > 3
      // n is passed as parameter to test method of Predicate interface
      // test method will return true if n is greater than 3.
		
      System.out.println("Print numbers greater than 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 + " ");
         }
      }
   }
}

这里我们传递了 Predicate 接口，它接受单个输入并返回布尔值。

验证结果

使用 javac 编译类编译器如下-

C:\JAVA>javac Java8Tester.java

现在按如下方式运行 Java8Tester -

C:\JAVA>java Java8Tester

它应该产生以下输出 -

Print all numbers:
1
2
3
4
5
6
7
8
9
Print even numbers:
2
4
6
8
Print numbers greater than 3:
4
5
6
7
8
9

Java 8 - 默认方法

Java 8 在接口中引入了默认方法实现的新概念。添加此功能是为了向后兼容，以便可以使用旧接口来利用 Java 8 的 lambda 表达式功能。

例如，“List”或“Collection”接口没有“forEach”方法声明。因此，添加这样的方法只会破坏集合框架的实现。 Java 8 引入了默认方法，使得 List/Collection 接口可以有一个 forEach 方法的默认实现，实现这些接口的类不需要实现相同的实现。

语法

public interface vehicle {

   default void print() {
      System.out.println("I am a vehicle!");
   }
}

多个默认值

使用接口中的默认函数，一个类可能会使用相同的默认方法实现两个接口。下面的代码解释了如何解决这种歧义。

public interface vehicle {

   default void print() {
      System.out.println("I am a vehicle!");
   }
}

public interface fourWheeler {

   default void print() {
      System.out.println("I am a four wheeler!");
   }
}

第一个解决方案是创建一个自己的方法来覆盖默认实现。

public class car implements vehicle, fourWheeler {

   public void print() {
      System.out.println("I am a four wheeler car vehicle!");
   }
}

第二种方案是使用super调用指定接口的默认方法。

public class car implements vehicle, fourWheeler {

   public void print() {
      vehicle.super.print();
   }
}

静态默认方法

从 Java 8 开始，接口也可以有静态辅助方法。

public interface vehicle {

   default void print() {
      System.out.println("I am a vehicle!");
   }
	
   static void blowHorn() {
      System.out.println("Blowing horn!!!");
   }
}

默认方法示例

使用您选择的任何编辑器创建以下 Java 程序，例如 C:\> JAVA。

Java8Tester.java

现场演示

public class Java8Tester {

   public static void main(String args[]) {
      Vehicle vehicle = new Car();
      vehicle.print();
   }
}

interface Vehicle {

   default void print() {
      System.out.println("I am a vehicle!");
   }
	
   static void blowHorn() {
      System.out.println("Blowing horn!!!");
   }
}

interface FourWheeler {

   default void print() {
      System.out.println("I am a four wheeler!");
   }
}

class Car implements Vehicle, FourWheeler {

   public void print() {
      Vehicle.super.print();
      FourWheeler.super.print();
      Vehicle.blowHorn();
      System.out.println("I am a car!");
   }
}

验证结果

使用 javac 编译类编译器如下-

C:\JAVA>javac Java8Tester.java

现在按如下方式运行 Java8Tester -

C:\JAVA>java Java8Tester

它应该产生以下输出 -

I am a vehicle!
I am a four wheeler!
Blowing horn!!!
I am a car!

Java 8 - 流

Stream 是 Java 8 中引入的一个新的抽象层。使用 Stream，您可以以类似于 SQL 语句的声明方式处理数据。例如，考虑下面的 SQL 语句。

SELECT max(salary), employee_id, employee_name FROM Employee

上面的 SQL 表达式会自动返回最高工资员工的详细信息，而无需在开发人员端进行任何计算。使用 Java 中的集合框架，开发人员必须使用循环并进行重复检查。另一个问题是效率。由于多核处理器可以轻松使用，Java 开发人员必须编写可能非常容易出错的并行代码处理。

为了解决这些问题，Java 8 引入了流的概念，让开发人员可以声明式地处理数据并利用多核架构，而无需为其编写任何特定代码。

什么是流？

Stream 表示来自源的一系列对象，它支持聚合操作。以下是 Stream 的特征 -

元素序列 − 流以顺序方式提供一组特定类型的元素。流按需获取/计算元素。它从不存储元素。
来源 − Stream 将集合、数组或 I/O 资源作为输入源。
聚合操作 − Stream 支持 filter、map、limit、reduce、find、match 等聚合操作。
流水线 - 大多数流操作返回流本身，以便它们的结果可以流水线化。这些操作称为中间操作，它们的功能是获取输入、处理它们并将输出返回给目标。 collect() 方法是一个终端操作，通常出现在流水线操作的末尾，以标记流的结束。
自动迭代 − 流操作在提供的源元素上进行内部迭代，与需要显式迭代的集合相反。

生成流

在 Java 8 中，Collection 接口有两种方法来生成 Stream。

流（） − 返回一个以集合为源的顺序流。
parallelStream() − 返回一个以集合为源的并行 Stream。

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

forEach

Stream 提供了一种新方法“forEach”来迭代流的每个元素。以下代码段展示了如何使用 forEach 打印 10 个随机数。

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

地图

“map”方法用于将每个元素映射到其对应的结果。以下代码段使用 map 打印唯一的数字平方。

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

//get list of unique squares
List<Integer> squaresList = numbers.stream().map( i -> i*i).distinct().collect(Collectors.toList());

过滤

“过滤器”方法用于根据标准消除元素。以下代码段使用过滤器打印空字符串的计数。

List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");

//get count of empty string
int count = strings.stream().filter(string -> string.isEmpty()).count();

限制

“limit”方法用于减小流的大小。以下代码段展示了如何使用limit打印10个随机数。

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

排序

“sorted”方法用于对流进行排序。以下代码段展示了如何按排序顺序打印 10 个随机数。

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

并行处理

parallelStream 是用于并行处理的流的替代方案。看看下面的代码段，它使用 parallelStream 打印空字符串的计数。

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");

//get count of empty string
long count = strings.parallelStream().filter(string -> string.isEmpty()).count();

在顺序流和并行流之间切换非常容易。

收藏家

收集器用于组合对流元素的处理结果。收集器可用于返回列表或字符串。

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 List: " + filtered);
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("Merged String: " + mergedString);

统计

在 Java 8 中，引入了统计收集器来在流处理完成时计算所有统计信息。

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

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

System.out.println("Highest number in List : " + stats.getMax());
System.out.println("Lowest number in List : " + stats.getMin());
System.out.println("Sum of all numbers : " + stats.getSum());
System.out.println("Average of all numbers : " + stats.getAverage());

流示例

使用您选择的任何编辑器创建以下 Java 程序，例如 C:\> JAVA。

Java8Tester.java

现场演示

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("Using Java 7: ");
		
      // Count empty strings
      List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
      System.out.println("List: " +strings);
      long count = getCountEmptyStringUsingJava7(strings);
		
      System.out.println("Empty Strings: " + count);
      count = getCountLength3UsingJava7(strings);
		
      System.out.println("Strings of length 3: " + count);
		
      //Eliminate empty string
      List<String> filtered = deleteEmptyStringsUsingJava7(strings);
      System.out.println("Filtered List: " + filtered);
		
      //Eliminate empty string and join using comma.
      String mergedString = getMergedStringUsingJava7(strings,", ");
      System.out.println("Merged String: " + mergedString);
      List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
		
      //get list of square of distinct numbers
      List<Integer> squaresList = getSquares(numbers);
      System.out.println("Squares List: " + squaresList);
      List<Integer> integers = Arrays.asList(1,2,13,4,15,6,17,8,19);
		
      System.out.println("List: " +integers);
      System.out.println("Highest number in List : " + getMax(integers));
      System.out.println("Lowest number in List : " + getMin(integers));
      System.out.println("Sum of all numbers : " + getSum(integers));
      System.out.println("Average of all numbers : " + getAverage(integers));
      System.out.println("Random Numbers: ");
		
      //print ten random numbers
      Random random = new Random();
		
      for(int i = 0; i < 10; i++) {
         System.out.println(random.nextInt());
      }
		
      System.out.println("Using Java 8: ");
      System.out.println("List: " +strings);
		
      count = strings.stream().filter(string->string.isEmpty()).count();
      System.out.println("Empty Strings: " + count);
		
      count = strings.stream().filter(string -> string.length() == 3).count();
      System.out.println("Strings of length 3: " + count);
		
      filtered = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.toList());
      System.out.println("Filtered List: " + filtered);
		
      mergedString = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.joining(", "));
      System.out.println("Merged String: " + mergedString);
		
      squaresList = numbers.stream().map( i ->i*i).distinct().collect(Collectors.toList());
      System.out.println("Squares List: " + squaresList);
      System.out.println("List: " +integers);
		
      IntSummaryStatistics stats = integers.stream().mapToInt((x) ->x).summaryStatistics();
		
      System.out.println("Highest number in List : " + stats.getMax());
      System.out.println("Lowest number in List : " + stats.getMin());
      System.out.println("Sum of all numbers : " + stats.getSum());
      System.out.println("Average of all numbers : " + stats.getAverage());
      System.out.println("Random Numbers: ");
		
      random.ints().limit(10).sorted().forEach(System.out::println);
		
      //parallel processing
      count = strings.parallelStream().filter(string -> string.isEmpty()).count();
      System.out.println("Empty Strings: " + 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();
   }
}

验证结果

使用 javac 编译类编译器如下-

C:\JAVA>javac Java8Tester.java

现在按如下方式运行 Java8Tester -

C:\JAVA>java Java8Tester

它应该产生以下结果 -

Using Java 7:
List: [abc, , bc, efg, abcd, , jkl]
Empty Strings: 2
Strings of length 3: 3
Filtered List: [abc, bc, efg, abcd, jkl]
Merged String: abc, bc, efg, abcd, jkl
Squares List: [9, 4, 49, 25]
List: [1, 2, 13, 4, 15, 6, 17, 8, 19]
Highest number in List : 19
Lowest number in List : 1
Sum of all numbers : 85
Average of all numbers : 9
Random Numbers:
-1279735475
903418352
-1133928044
-1571118911
628530462
18407523
-881538250
-718932165
270259229
421676854
Using Java 8:
List: [abc, , bc, efg, abcd, , jkl]
Empty Strings: 2
Strings of length 3: 3
Filtered List: [abc, bc, efg, abcd, jkl]
Merged String: abc, bc, efg, abcd, jkl
Squares List: [9, 4, 49, 25]
List: [1, 2, 13, 4, 15, 6, 17, 8, 19]
Highest number in List : 19
Lowest number in List : 1
Sum of all numbers : 85
Average of all numbers : 9.444444444444445
Random Numbers:
-1009474951
-551240647
-2484714
181614550
933444268
1227850416
1579250773
1627454872
1683033687
1798939493
Empty Strings: 2

Java 8 - 可选类

Optional 是一个容器对象，用于包含非空对象。可选对象用于表示不存在值的空值。这个类有各种实用方法来帮助代码将值处理为“可用”或“不可用”，而不是检查空值。它是在 Java 8 中引入的，类似于 Guava 中的 Optional。

类声明

以下是 java.util.Optional 的声明类-

public final class Optional<T> extends Object

类方法

Sr.No.	方法和说明
1	静态可选 empty() 返回一个空的 Optional 实例。
2	布尔等于（对象 obj）指示某个其他对象是否“等于”这个 Optional。
3	可选过滤器（谓词谓词）如果存在一个值并且该值与给定的谓词匹配，则返回一个描述该值的 Optional，否则返回一个空 Optional。
4	可选 flatMap(Function> 映射器) 如果存在值，则将提供的 Optional-bearing 映射函数应用于它，返回该结果，否则返回空 Optional。
5	T get() 如果此 Optional 中存在值，则返回该值，否则抛出 NoSuchElementException。
6	int hashCode() 返回当前值的哈希码值（如果有），如果不存在则返回 0（零）。
7	void ifPresent(Consumer consumer) 如果存在值，则使用该值调用指定的使用者，否则什么也不做。
8	布尔 isPresent() 如果存在值，则返回 true，否则返回 false。
9	可选 map(Function mapper) 如果存在值，则对其应用提供的映射函数，如果结果为非 null，则返回描述结果的 Optional。
10	静态可选 of(T值) 返回具有指定当前非空值的 Optional。
11	静态可选 ofNullable(T值) 返回一个描述指定值的Optional，如果非null，否则返回一个空的Optional。
12	T orElse(T 其他) 如果存在则返回值，否则返回其他值。
13	T orElseGet(Supplier other) 如果存在则返回该值，否则调用 other 并返回该调用的结果。
14	T orElseThrow(Supplier exceptionSupplier) 返回包含的值（如果存在），否则抛出由提供的供应商创建的异常。
15	字符串 toString() 返回此 Optional 适合调试的非空字符串表示形式。

这个类继承了以下类的方法 -

java.lang.Object

可选示例

使用您选择的任何编辑器创建以下 Java 程序，例如 C:\> JAVA。

Java8Tester.java

现场演示

import java.util.Optional;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8Tester = new Java8Tester();
      Integer value1 = null;
      Integer value2 = new Integer(10);
		
      //Optional.ofNullable - allows passed parameter to be null.
      Optional<Integer> a = Optional.ofNullable(value1);
		
      //Optional.of - throws NullPointerException if passed parameter is null
      Optional<Integer> b = Optional.of(value2);
      System.out.println(java8Tester.sum(a,b));
   }
	
   public Integer sum(Optional<Integer> a, Optional<Integer> b) {
      //Optional.isPresent - checks the value is present or not
		
      System.out.println("First parameter is present: " + a.isPresent());
      System.out.println("Second parameter is present: " + b.isPresent());
		
      //Optional.orElse - returns the value if present otherwise returns
      //the default value passed.
      Integer value1 = a.orElse(new Integer(0));
		
      //Optional.get - gets the value, value should be present
      Integer value2 = b.get();
      return value1 + value2;
   }
}

验证结果

使用 javac 编译类编译器如下-

C:\JAVA>javac Java8Tester.java

现在按如下方式运行 Java8Tester -

C:\JAVA>java Java8Tester

它应该产生以下输出 -

First parameter is present: false
Second parameter is present: true
10

Java 8 - Nashorn JavaScript

在 Java 8 中，引入了 Nashorn，一个大大改进的 javascript 引擎，以取代现有的 Rhino。 Nashorn 提供了 2 到 10 倍的性能，因为它直接在内存中编译代码并将字节码传递给 JVM。 Nashorn 使用 Java 7 中引入的调用动态特性来提高性能。

jjs

对于 Nashorn 引擎，JAVA 8 引入了一个新的命令行工具，jjs, 在控制台执行javascript代码。

解释js文件

创建并保存文件 sample.js 在 c:\> JAVA 文件夹中。

sample.js

print('Hello World!');

打开控制台并使用以下命令。

C:\JAVA>jjs sample.js

它将产生以下输出：

Hello World!

交互模式下的jjs

打开控制台并使用以下命令。

C:\JAVA>jjs
jjs> print("Hello, World!")
Hello, World!
jjs> quit()
>>

传递参数

打开控制台并使用以下命令。

C:\JAVA> jjs -- a b c
jjs> print('letters: ' +arguments.join(", "))
letters: a, b, c
jjs>

从 Java 调用 JavaScript

使用 ScriptEngineManager，可以在 Java 中调用和解释 JavaScript 代码。

示例

使用您选择的任何编辑器创建以下 Java 程序，例如 C:\> JAVA。

Java8Tester.java

现场演示

import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
import javax.script.ScriptException;

public class Java8Tester {

   public static void main(String args[]) {
      ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
      ScriptEngine nashorn = scriptEngineManager.getEngineByName("nashorn");
		
      String name = "Mahesh";
      Integer result = null;
      
      try {
         nashorn.eval("print('" + name + "')");
         result = (Integer) nashorn.eval("10 + 2");
         
      } catch(ScriptException e) {
         System.out.println("Error executing script: "+ e.getMessage());
      }
      System.out.println(result.toString());
   }
}

验证结果

使用 javac 编译类编译器如下-

C:\JAVA>javac Java8Tester.java

现在按如下方式运行 Java8Tester -

C:\JAVA>java Java8Tester

它应该产生以下结果 -

Mahesh
12

从 JavaScript 调用 Java

下面的例子说明了如何在 java 脚本中导入和使用 Java 类。

创建并保存 sample.js 在 c:\> JAVA 文件夹中。

sample.js

var BigDecimal = Java.type('java.math.BigDecimal');

function calculate(amount, percentage) {

   var result = new BigDecimal(amount).multiply(new BigDecimal(percentage)).divide(
      new BigDecimal("100"), 2, BigDecimal.ROUND_HALF_EVEN);
   
   return result.toPlainString();
}
var result = calculate(568000000000000000023,13.9);
print(result);

打开控制台并使用以下命令。

C:\JAVA>jjs sample.js

它应该产生以下输出 -

78952000000000000003.20

Java 8 - 新的日期/时间 API

Java 8 引入了一个新的 Date-Time API 来弥补旧的 date-time API 的以下缺点。

不是线程安全的 − java.util.Date 不是线程安全的，因此开发人员在使用日期时必须处理并发问题。新的日期时间 API 是不可变的，并且没有 setter 方法。
糟糕的设计 − 默认日期从 1900 开始，月份从 1 开始，日从 0 开始，因此没有统一性。旧 API 对日期操作的直接方法较少。新的 API 为此类操作提供了许多实用方法。
时区处理困难 − 开发人员必须编写大量代码来处理时区问题。新 API 的开发考虑了特定领域的设计。

Java 8 在 java.time 包下引入了一个新的日期时间 API。以下是java.time包中引入的一些重要类。

本地 − 简化的日期时间 API，没有复杂的时区处理。
分区 − 处理各种时区的专用日期时间API。

本地日期时间 API

LocalDate/LocalTime 和 LocalDateTime 类简化了不需要时区的开发。让我们看看他们的行动。

使用您选择的任何编辑器创建以下 java 程序，例如 C:\> JAVA。

Java8Tester.java

现场演示

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.Month;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testLocalDateTime();
   }
	
   public void testLocalDateTime() {
      // Get the current date and time
      LocalDateTime currentTime = LocalDateTime.now();
      System.out.println("Current DateTime: " + 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: " + month +"day: " + day +"seconds: " + 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 hour 15 minutes
      LocalTime date4 = LocalTime.of(22, 15);
      System.out.println("date4: " + date4);
		
      //parse a string
      LocalTime date5 = LocalTime.parse("20:15:30");
      System.out.println("date5: " + date5);
   }
}

验证结果

使用 javac 编译类编译器如下-

C:\JAVA>javac Java8Tester.java

现在按如下方式运行 Java8Tester -

C:\JAVA>java Java8Tester

它应该产生以下输出 -

Current DateTime: 2014-12-09T11:00:45.457
date1: 2014-12-09
Month: DECEMBERday: 9seconds: 45
date2: 2012-12-10T11:00:45.457
date3: 2014-12-12
date4: 22:15
date5: 20:15:30

分区日期时间 API

在考虑时区时，将使用分区日期时间 API。让我们看看他们的行动。

使用您选择的任何编辑器创建以下 Java 程序，例如 C:\> JAVA。

Java8Tester.java

现场演示

import java.time.ZonedDateTime;
import java.time.ZoneId;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testZonedDateTime();
   }
	
   public void testZonedDateTime() {
      // Get the current date and time
      ZonedDateTime date1 = ZonedDateTime.parse("2007-12-03T10:15:30+05:30[Asia/Karachi]");
      System.out.println("date1: " + date1);
		
      ZoneId id = ZoneId.of("Europe/Paris");
      System.out.println("ZoneId: " + id);
		
      ZoneId currentZone = ZoneId.systemDefault();
      System.out.println("CurrentZone: " + currentZone);
   }
}

验证结果

使用 javac 编译类编译器如下-

C:\JAVA>javac Java8Tester.java

现在按如下方式运行 Java8Tester -

C:\JAVA>java Java8Tester

它应该产生以下输出 -

date1: 2007-12-03T10:15:30+05:00[Asia/Karachi]
ZoneId: Europe/Paris
CurrentZone: Etc/UTC

计时单位枚举

Java 8 中添加了 java.time.temporal.ChronoUnit 枚举，以替换旧 API 中用于表示日、月等的整数值。让我们看看它们的实际效果。

使用您选择的任何编辑器创建以下 Java 程序，例如 C:\> JAVA。

Java8Tester.java

现场演示

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testChromoUnits();
   }
	
   public void testChromoUnits() {
      //Get the current date
      LocalDate today = LocalDate.now();
      System.out.println("Current date: " + today);
		
      //add 1 week to the current date
      LocalDate nextWeek = today.plus(1, ChronoUnit.WEEKS);
      System.out.println("Next week: " + nextWeek);
		
      //add 1 month to the current date
      LocalDate nextMonth = today.plus(1, ChronoUnit.MONTHS);
      System.out.println("Next month: " + nextMonth);
		
      //add 1 year to the current date
      LocalDate nextYear = today.plus(1, ChronoUnit.YEARS);
      System.out.println("Next year: " + nextYear);
		
      //add 10 years to the current date
      LocalDate nextDecade = today.plus(1, ChronoUnit.DECADES);
      System.out.println("Date after ten year: " + nextDecade);
   }
}

验证结果

使用 javac 编译类编译器如下-

C:\JAVA>javac Java8Tester.java

现在按如下方式运行 Java8Tester -

C:\JAVA>java Java8Tester

它应该产生以下结果 -

Current date: 2014-12-10
Next week: 2014-12-17
Next month: 2015-01-10
Next year: 2015-12-10
Date after ten year: 2024-12-10

期间和持续时间

在 Java 8 中，引入了两个专门的类来处理时间差异。

期间 − 它处理基于日期的时间量。
持续时间 − 它处理基于时间的时间量。

让我们看看他们的行动。

使用您选择的任何编辑器创建以下 Java 程序，例如 C:\> JAVA。

Java8Tester.java

现场演示

import java.time.temporal.ChronoUnit;

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.Duration;
import java.time.Period;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testPeriod();
      java8tester.testDuration();
   }
	
   public void testPeriod() {
      //Get the current date
      LocalDate date1 = LocalDate.now();
      System.out.println("Current date: " + date1);
		
      //add 1 month to the current date
      LocalDate date2 = date1.plus(1, ChronoUnit.MONTHS);
      System.out.println("Next month: " + date2);
      
      Period period = Period.between(date2, date1);
      System.out.println("Period: " + period);
   }
	
   public void testDuration() {
      LocalTime time1 = LocalTime.now();
      Duration twoHours = Duration.ofHours(2);
		
      LocalTime time2 = time1.plus(twoHours);
      Duration duration = Duration.between(time1, time2);
		
      System.out.println("Duration: " + duration);
   }
}

验证结果

使用 javac 编译类编译器如下-

C:\JAVA>javac Java8Tester.java

现在按如下方式运行 Java8Tester -

C:\JAVA>java Java8Tester

它应该产生以下输出 -

Current date: 2014-12-10
Next month: 2015-01-10
Period: P-1M
Duration: PT2H

时间调节器

TemporalAdjuster 用于执行日期数学运算。例如，获取“每月的第二个星期六”或“下星期二”。让我们看看他们的行动。

使用您选择的任何编辑器创建以下 Java 程序，例如 C:\> JAVA。

Java8Tester.java

现场演示

import java.time.LocalDate;
import java.time.temporal.TemporalAdjusters;
import java.time.DayOfWeek;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testAdjusters();
   }
	
   public void testAdjusters() {
      //Get the current date
      LocalDate date1 = LocalDate.now();
      System.out.println("Current date: " + date1);
		
      //get the next tuesday
      LocalDate nextTuesday = date1.with(TemporalAdjusters.next(DayOfWeek.TUESDAY));
      System.out.println("Next Tuesday on : " + nextTuesday);
		
      //get the second saturday of next month
      LocalDate firstInYear = LocalDate.of(date1.getYear(),date1.getMonth(), 1);
      LocalDate secondSaturday = firstInYear.with(TemporalAdjusters.nextOrSame(
         DayOfWeek.SATURDAY)).with(TemporalAdjusters.next(DayOfWeek.SATURDAY));
      System.out.println("Second Saturday on : " + secondSaturday);
   }
}

验证结果

使用 javac 编译类编译器如下-

C:\JAVA>javac Java8Tester.java

现在按如下方式运行 Java8Tester -

C:\JAVA>java Java8Tester

它应该产生以下结果 -

Current date: 2014-12-10
Next Tuesday on : 2014-12-16
Second Saturday on : 2014-12-13

向后兼容性

一个 toInstant() 方法被添加到原始的 Date 和 Calendar 对象中，可用于将它们转换为新的 Date-Time API。使用 ofInstant(Insant,ZoneId) 方法获取 LocalDateTime 或 ZonedDateTime 对象。让我们看看他们的行动。

使用您选择的任何编辑器创建以下 Java 程序，例如 C:\> JAVA。

Java8Tester.java

现场演示

import java.time.LocalDateTime;
import java.time.ZonedDateTime;

import java.util.Date;

import java.time.Instant;
import java.time.ZoneId;

public class Java8Tester {

   public static void main(String args[]) {
      Java8Tester java8tester = new Java8Tester();
      java8tester.testBackwardCompatability();
   }
	
   public void testBackwardCompatability() {
      //Get the current date
      Date currentDate = new Date();
      System.out.println("Current date: " + currentDate);
		
      //Get the instant of current date in terms of milliseconds
      Instant now = currentDate.toInstant();
      ZoneId currentZone = ZoneId.systemDefault();
		
      LocalDateTime localDateTime = LocalDateTime.ofInstant(now, currentZone);
      System.out.println("Local date: " + localDateTime);
		
      ZonedDateTime zonedDateTime = ZonedDateTime.ofInstant(now, currentZone);
      System.out.println("Zoned date: " + zonedDateTime);
   }
}

验证结果

使用 javac 编译类编译器如下-

C:\JAVA>javac Java8Tester.java

现在按如下方式运行 Java8Tester -

C:\JAVA>java Java8Tester

它应该产生以下输出 -

Current date: Wed Dec 10 05:44:06 UTC 2014
Local date: 2014-12-10T05:44:06.635
Zoned date: 2014-12-10T05:44:06.635Z[Etc/UTC]

Java 8 - Base64

在 Java 8 中，Base64 终于如愿以偿。 Java 8 现在具有用于 Base64 编码的内置编码器和解码器。在 Java 8 中，我们可以使用三种 Base64 编码。

简单 − 输出映射到位于 A-Za-z0-9+/ 中的一组字符。编码器在输出中不添加任何换行符，解码器拒绝除 A-Za-z0-9+/ 以外的任何字符。
网址 − 输出映射到位于 A-Za-z0-9+_ 中的字符集。输出是 URL 和文件名安全的。
MIME − 输出映射为 MIME 友好格式。输出以每行不超过 76 个字符表示，并使用回车“\r”后跟换行“\n”作为行分隔符。编码输出的末尾没有行分隔符。

嵌套类

Sr.No.	嵌套类和描述
1	静态类 Base64.Decoder 此类实现了一个解码器，用于使用 RFC 4648 和 RFC 2045 中指定的 Base64 编码方案来解码字节数据。
2	静态类 Base64.Encoder 此类实现了一个编码器，用于使用 RFC 4648 和 RFC 2045 中指定的 Base64 编码方案对字节数据进行编码。

Sr.No.

嵌套类和描述

静态类 Base64.Decoder

此类实现了一个解码器，用于使用 RFC 4648 和 RFC 2045 中指定的 Base64 编码方案来解码字节数据。

静态类 Base64.Encoder

此类实现了一个编码器，用于使用 RFC 4648 和 RFC 2045 中指定的 Base64 编码方案对字节数据进行编码。

方法

Sr.No.	方法名称和描述
1	静态 Base64.Decoder getDecoder() 返回使用 Basic 类型 base64 编码方案进行解码的 Base64.Decoder。
2	静态 Base64.Encoder getEncoder() 返回使用 Basic 类型 base64 编码方案进行编码的 Base64.Encoder。
3	静态 Base64.Decoder getMimeDecoder() 返回使用 MIME 类型 base64 解码方案进行解码的 Base64.Decoder。
4	静态 Base64.Encoder getMimeEncoder() 返回使用 MIME 类型 base64 编码方案进行编码的 Base64.Encoder。
5	静态 Base64.Encoder getMimeEncoder(int lineLength, byte[] lineSeparator) 返回一个 Base64.Encoder，它使用 MIME 类型的 base64 编码方案进行编码，具有指定的行长和行分隔符。
6	静态 Base64.Decoder getUrlDecoder() 返回使用 URL 和文件名安全类型 base64 编码方案进行解码的 Base64.Decoder。
7	静态 Base64.Encoder getUrlEncoder() 返回使用 URL 和 Filename 安全类型 base64 编码方案进行编码的 Base64.Encoder。

继承的方法

这个类继承了以下类的方法 -

java.lang.Object

Base64 示例

在 C:/> JAVA 中使用您选择的任何编辑器创建以下 Java 程序。

Java8Tester.java

现场演示

import java.util.Base64;
import java.util.UUID;
import java.io.UnsupportedEncodingException;

public class HelloWorld {

   public static void main(String args[]) {

      try {
		
         // Encode using basic encoder
         String base64encodedString = Base64.getEncoder().encodeToString(
            "TutorialsPoint?java8".getBytes("utf-8"));
         System.out.println("Base64 Encoded String (Basic) :" + base64encodedString);
		
         // Decode
         byte[] base64decodedBytes = Base64.getDecoder().decode(base64encodedString);
		
         System.out.println("Original String: " + new String(base64decodedBytes, "utf-8"));
         base64encodedString = Base64.getUrlEncoder().encodeToString(
            "TutorialsPoint?java8".getBytes("utf-8"));
         System.out.println("Base64 Encoded String (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 Encoded String (MIME) :" + mimeEncodedString);

      } catch(UnsupportedEncodingException e) {
         System.out.println("Error :" + e.getMessage());
      }
   }
}

验证结果

使用 javac 编译类编译器如下-

C:\JAVA>javac Java8Tester.java

现在按如下方式运行 Java8Tester -

C:\JAVA>java Java8Tester

它应该产生以下输出 -

Base64 Encoded String (Basic) :VHV0b3JpYWxzUG9pbnQ/amF2YTg=
Original String: TutorialsPoint?java8
Base64 Encoded String (URL) :VHV0b3JpYWxzUG9pbnQ_amF2YTg=
Base64 Encoded String (MIME) :YmU3NWY2ODktNGM5YS00ODlmLWI2MTUtZTVkOTk2YzQ1Njk1Y2EwZTg2OTEtMmRiZC00YTQ1LWJl
NTctMTI1MWUwMTk0ZWQyNDE0NDAwYjgtYTYxOS00NDY5LTllYTctNjc1YzE3YWJhZTk1MTQ2MDQz
NDItOTAyOC00ZWI0LThlOTYtZWU5YzcwNWQyYzVhMTQxMWRjYTMtY2MwNi00MzU0LTg0MTgtNGQ1
MDkwYjdiMzg2ZTY0OWU5MmUtZmNkYS00YWEwLTg0MjQtYThiOTQxNDQ2YzhhNTVhYWExZjItNjU2
Mi00YmM4LTk2ZGYtMDE4YmY5ZDZhMjkwMzM3MWUzNDMtMmQ3MS00MDczLWI0Y2UtMTQxODE0MGU5
YjdmYTVlODUxYzItN2NmOS00N2UyLWIyODQtMThlMWVkYTY4M2Q1YjE3YTMyYmItZjllMS00MTFk
LWJiM2UtM2JhYzUxYzI5OWI4

Java 8 问答 Java 8 - 有用的资源

java