java 8新內容整理

時間 2019-11-11

標籤 java 內容整理欄目 Java 简体版

原文原文鏈接

1、Java 8 Lambda 表達式

Lambda 表達式，也可稱爲閉包，它是推進 Java 8 發佈的最重要新特性。

Lambda 容許把函數做爲一個方法的參數（函數做爲參數傳遞進方法中）。

使用Lambda 表達式可使代碼變的更加簡潔緊湊。

1.1 語法

lambda 表達式的語法格式以下：

(parameters) -> expression或(parameters) ->{statements; }

如下是lambda表達式的重要特徵:

可選類型聲明：不須要聲明參數類型，編譯器能夠統一識別參數值；

可選的參數圓括號：一個參數無需定義圓括號，但多個參數須要定義圓括號；

可選的大括號：若是主體包含了一個語句，就不須要使用大括號；

可選的返回關鍵字：若是主體只有一個表達式返回值則編譯器會自動返回值，大括號須要指定明表達式返回了一個數值。

1.2 Lambda 表達式實例（常見）

（1）用lambda表達式實現Runnable

Lambda是一個匿名函數，咱們能夠把Lambda表達式理解爲是一段能夠傳遞的代碼（將代碼像數據同樣進行傳遞），其能夠代替實現「接口」中的抽象方法時的書寫匿名內部類的繁瑣代碼。

Runnable run = new Runnable() {
    @Override
    public void run() {
        System.out.println("old run");
    }
};
run.run();

該代碼可使用lambda表達式簡化爲：

 Runnable run1 = () ->     System.out.println("lambda run");
 run1.run();

（2）使用lambda表達式對列表進行迭代

List features = Arrays.asList("Lambdas", "Default Method", "Stream API", "Date and Time API");
features.forEach(n -> System.out.println(n));
features.forEach(System.out::println);

（3）使用lambda表達式和函數式接口Predicate，適合用於過濾；

同時它提供相似於邏輯操做符AND和OR的方法，名字叫作and()、or()和xor()，用於將傳入 filter() 方法的條件合併起來

List names = Arrays.asList("Java", "Scala", "C++", "Haskell", "Lisp");
Predicate<String> startsWithJ = (n) -> n.startsWith("J");
Predicate<String> fourLetterLong = (n) -> n.length() == 4;
names.stream()
    .filter(startsWithJ.and(fourLetterLong))
    .forEach((n) -> System.out.print("nName, which starts with 'J' and four letter long is : " + n));

(4)使用lambda表達式的Map和Reduce

List costBeforeTax = Arrays.asList(100, 200, 300, 400, 500);
costBeforeTax.stream().map((cost) -> cost + .12*cost).forEach(System.out::println);
double totalBill = costBeforeTax.stream().map((cost) -> cost + .12*cost).reduce((sum, cost) -> sum + cost).get();

(5)經過過濾建立一個String列表

// 建立一個字符串列表，每一個字符串長度大於2
List<String> filtered = strList.stream().filter(x -> x.length()> 2).collect(Collectors.toList());
// 將字符串換成大寫並用逗號連接起來
String G7Countries = strList.stream().map(x -> x.toUpperCase()).collect(Collectors.joining(", "));
（更多相關用法詳見stream用法）

(6)綜合實例

public class Java8Tester {
    public static void main(String args[]) {
        Java8Tester tester = new Java8Tester();
        // 類型聲明
        MathOperation addition = (int a, int b) -> a + b;
        // 不用類型聲明
        MathOperation subtraction = (a, b) -> a - b;
        // 大括號中的返回語句
        MathOperation multiplication = (int a, int b) -> {
            return a * b;
        };
        // 沒有大括號及返回語句
        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));
        // 不用括號
        GreetingService greetService1 = message ->
                System.out.println("Hello " + message);
        // 用括號
        GreetingService greetService2 = (message) ->
                System.out.println("Hello " + message);
        greetService1.sayMessage("Runoob");
        greetService2.sayMessage("Google");
    }
    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);
    }
}

10+5=15
10-5=5
10 x 5=50
10/5=2
HelloRunoob
HelloGoogle

輸出結果

使用Lambda 表達式須要注意如下兩點：

Lambda 表達式主要用來定義行內執行的方法類型接口，例如，一個簡單方法接口。在上面例子中，咱們使用各類類型的Lambda表達式來定義MathOperation接口的方法。而後咱們定義了sayMessage的執行。

Lambda 表達式免去了使用匿名方法的麻煩，而且給予Java簡單可是強大的函數化的編程能力。

1.3 變量做用域

>lambda 表達式只能引用標記了 final 的外層局部變量，這就是說不能在lambda 內部修改定義在域外的局部變量，不然會編譯錯誤。

例：

public class Java8Tester {
    final static String salutation = "Hello! ";
    
    public static void main(String args[]){
        GreetingService greetService1 = message ->
                System.out.println(salutation + message);
        greetService1.sayMessage("Runoob");
    //====================至關於下面==============================
        GreetingService g = new GreetingService() {
            @Override
            public void sayMessage(String message) {
                System.out.println(salutation + message);
            }
        };
        g.sayMessage("jack");
    //===========================================================
    }
    interface GreetingService {
        void sayMessage(String message);
    }
}

Hello! Runoob
Hello! jack

執行結果

>咱們也能夠直接在lambda 表達式中訪問外層的局部變量：

例:

public class Java8Tester {
    public static void main(String args[]) {
        final int num = 1;
        Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
        s.convert(2);  // 輸出結果爲 3
    }
    public interface Converter<T1, T2> {
        void convert(int i);
    }
}

>lambda 表達式的局部變量能夠不用聲明爲 final，可是必須不可被後面的代碼修改（即隱性的具備final 的語義）

