1 Java 8概述

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

新功能

• Lambda表达式 – 为Java增加了功能处理能力。

• 方法引用(Method references) – 通过名称引用函数，而不是直接调用它们。使用函数作为参数。

• 默认方法(Default method) – 具有默认方法实现的接口。

• 新工具 – 添加新的编译器工具和实用程序，如’jdeps’以找出依赖关系。

• Stream API – 新的流API以方便流水线处理。

• Date Time API – 改进的日期时间API。

• Optional – 强调最佳实践以正确处理空值。

• 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表达式作为参数的排序函数来获取排序条件。

2 Lambda表达式

Lambda表达式在Java 8中引入，并被吹捧为Java 8的最大特性.Lambda表达式有助于函数式编程，并简化了开发过程。

语法

lambda表达式的特征在于以下语法。

parameter -> expression body

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

• 可选类型声明 – 不需要声明参数的类型。编译器可以从参数的值推断相同的值。

• 围绕参数的可选括号 – 不需要在括号中声明单个参数。对于多个参数，需要括号。

• 可选花括号 – 如果身体含有单个陈述，则不需要在表情身体中使用花括号。

• 可选的return关键字 – 如果主体具有单个表达式以返回值，则编译器自动返回值。需要大括号来指示表达式返回一个值。

Lambda表达式示例

使用您选择的任何编辑器（例如C：\> JAVA）创建以下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表达式会引发编译错误。

范围示例

使用您选择的任何编辑器（例如C：\> JAVA）创建以下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

3 方法引用

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

• 静态方法
• 实例方法
• 使用new运算符的构造函数（TreeSet :: new）

方法引用示例

使用您选择的任何编辑器（例如C：\> JAVA）创建以下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

4 函数式接口

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

下面给出的是Java8中的接口列表。

函数式接口示例

Predicate <T>接口是一个具有方法测试（Object）的函数接口，用于返回一个布尔值。这个接口表示一个对象被测试为真或假。

使用您选择的任何编辑器（例如C：\> JAVA）创建以下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

5 默认方法

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 {

   default 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!!!");
   }
}

默认方法示例

使用您选择的任何编辑器（例如C：\> JAVA）创建以下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!

6 Streams

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

SELECT max(salary), employee_id, employee_name FROM Employee

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

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

什么是Stream？

流代表来自源的一系列对象，它支持聚合操作。以下是Stream的特点 –

• 元素序列 – 流以顺序方式提供一组特定类型的元素。流按需获取/计算元素。它从不存储元素。

• Source – Stream将Collections，Arrays或I / O资源作为输入源。

• 聚合操作 – Stream支持聚合操作，如过滤器，映射，限制，减少，查找，匹配等。

• Pipelining – 大多数流操作本身返回流，以便它们的结果可以流水线化。这些操作被称为中间操作，它们的功能是接受输入，处理它们，并将输出返回给目标。collect（）方法是终端操作，通常在流水线操作结束时出现以标记流的结束。

• 自动迭代 – 流操作通过所提供的源元素在内部执行迭代，与需要显式迭代的集合相反。

生成流

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

• stream（） – 返回考虑集合作为源的顺序流。

• parallelStream（） – 返回并行流考虑集合作为其源。

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());

filter

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

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

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

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

sorted

‘sorted’方法用于对流进行排序。以下代码段显示如何以排序顺序打印10个随机数。

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

并行处理(Parallel Processing)

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

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

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

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

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

Statistics

使用Java 8时，引入统计信息收集器来计算流处理完成时的所有统计信息。

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

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());

Stream示例

使用您选择的任何编辑器（例如C：\> JAVA）创建以下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

7 Optional

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

类声明

以下是java.util.Optional <T>类的声明–

public final class Optional<T> extends Object

类方法

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

• java.lang.Object继承

Optional示例

使用您选择的任何编辑器（例如C：\> JAVA）创建以下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

8 Nashorn JavaScript

随着Java 8，Nashorn推出了一个大大改进的JavaScript引擎，用于替换现有的Rhino。Nashorn提供的性能提高2到10倍，因为它直接编译内存中的代码并将字节码传递给JVM。Nashorn使用Java 7中引入的invoke动态特性来提高性能。

JJS

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

解释js文件

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

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，JavaScript代码可以在Java中调用和解释。

例

使用您选择的任何编辑器（例如C：\> JAVA）创建以下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类。

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

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

9 新Date/Time API

在Java 8中，引入了一个新的日期时间API来涵盖旧的日期时间API的以下缺点。

• 不是线程安全的 – java.util.Date不是线程安全的，因此开发人员在使用日期时必须处理并发问题。新的日期时间API是不可变的，并且没有setter方法。

• 糟糕的设计 – 默认日期从1900开始，月份从1开始，而日从0开始，因此没有统一性。旧的API对日期操作的直接方法较少。新的API为这些操作提供了许多实用方法。

• 困难的时区处理 – 开发人员必须编写大量代码来处理时区问题。新的API已经开发出来，保持了特定领域的设计。

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

• Local – 简化的日期时间API，不需要处理时区复杂性。

• Zoned – 专门的日期时间API来处理各种时区。

Local Date-Time API

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

使用您选择的任何编辑器（例如C：\> JAVA）创建以下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

Zoned Date-Time API

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

使用您选择的任何编辑器（例如C：\> JAVA）创建以下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

计时单位枚举(Chrono Units Enum)

在Java 8中添加java.time.temporal.ChronoUnit枚举，以替换旧API中使用的整数值来表示日，月等。让我们看看它们的实际运行情况。

使用您选择的任何编辑器（例如C：\> JAVA）创建以下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

周期和持续时间(Period and Duration)

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

• Period -它随着时间基于日期金额的交易。

• Duration – 它处理基于时间的时间量。

让我们看看他们的行动。

使用您选择的任何编辑器（例如C：\> JAVA）创建以下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

时间调节器(Temporal Adjusters)

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

使用您选择的任何编辑器（例如C：\> JAVA）创建以下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对象。让我们看看他们的行动。

使用您选择的任何编辑器（例如C：\> JAVA）创建以下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]

10 Base64

在Java 8中，Base64终于得到了应有的支持。Java 8现在具有用于Base64编码的内置编码器和解码器。在Java 8中，我们可以使用三种类型的Base64编码。

• Simple – 输出映射到位于A-Za-z0-9 + /中的一组字符。编码器不会在输出中添加换行符，并且解码器拒绝除A-Za-z0-9 + /以外的任何字符。

• URL – 输出被映射到位于A-Za-z0-9 + _中的一组字符。输出是URL和文件名安全。

• MIME – 输出被映射为MIME友好格式。输出以每行不超过76个字符的行表示，并使用回车’\ r’作为行分隔符，后接换行符’\ n’。编码输出的末尾不存在行分隔符。

嵌套类

方法

方法继承

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

• 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