//報錯信息：Local variable num defined in an enclosing scope must be final or effectively final

把num=5；註釋掉就不報錯了

public class Java8Tester {
    public static void main(String args[]) {
        int num = 1;
        Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
        s.convert(2);
        num = 5;
    }
    public interface Converter<T1, T2> {
        void convert(int i);
    }
}

>在Lambda 表達式當中不容許聲明一個與局部變量同名的參數或者局部變量。

public class Java8Tester {
    public static void main(String args[]) {
        String first = "";
        Comparator<String> comparator = (first, second) -> System.out.println(Integer.compare(first.length(), second.length()));  //編譯會出錯

        comparator.com("aaaaa","bb");
    }
    public interface Comparator<T> {
        void com(String a,String b);
    }
}

把String first = "";注掉就不報錯

2、Java 8 Stream

Java 8 API添加了一個新的抽象稱爲流Stream，可讓你以一種聲明的方式處理數據。

Stream使用一種相似用SQL語句從數據庫查詢數據的直觀方式來提供一種對Java集合運算和表達的高階抽象。

Stream API能夠極大提升Java程序員的生產力，讓程序員寫出高效率、乾淨、簡潔的代碼。

這種風格將要處理的元素集合看做一種流，流在管道中傳輸，而且能夠在管道的節點上進行處理，好比篩選，排序，聚合等。

元素流在管道中通過中間操做（intermediate operation）的處理，最後由最終操做(terminal operation)獲得前面處理的結果。

2.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)實現。

2.2生成流

在Java 8中,集合接口有兩個方法來生成流：

stream() −爲集合建立串行流。

parallelStream() − 爲集合建立並行流。

public static void main(String[] args) {
    List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
    List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
}

2.3 forEach

Stream 提供了新的方法 'forEach' 來迭代流中的每一個數據。如下代碼片斷使用forEach 輸出了10個隨機數：

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

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

2.5 filter

filter 方法用於經過設置條件過濾出元素。如下代碼片斷使用filter 方法過濾出空字符串：

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

2.6 limit

limit 方法用於獲取指定數量的流。如下代碼片斷使用 limit 方法打印出 10 條數據：

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

2.7 sorted

sorted 方法用於對流進行排序。如下代碼片斷使用 sorted 方法對輸出的 10 個隨機數進行排序：

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

2.8 並行（parallel）程序

parallelStream 是流並行處理程序的代替方法。如下實例咱們使用parallelStream 來輸出空字符串的數量：

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

咱們能夠很容易的在順序運行和並行直接切換。

2.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);

 1 集合
 2 static <T> Collector<T,?,List<T>>    toList()        將元素聚合成ArrayList
 3 static <T> Collector<T,?,Set<T>>    toSet()          將元素聚合成HashSet
 4 static <T,C extends Collection<T>>  Collector<T,?,C>    toCollection(Supplier<C> collectionFactory) 將流中的元素所有放置到一個集合中返回，這裏使用Collection，泛指多種集合，參數示例：LinkedList::new
 5 static <T,K,U> Collector<T,?,Map<K,U>>    toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)   根據給定的鍵生成器和值生成器生成的鍵和值保存到一個map中返回
 6 static <T,K,U> Collector<T,?,Map<K,U>>    toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)  在上面方法的基礎上增長了對鍵發生重複時處理方式的mergeFunction，參數示例：e -> e.substring(0,1),e->e,(a,b)-> b)
 7 static <T,K,U,M extends Map<K,U>> Collector<T,?,M>    toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier) 在第上個方法的基礎上再添加告終果Map的生成方法，參數示例：e -> e.substring(0,1),e->e,(a,b)-> b,HashMap::new
 8 static <T,K,U> Collector<T,?,ConcurrentMap<K,U>>    toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper) toMap的併發版
 9 static <T,K,U> Collector<T,?,ConcurrentMap<K,U>>    toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)    toMap的併發版
10 static <T,K,U,M extends ConcurrentMap<K,U>> Collector<T,?,M>    toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)   toMap的併發版
11 
12 統計
13 static <T> Collector<T,?,Double>    summingDouble(ToDoubleFunction<? super T> mapper)       對小數求和。
14 static <T> Collector<T,?,Integer>    summingInt(ToIntFunction<? super T> mapper)            對整數求和。
15 static <T> Collector<T,?,Long>    summingLong(ToLongFunction<? super T> mapper)             對大整數求和。
16 static <T> Collector<T,?,Double>    averagingDouble(ToDoubleFunction<? super T> mapper)     它生成應用於輸入元素的小數數的算術平均值，參數示例:Double::valueOf
17 static <T> Collector<T,?,Double>    averagingInt(ToIntFunction<? super T> mapper)           它生成應用於輸入元素的整數值函數的算術平均值，參數示例：l->Integer.valueOf(l)
18 static <T> Collector<T,?,Double>    averagingLong(ToLongFunction<? super T> mapper)         它生成應用於輸入元素的大整數函數的算術平均值，參數示例：Long::valueOf
19 static <T> Collector<T,?,Long>    counting()              統計T元素的數量用。
20 static <T> Collector<T,?,Optional<T>>    maxBy(Comparator<? super T> comparator)     　　　　根據給定規則返回最大元素。參數示例：(a,b) -> a.length()-b.length()
21 static <T> Collector<T,?,Optional<T>>    minBy(Comparator<? super T> comparator)     　　　　根據給定規則返回最小元素。參數示例：(a,b) -> a.length()-b.length()
22 static <T> Collector<T,?,DoubleSummaryStatistics>    summarizingDouble(ToDoubleFunction<? super T> mapper)   對小數彙總統計，包括計數、求和、平均值、最大值、最小值信息。
23 static <T> Collector<T,?,IntSummaryStatistics>    summarizingInt(ToIntFunction<? super T> mapper)            對整數數彙總統計，包括計數、求和、平均值、最大值、最小值信息。
24 static <T> Collector<T,?,LongSummaryStatistics>    summarizingLong(ToLongFunction<? super T> mapper)         對大整數彙總統計，包括計數、求和、平均值、最大值、最小值信息。
25 
26 結合、分組
27 static Collector<CharSequence,?,String>    joining()       將結果鏈接成一個字符串。
28 static Collector<CharSequence,?,String>    joining(CharSequence delimiter)     將結果鏈接成一個字符串，中間用delimiter分隔。
29 static Collector<CharSequence,?,String>    joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)   將結果鏈接成一個字符串，中間用delimiter分隔，並可指定先後綴。
30 static <T> Collector<T,?,Map<Boolean,List<T>>>    partitioningBy(Predicate<? super T> predicate)  將流中的元素按照給定的校驗規則分爲兩個部分，放到一個map中返回，map的鍵是Boolean類型，值爲元素的列表List。參數示例：s -> s.length()>4)
31 static <T,D,A> Collector<T,?,Map<Boolean,D>>    partitioningBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)     同上，同時增長告終果處理方法，參數示例：s -> s.length()>4)， Collectors.toSet()
32 static <T,K> Collector<T,?,Map<K,List<T>>>    groupingBy(Function<? super T,? extends K> classifier)  根據分類函數對元素進行分組，並將結果返回到a Map。參數示例：String::length
33 static <T,K,A,D> Collector<T,?,Map<K,D>>    groupingBy(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)     根據分類函數對元素進行分組，而後使用downstream方法進一步處理元素。參數示例：String::length, Collectors.counting()
34 static <T,K,D,A,M extends Map<K,D>> Collector<T,?,M>    groupingBy(Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream)
35 根據分類函數對元素進行分組，添加告終果Map的生成方法，而後使用downstream方法進一步處理元素。參數示例：String::length,HashMap::new,Collectors.toSet()
36 static <T,K> Collector<T,?,Map<K,List<T>>>    groupingByConcurrent(Function<? super T,? extends K> classifier)    併發執行，功能同上
37 static <T,K,A,D> Collector<T,?,Map<K,D>>    groupingByConcurrent(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)     併發執行，功能同上
38 static <T,K,D,A,M extends Map<K,D>> Collector<T,?,M>    groupingByConcurrent(Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream)   併發執行，功能同上
39 
40 其餘
41 static <T,A,R,RR> Collector<T,A,RR>    collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher) 　　　　　　　 　 對一個已經獲得的Collector繼續進行finisher處理，示例：int length = list.stream().collect(Collectors.collectingAndThen(Collectors.toList(),e -> e.size()))
42 static <T,U,A,R> Collector<T,?,R>    mapping(Function<? super T,? extends U> mapper, Collector<? super U,A,R> downstream)     首先對流中的每一個元素進行映射，即類型轉換，而後再將新元素以給定的Collector進行概括。參數示例：Integer::valueOf,Collectors.toList()
43 static <T> Collector<T,?,Optional<T>>    reducing(BinaryOperator<T> op)  　　也是對流中的元素作統計概括做用,同Stream的reduce方法相似，參數示例：Integer::sum
44 static <T> Collector<T,?,T>    reducing(T identity, BinaryOperator<T> op)    給定初始值identity，後對流中的元素作統計概括
45 static <T,U> Collector<T,?,U>    reducing(U identity, Function<? super T,? extends U> mapper, BinaryOperator<U> op) 　　　　　　有初始值，還有針對元素的處理方案mapper，對流中的元素作統計概括，參數示例：0,String::length,Integer::sum

Collectors 靜態方法（都是返回一個Collector）

2.10 統計

另外，一些產生統計結果的收集器也很是有用。它們主要用於int、double、long等基本類型上，它們能夠用來產生相似以下的統計結果。

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
IntSummaryStatistics stats = numbers.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());

2.11 其餘還有

 1 distinct()
 2 count()
 3 mapToInt() 返回一個IntStream；
 4 mapToLong()
 5 mapToDouble()
 6 peek()
 7 limit()   取最多多少個
 8 skip()    跳過前多個個
 9 anyMatch(Predicate<? super T> predicate)
10 noneMatch(Predicate<? super T> predicate)
11 max(Comparator<? super T> comparator)
12 min(Comparator<? super T> comparator)

2.12 Stream 綜合實例

  1 public class Java8Tester {
  2     public static void main(String args[]) {
  3         System.out.println("使用 Java 7: ");
  4         // 計算空字符串
  5         List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
  6         System.out.println("列表: " + strings);
  7         long count = getCountEmptyStringUsingJava7(strings);
  8         System.out.println("空字符數量爲: " + count);
  9         count = getCountLength3UsingJava7(strings);
 10         System.out.println("字符串長度爲 3 的數量爲: " + count);
 11         // 刪除空字符串
 12         List<String> filtered = deleteEmptyStringsUsingJava7(strings);
 13         System.out.println("篩選後的列表: " + filtered);
 14         // 刪除空字符串，並使用逗號把它們合併起來
 15         String mergedString = getMergedStringUsingJava7(strings, ", ");
 16         System.out.println("合併字符串: " + mergedString);
 17         List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
 18         // 獲取列表元素平方數
 19         List<Integer> squaresList = getSquares(numbers);
 20         System.out.println("平方數列表: " + squaresList);
 21         List<Integer> integers = Arrays.asList(1, 2, 13, 4, 15, 6, 17, 8, 19);
 22         System.out.println("列表: " + integers);
 23         System.out.println("列表中最大的數 : " + getMax(integers));
 24         System.out.println("列表中最小的數 : " + getMin(integers));
 25         System.out.println("全部數之和 : " + getSum(integers));
 26         System.out.println("平均數 : " + getAverage(integers));
 27         System.out.println("隨機數: ");
 28         // 輸出10個隨機數
 29         Random random = new Random();
 30         for (int i = 0; i < 10; i++) {
 31             System.out.println(random.nextInt());
 32         }
 33         System.out.println("使用 Java 8: ");
 34         System.out.println("列表: " + strings);
 35         count = strings.stream().filter(string -> string.isEmpty()).count();
 36         System.out.println("空字符串數量爲: " + count);
 37         count = strings.stream().filter(string -> string.length() == 3).count();
 38         System.out.println("字符串長度爲 3 的數量爲: " + count);
 39         filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
 40         System.out.println("篩選後的列表: " + filtered);
 41         mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
 42         System.out.println("合併字符串: " + mergedString);
 43         squaresList = numbers.stream().map(i -> i * i).distinct().collect(Collectors.toList());
 44         System.out.println("Squares List: " + squaresList);
 45         System.out.println("列表: " + integers);
 46         IntSummaryStatistics stats = integers.stream().mapToInt((x) -> x).summaryStatistics();
 47         System.out.println("列表中最大的數 : " + stats.getMax());
 48         System.out.println("列表中最小的數 : " + stats.getMin());
 49         System.out.println("全部數之和 : " + stats.getSum());
 50         System.out.println("平均數 : " + stats.getAverage());
 51         System.out.println("隨機數: ");
 52         random.ints().limit(10).sorted().forEach(System.out::println);
 53         // 並行處理
 54         count = strings.parallelStream().filter(string -> string.isEmpty()).count();
 55         System.out.println("空字符串的數量爲: " + count);
 56     }
 57 
 58     private static int getCountEmptyStringUsingJava7(List<String> strings) {
 59         int count = 0;
 60         for (String string : strings) {
 61             if (string.isEmpty()) {
 62                 count++;
 63             }
 64         }
 65         return count;
 66     }
 67 
 68     private static int getCountLength3UsingJava7(List<String> strings) {
 69         int count = 0;
 70         for (String string : strings) {
 71             if (string.length() == 3) {
 72                 count++;
 73             }
 74         }
 75         return count;
 76     }
 77 
 78     private static List<String> deleteEmptyStringsUsingJava7(List<String> strings) {
 79         List<String> filteredList = new ArrayList<String>();
 80         for (String string : strings) {
 81             if (!string.isEmpty()) {
 82                 filteredList.add(string);
 83             }
 84         }
 85         return filteredList;
 86     }
 87 
 88     private static String getMergedStringUsingJava7(List<String> strings, String separator) {
 89         StringBuilder stringBuilder = new StringBuilder();
 90         for (String string : strings) {
 91             if (!string.isEmpty()) {
 92                 stringBuilder.append(string);
 93                 stringBuilder.append(separator);
 94             }
 95         }
 96         String mergedString = stringBuilder.toString();
 97         return mergedString.substring(0, mergedString.length() - 2);
 98     }
 99 
100     private static List<Integer> getSquares(List<Integer> numbers) {
101         List<Integer> squaresList = new ArrayList<Integer>();
102         for (Integer number : numbers) {
103             Integer square = new Integer(number.intValue() * number.intValue());
104             if (!squaresList.contains(square)) {
105                 squaresList.add(square);
106             }
107         }
108         return squaresList;
109     }
110 
111     private static int getMax(List<Integer> numbers) {
112         int max = numbers.get(0);
113         for (int i = 1; i < numbers.size(); i++) {
114             Integer number = numbers.get(i);
115             if (number.intValue() > max) {
116                 max = number.intValue();
117             }
118         }
119         return max;
120     }
121 
122     private static int getMin(List<Integer> numbers) {
123         int min = numbers.get(0);
124         for (int i = 1; i < numbers.size(); i++) {
125             Integer number = numbers.get(i);
126             if (number.intValue() < min) {
127                 min = number.intValue();
128             }
129         }
130         return min;
131     }
132 
133     private static int getSum(List numbers) {
134         int sum = (int) (numbers.get(0));
135         for (int i = 1; i < numbers.size(); i++) {
136             sum += (int) numbers.get(i);
137         }
138         return sum;
139     }
140 
141     private static int getAverage(List<Integer> numbers) {
142         return getSum(numbers) / numbers.size();
143     }
144 }

綜合實例

使用Java7:
列表:[abc,, bc, efg, abcd,, jkl]
空字符數量爲:2
字符串長度爲3的數量爲:3
篩選後的列表:[abc, bc, efg, abcd, jkl]
合併字符串: abc, bc, efg, abcd, jkl
平方數列表:[9,4,49,25]
列表:[1,2,13,4,15,6,17,8,19]
列表中最大的數:19
列表中最小的數:1
全部數之和:85
平均數:9
隨機數:
-393170844
-963842252
447036679
-1043163142
-881079698
221586850
-1101570113
576190039
-1045184578
1647841045

使用Java8:
列表:[abc,, bc, efg, abcd,, jkl]
空字符串數量爲:2
字符串長度爲3的數量爲:3
篩選後的列表:[abc, bc, efg, abcd, jkl]
合併字符串: abc, bc, efg, abcd, jkl
SquaresList:[9,4,49,25]
列表:[1,2,13,4,15,6,17,8,19]
列表中最大的數:19
列表中最小的數:1
全部數之和:85
平均數:9.444444444444445
隨機數:
-1743813696
-1301974944
-1299484995
-779981186
136544902
555792023
1243315896
1264920849
1472077135
1706423674
空字符串的數量爲:2

執行結果

3、Java 8 方法引用

當Lambda表達式中只是執行一個方法調用時，不用Lambda表達式，直接經過方法引用的形式可讀性更高一些。方法引用是一種更簡潔易懂的Lambda表達式。

方法引用經過方法的名字來指向一個方法。

方法引用可使語言的構造更緊湊簡潔，減小冗餘代碼。

方法引用使用一對冒號 :: 。

3.1方法引用

下面，咱們在 Car 類中定義了 4 個方法做爲例子來區分 Java 中 4 種不一樣方法的引用。

class Car {
    @FunctionalInterface
    public interface Supplier<T> {
        T get();
    }

    //Supplier是jdk1.8的接口，這裏和lamda一塊兒使用了
    public static Car create(final Supplier<Car> supplier) {
        return supplier.get();
    }

    public static void collide(final Car car) {
        System.out.println("Collided " + car.toString());
    }

    public void follow(final Car another) {
        System.out.println("Following the " + another.toString());
    }

    public void repair() {
        System.out.println("Repaired " + this.toString());
    }

    public static void main(String[] args) {
        //構造器引用：它的語法是Class::new，或者更通常的Class< T >::new實例以下：
         Car car  = Car.create(Car::new);
         Car car1 = Car.create(Car::new);
         Car car2 = Car.create(Car::new);
         Car car3 = new Car();
        List<Car> cars = Arrays.asList(car,car1,car2,car3);
        System.out.println("===================構造器引用========================");
        //靜態方法引用：它的語法是Class::static_method，實例以下：
        cars.forEach(Car::collide);
        System.out.println("===================靜態方法引用========================");
        //特定類的任意對象的方法引用：它的語法是Class::method實例以下：
        cars.forEach(Car::repair);
        System.out.println("==============特定類的任意對象的方法引用================");
        //特定對象的方法引用：它的語法是instance::method實例以下：
        final Car police = Car.create(Car::new);
        cars.forEach(police::follow);
        System.out.println("===================特定對象的方法引用===================");
    }
}

===================構造器引用========================
Collided mybatis.scaffold.Car@1218025c
Collided mybatis.scaffold.Car@816f27d
Collided mybatis.scaffold.Car@87aac27
Collided mybatis.scaffold.Car@3e3abc88
===================靜態方法引用========================
Repaired mybatis.scaffold.Car@1218025c
Repaired mybatis.scaffold.Car@816f27d
Repaired mybatis.scaffold.Car@87aac27
Repaired mybatis.scaffold.Car@3e3abc88
==============特定類的任意對象的方法引用================
Following the mybatis.scaffold.Car@1218025c
Following the mybatis.scaffold.Car@816f27d
Following the mybatis.scaffold.Car@87aac27
Following the mybatis.scaffold.Car@3e3abc88
===================特定對象的方法引用===================

執行結果

3.2方法引用實例

public class J8Tester {
    public interface StringFunc {
        String func(String n);
    }

    //靜態方法： 反轉字符串
    public static String strReverse(String str) {
        String result = ""; 
        for (int i = str.length() - 1; i >= 0; i--) {
            result += str.charAt(i);
        }
        return result;
    }
    
    public static String stringOp(StringFunc sf, String s) {
        return sf.func(s);
    }
    
    public static void main(String[] args) {
        String inStr = "lambda add power to Java";
        //MyStringOps::strReverse 至關於實現了接口方法func() 
        // 並在接口方法func()中做了MyStringOps.strReverse()操做
//        String outStr = stringOp(s -> J8Tester.strReverse(s), inStr);
        String outStr = stringOp(J8Tester :: strReverse, inStr);
        System.out.println("Original string: " + inStr);
        System.out.println("String reserved: " + outStr);
    }
}

Original string: lambda add power to Java
String reserved: avaJ ot rewop dda adbmal

執行結果

4、Java 8 函數式接口

函數式接口(FunctionalInterface)就是一個有且僅有一個抽象方法，可是能夠有多個非抽象方法的接口。

函數式接口能夠被隱式轉換爲lambda表達式。

函數式接口能夠現有的函數友好地支持 lambda。

JDK 1.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

4.1 JDK 1.8 新增長的函數接口

java.util.function 它包含了不少類，用來支持 Java的函數式編程，該包中的函數式接口有：

 1 BiConsumer<T,U>       表明了一個接受兩個輸入參數的操做，而且不返回任何結果
 2 BiFunction<T,U,R>     表明了一個接受兩個輸入參數的方法，而且返回一個結果
 3 BinaryOperator<T>     表明了一個做用於於兩個同類型操做符的操做，而且返回了操做符同類型的結果
 4 BiPredicate<T,U>      表明了一個兩個參數的boolean值方法
 5 BooleanSupplier       表明了boolean值結果的提供方
 6 Consumer<T>           表明了接受一個輸入參數而且無返回的操做
 7 DoubleBinaryOperator  表明了做用於兩個double值操做符的操做，而且返回了一個double值的結果。
 8 DoubleConsumer        表明一個接受double值參數的操做，而且不返回結果。
 9 DoubleFunction<R>     表明接受一個double值參數的方法，而且返回結果
10 DoublePredicate       表明一個擁有double值參數的boolean值方法
11 DoubleSupplier        表明一個double值結構的提供方
12 DoubleToIntFunction   接受一個double類型輸入，返回一個int類型結果。
13 DoubleToLongFunction  接受一個double類型輸入，返回一個long類型結果
14 DoubleUnaryOperator   接受一個參數同爲類型double,返回值類型也爲double。
15 Function<T,R>         接受一個輸入參數，返回一個結果。
16 IntBinaryOperator     接受兩個參數同爲類型int,返回值類型也爲int 。
17 IntConsumer           接受一個int類型的輸入參數，無返回值。
18 IntFunction<R>        接受一個int類型輸入參數，返回一個結果。
19 IntPredicate          接受一個int輸入參數，返回一個布爾值的結果。
20 IntSupplier           無參數，返回一個int類型結果。
21 IntToDoubleFunction   接受一個int類型輸入，返回一個double類型結果。
22 IntToLongFunction     接受一個int類型輸入，返回一個long類型結果。
23 IntUnaryOperator      接受一個參數同爲類型int,返回值類型也爲int 。
24 LongBinaryOperator    接受兩個參數同爲類型long,返回值類型也爲long。
25 LongConsumer          接受一個long類型的輸入參數，無返回值。
26 LongFunction<R>       接受一個long類型輸入參數，返回一個結果。
27 LongPredicate         R接受一個long輸入參數，返回一個布爾值類型結果。
28 LongSupplier          無參數，返回一個結果long類型的值。
29 LongToDoubleFunction  接受一個long類型輸入，返回一個double類型結果。
30 LongToIntFunction     接受一個long類型輸入，返回一個int類型結果。
31 LongUnaryOperator     接受一個參數同爲類型long,返回值類型也爲long。
32 ObjDoubleConsumer<T>  接受一個object類型和一個double類型的輸入參數，無返回值。
33 ObjIntConsumer<T>     接受一個object類型和一個int類型的輸入參數，無返回值。
34 ObjLongConsumer<T>    接受一個object類型和一個long類型的輸入參數，無返回值。
35 Predicate<T>          接受一個輸入參數，返回一個布爾值結果。
36 Supplier<T>           無參數，返回一個結果。
37 ToDoubleBiFunction<T,U>接受兩個輸入參數，返回一個double類型結果
38 ToDoubleFunction<T>   接受一個輸入參數，返回一個double類型結果
39 ToIntBiFunction<T,U>  接受兩個輸入參數，返回一個int類型結果。
40 ToIntFunction<T>      接受一個輸入參數，返回一個int類型結果。
41 ToLongBiFunction<T,U> 接受兩個輸入參數，返回一個long類型結果。
42 ToLongFunction<T>     接受一個輸入參數，返回一個long類型結果。
43 UnaryOperator<T>      接受一個參數爲類型T,返回值類型也爲T。

4.2 函數式接口實例

Predicate <T> 接口是一個函數式接口，它接受一個輸入參數 T，返回一個布爾值結果。

該接口包含多種默認方法來將Predicate組合成其餘複雜的邏輯（好比：與，或，非）。

該接口用於測試對象是 true 或 false。

咱們能夠經過如下實例（Java8Tester.java）來了解函數式接口 Predicate <T> 的使用：

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 是一個參數傳遞到 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 + " ");
            }
        }
    }
}

輸出全部數據:
1
2
3
4
5
6
7
8
9
輸出全部偶數:
2
4
6
8
輸出大於3的全部數字:
4
5
6
7
8
9

執行結果

5、Java 8 默認方法

Java 8 新增了接口的默認方法。

簡單說，默認方法就是接口能夠有實現方法，並且不須要實現類去實現其方法。

咱們只需在方法名前面加個default關鍵字便可實現默認方法。

爲何要有這個特性？

首先，以前的接口是個雙刃劍，好處是面向抽象而不是面向具體編程，缺陷是，當須要修改接口時候，須要修改所有實現該接口的類，目前的java 8以前的集合框架沒有foreach方法，一般能想到的解決辦法是在JDK裏給相關的接口添加新的方法及實現。然而，對於已經發布的版本，是無法在給接口添加新方法的同時不影響已有的實現。因此引進的默認方法。他們的目的是爲了解決接口的修改與現有的實現不兼容的問題。

5.1語法

默認方法語法格式以下：

public interface vehicle {
    default void print() {
        System.out.println("我是一輛車!");
    }
}

5.2多個默認方法

一個接口有默認方法，考慮這樣的狀況，一個類實現了多個接口，且這些接口有相同的默認方法，如下實例說明了這種狀況的解決方法：

public interface vehicle {
    default void print() {
        System.out.println("我是一輛車!");
    }
}
public interface fourWheeler {
    default void print() {
        System.out.println("我是一輛四輪車!");
    }
}

第一個解決方案是建立本身的默認方法，來覆蓋重寫接口的默認方法：

public class Car implements vehicle, fourWheeler {
    @Override
    public void print() {
        System.out.println("我是一輛四輪汽車!");
    }
}

第二種解決方案可使用 super 來調用指定接口的默認方法：

public class Car implements vehicle, fourWheeler {
    @Override
    public void print() {
        vehicle.super.print();
    }
}

5.3 靜態默認方法

Java 8 的另外一個特性是接口能夠聲明（而且能夠提供實現）靜態方法。例如：

public interface vehicle {
    default void print() {
        System.out.println("我是一輛車!");
    }
    // 靜態方法
    static void blowHorn() {
        System.out.println("按喇叭!!!");
    }
}

5.4 默認方法實例

咱們能夠經過如下代碼來了解關於默認方法的使用，能夠將代碼放入 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("我是一輛車!");
    }

    static void blowHorn() {
        System.out.println("按喇叭!!!");
    }
}

interface FourWheeler {
    default void print() {
        System.out.println("我是一輛四輪車!");
    }
}

class Car implements Vehicle, FourWheeler {
    public void print() {
        Vehicle.super.print();
        FourWheeler.super.print();
        Vehicle.blowHorn();
        System.out.println("我是一輛汽車!");
    }
}

View Code

我是一輛車!
我是一輛四輪車!
按喇叭!!!
我是一輛汽車!

執行結果

6、Java 8 日期時間 API

Java 8經過發佈新的Date-Time API (JSR 310)來進一步增強對日期與時間的處理。

在舊版的Java 中，日期時間API 存在諸多問題，其中有：

非線程安全 − 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類，但他們一樣存在上述全部的問題。

Java 8 在 java.time 包下提供了不少新的 API。如下爲兩個比較重要的 API：

Local(本地) − 簡化了日期時間的處理，沒有時區的問題。

Zoned(時區) − 經過制定的時區處理日期時間。

新的java.time包涵蓋了全部處理日期，時間，日期/時間，時區，時刻（instants），過程（during）與時鐘（clock）的操做。

6.1 本地化日期時間 API

LocalDate/LocalTime 和 LocalDateTime 類能夠在處理時區不是必須的狀況。代碼以下：

    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);
        
        LocalDateTime dateTime1 = LocalDateTime.parse("2019-10-17 12", DateTimeFormatter.ofPattern("yyyy-MM-dd HH"));
        System.out.println("dateTime1: " + dateTime1);
        //格式化輸出
        System.out.println(dateTime1.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH時mm分")));
        
      //獲取秒數
        Long second = LocalDateTime.now().toEpochSecond(ZoneOffset.of("+8"));
        System.out.println(second);
        //獲取毫秒數
        Long milliSecond = LocalDateTime.now().toInstant(ZoneOffset.of("+8")).toEpochMilli();
        System.out.println(milliSecond);
    }

當前時間: 2019-10-17T11:20:39.328
date1: 2019-10-17
月: OCTOBER, 日: 17, 秒: 39
date2: 2012-10-10T11:20:39.328
date3: 2014-12-12
date4: 22:15
date5: 20:15:30
dateTime1: 2019-10-17T12:00
2019年10月17日 12時00分
1571282439
1571282439343

執行結果

6.2 使用時區的日期時間API

若是咱們須要考慮到時區，就可使用時區的日期時間API：

public class Java8Tester {
    public static void main(String args[]) {
        Java8Tester java8tester = new Java8Tester();
        java8tester.testZonedDateTime();
    }
    public void testZonedDateTime() {
        // 獲取當前時間日期
        ZonedDateTime date1 = ZonedDateTime.parse("2015-12-03T10:15:30+05:30[Asia/Shanghai]");
        System.out.println("date1: " + date1);
        ZoneId id = ZoneId.of("Europe/Paris");
        System.out.println("ZoneId: " + id);
        ZoneId currentZone = ZoneId.systemDefault();
        System.out.println("當期時區: " + currentZone);
    }
}

執行以上腳本，輸出結果爲：

date1:2015-12-03T10:15:30+08:00[Asia/Shanghai]
ZoneId:Europe/Paris
當期時區: Asia/Shanghai

執行結果

7、Java 8 Optional 類

Optional 類是一個能夠爲null的容器對象。若是值存在則isPresent()方法會返回true，調用get()方法會返回該對象。

Optional 是個容器：它能夠保存類型T的值，或者僅僅保存null。Optional提供不少有用的方法，這樣咱們就不用顯式進行空值檢測。

Optional 類的引入很好的解決空指針異常。

7.1類聲明

如下是一個 java.util.Optional<T> 類的聲明：

publicfinalclassOptional<T> extendsObject

7.2 類方法

 1 static <T> Optional<T> empty()                    返回空的 Optional 實例。
 2 boolean equals(Object obj)                        判斷其餘對象是否等於 Optional。
 3 Optional<T> filter(Predicate<? super <T> predicate)                若是值存在，而且這個值匹配給定的 predicate，返回一個Optional用以描述這個值，不然返回一個空的Option Optional。
 4 <U> Optional<U> flatMap(Function<? super T,Optional<U>> mapper)    若是值存在，返回基於Optional包含的映射方法的值，不然返回一個空的Optional
 5 T get()                                            若是在這個Optional中包含這個值，返回值，不然拋出異常：NoSuchElementException
 6 int hashCode()                                     返回存在值的哈希碼，若是值不存在返回 0。
 7 void ifPresent(Consumer<? super T> consumer)       若是值存在則使用該值調用 consumer , 不然不作任何事情。
 8 boolean isPresent()                                若是值存在則方法會返回true，不然返回 false。
 9 <U>Optional<U> map(Function<? super T,? extends U> mapper)         若是存在該值，提供的映射方法，若是返回非null，返回一個Optional描述結果。
10 static <T> Optional<T> of(T value)                 返回一個指定非null值的Optional。
11 static <T> Optional<T> ofNullable(T value)         若是爲非空，返回 Optional 描述的指定值，不然返回空的 Optional。
12 T orElse(T other)                                  若是存在該值，返回值，不然返回 other。
13 T orElseGet(Supplier<? extends T> other)           若是存在該值，返回值，不然觸發 other，並返回 other 調用的結果。
14 <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)    若是存在該值，返回包含的值，不然拋出由 Supplier 繼承的異常
15 String toString()                                  返回一個Optional的非空字符串，用來調試
16 注意： 這些方法是從 java.lang.Object 類繼承來的。

7.3 Optional 實例

public class Java8Tester {
    public static void main(String args[]) {
        Java8Tester java8Tester = new Java8Tester();
        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(java8Tester.sum(a, b));
    }

    public 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、Java 8 Nashorn JavaScript

Nashorn 一個 javascript 引擎。

從JDK1.8開始，Nashorn取代Rhino(JDK 1.6, JDK1.7)成爲Java的嵌入式JavaScript引擎。Nashorn徹底支持ECMAScript 5.1規範以及一些擴展。它使用基於JSR292的新語言特性，其中包含在JDK 7中引入的 invokedynamic，將JavaScript編譯成Java字節碼。

與先前的Rhino實現相比，這帶來了2到10倍的性能提高。

8.1 jjs

jjs是個基於Nashorn引擎的命令行工具。它接受一些JavaScript源代碼爲參數，而且執行這些源代碼。

例如，咱們建立一個具備以下內容的sample.js文件：

print('Hello World!');

打開控制檯，輸入如下命令：

$ jjs sample.js

以上程序輸出結果爲：

HelloWorld!

8.2 jjs 交互式編程

打開控制檯，輸入如下命令：

$ jjs
jjs>print("Hello, World!")
Hello,World!
jjs> quit()
>>

8.3 傳遞參數

打開控制檯，輸入如下命令：

$ jjs -- a b c
jjs>print('字母: '+arguments.join(", "))
字母: a, b, c
jjs>

8.4 Java 中調用 JavaScript

使用ScriptEngineManager, JavaScript 代碼能夠在 Java 中執行，實例以下：

public class Java8Tester {
    public static void main(String args[]) {

        ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
        ScriptEngine nashorn = scriptEngineManager.getEngineByName("nashorn");

        String name = "Runoob";
        Integer result = null;

        try {
            nashorn.eval("print('" + name + "')");
            result = (Integer) nashorn.eval("10 + 2");

        } catch (ScriptException e) {
            System.out.println("執行腳本錯誤: " + e.getMessage());
        }

        System.out.println(result.toString());
    }

Runoob

12

執行結果

8.5 JavaScript 中調用 Java

如下實例演示瞭如何在 JavaScript 中引用 Java 類：

varBigDecimal=Java.type('java.math.BigDecimal');
function calculate(amount, percentage){
   var result =newBigDecimal(amount).multiply(
   newBigDecimal(percentage)).divide(newBigDecimal("100"),2,BigDecimal.ROUND_HALF_EVEN);
   return result.toPlainString();
}

var result = calculate(568000000000000000023,13.9);

$ jjs sample.js
78952000000000002017.94

執行結果

9、Java8 Base64

在Java8中，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 內嵌類

static class Base64.Decoder 該類實現一個解碼器用於，使用 Base64 編碼來解碼字節數據。

static class Base64.Encoder 該類實現一個編碼器，使用 Base64 編碼來編碼字節數據。

9.2 方法

1 static Base64.Decoder getDecoder()        返回一個 Base64.Decoder ，解碼使用基本型 base64 編碼方案。
2 static Base64.Encoder getEncoder()        返回一個 Base64.Encoder ，編碼使用基本型 base64 編碼方案。
3 static Base64.Decoder getMimeDecoder()    返回一個 Base64.Decoder ，解碼使用 MIME 型 base64 編碼方案。
4 static Base64.Encoder getMimeEncoder()    返回一個 Base64.Encoder ，編碼使用 MIME 型 base64 編碼方案。
5 static Base64.Encoder getMimeEncoder(int lineLength, byte[] lineSeparator)    返回一個 Base64.Encoder ，編碼使用 MIME 型 base64 編碼方案，能夠經過參數指定每行的長度及行的分隔符。
6 static Base64.Decoder getUrlDecoder()     返回一個 Base64.Decoder ，解碼使用 URL 和文件名安全型 base64 編碼方案。
7 static Base64.Encoder getUrlEncoder()     返回一個 Base64.Encoder ，編碼使用 URL 和文件名安全型 base64 編碼方案。
8 注意：Base64 類的不少方法從 java.lang.Object 類繼承。

9.3 Base64 實例

如下實例演示了Base64 的使用:

public class Java8Tester {
    public static void main(String args[]) {
        try {
            // 使用基本編碼
            String base64encodedString = Base64.getEncoder().encodeToString("runoob?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("TutorialsPoint?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) {
            System.out.println("Error :" + e.getMessage());
        }
    }
}

Base64 編碼字符串 (基本) :cnVub29iP2phdmE4
原始字符串: runoob?java8
Base64編碼字符串(URL):VHV0b3JpYWxzUG9pbnQ_amF2YTg=
Base64編碼字符串(MIME):MjY5OGRlYmEtZDU0ZS00MjY0LWE3NmUtNzFiNTYwY2E4YjM1NmFmMDFlNzQtZDE2NC00MDk3LTlh
ZjItYzNkNGJjNmQwOWE2OWM0NDJiN2YtOGM4Ny00MjhkLWJkMzgtMGVlZjFkZjkyYjJhZDUwYzk0
ZWMtNDE5ZC00MTliLWEyMTAtZGMyMjVkYjZiOTE3ZTkxMjljMTgtNjJiZC00YTFiLTg3MzAtOTA0
YzdjYjgxYjQ0YTUxOWNkMTAtNjgxZi00YjQ0LWFkZGMtMzk1YzRkZjIwMjcyMzA0MTQzN2ItYzBk
My00MmQyLWJiZTUtOGM0MTlmMWIxM2MxYTY4NmNiOGEtNTkxZS00NDk1LThlN2EtM2RjMTZjMWJk
ZWQyZTdhNmZiNDgtNjdiYy00ZmFlLThjNTYtMjcyNDNhMTRhZTkyYjNiNWY2MmEtNTZhYS00ZDhk
LWEwZDYtY2I5ZTUwNzJhNGE1

執行結果

文章主要內容來源：https://blog.csdn.net/yitian_66/article/details/81010434