Java 8 新特性

 Java 9都快出來了，把Java 8學習一波，很多語言特性在別的語言中都見過，一些優秀的語言特性，好語言都會整合！

程式設計風格

Java8希望有自己的程式設計風格，並與Java7分開，以下展示以下兩者的區別。

package com.tencent;
 
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
 
public class Main {
 
 public static void main(String[] args) {
   List<String> names1 = new ArrayList<>();
 
   names1.add("Google");
   names1.add("Runoob");
   names1.add("Tencent");
   names1.add("Baidu");
 
   List<String> names2 = new ArrayList<>();
 
   names2.add("Google");
   names2.add("Runoob");
   names2.add("Tencent");
   names2.add("Baidu");
  }
 
 private void sortUsingJava7(List<String> names) {
   names.sort(new Comparator<String>() {
     @Override
     public int compare(String o1, String o2) {
       return o1.compareTo(o2);
     }
   });
  }
 
 private void sortUsingJava8(List<String> names) {
   names.sort((s1, s2) -> s1.compareTo(s2));
  }
}
 

       Lambda表示式，也可稱為閉包，它是推動 Java 8 釋出的最重要新特性。

Lambda 允許把函式作為一個方法的引數（函式作為引數傳遞進方法中）。

使用 Lambda 表示式可以使程式碼變的更加簡潔緊湊。

特徵

·      可選類型宣告：不需要宣告引數類型，編譯器可以統一識別引數值。

·      可選的引數圓括號：一個引數無需定義圓括號，但多個引數需要定義圓括號。

·      可選的大括號：如果主體包含了一個語句，就不需要使用大括號。

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

變數作用域

       編譯本質還是inner class，所以引用外部變數的時候一定要為final

package com.tencent;
 
public class Java8Tester {
 final static String salutation = "Hello! ";
 
 public static void main(String[] args) {
   Java8Tester tester = new Java8Tester();
 
   // 型別宣告
   MathOperation addtion = (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,addtion));
   System.out.println("10 - 5 = " + tester.operate(10, 5,subtraction));
   System.out.println("10 * 5 = " + tester.operate(10, 5,multiplication));
   System.out.println("10 / 5 = " + tester.operate(10, 5,division));
   // 不用括號
   GreetingService greetingService1 = message ->System.out.println("Hello " + message);
   // 用括號
   GreetingService greetingService2 = (message) -> {
     System.out.println("Hello " + message);
   };
   // 變數作用域 final
   GreetingService greetingService3 = message ->System.out.println(salutation + message);
 
   greetingService1.sayMessage("Runoob");
   greetingService2.sayMessage("Google");
   greetingService3.sayMessage("Tencent");
  }
 
 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);
  }
}
 

方法引用

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

方法引用可以使語言的構造更緊湊簡潔，減少冗餘程式碼。

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

package com.tencent;
 
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Supplier;
 
public class Car {
 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) {
   final Car car = Car.create(Car::new);
 
   final List<Car> cars = Collections.singletonList(car);
 
    cars.forEach(Car::collide);
 
   cars.forEach(Car::repair);
 
   final Car police = Car.create(Car::new);
   cars.forEach(police::follow);
 
   ArrayList<String> names = new ArrayList<>();
 
   names.add("Google");
   names.add("Runoob");
   names.add("Taobao");
   names.add("Baidu");
 
   names.forEach(System.out::println);
  }
}

函式式介面

函式式介面(Functional Interface)就是一個具有一個方法的普通介面。

函式式介面可以被隱式轉換為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

JDK 1.8 新增加的函式介面：

java.util.function

package com.tencent;
 
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);
 
   System.out.println("輸出所有資料：");
 
   eval(list, n -> true);
 
   System.out.println("輸出所有偶數：");
   eval(list, n -> n % 2 == 0);
 
   System.out.println("輸出大於 3 的所有數字：");
   eval(list, n -> n > 3);
  }
 
 private static void eval(List<Integer> list,Predicate<Integer> predicate) {
   for (Integer n : list) {
     if (predicate.test(n)) {
       System.out.println(n);
     }
    }
  }
}

默認方法

Java 8 新增了介面的預設方法。

簡單說，預設方法就是介面可以有實現方法，而且不需要實現類去實現其方法。

我們只需在方法名前面加個default關鍵字即可實現預設方法。

為什麼要有這個特性？

首先，之前的介面是個雙刃劍，好處是面向抽象而不是面向具體程式設計，缺陷是，當需要修改介面時候，需要修改全部實現該介面的類，目前的java 8之前的集合框架沒有foreach方法，通常能想到的解決辦法是在JDK裡給相關的介面新增新的方法及實現。然而，對於已經發布的版本，是沒法在給介面新增新方法的同時不影響已有的實現。所以引進的預設方法。他們的目的是為了解決介面的修改與現有的實現不相容的問題。

package com.tencent;
 
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
 
public class Java8Tester {
 
 public static void main(String[] args) {
   Vehicle vehicle = new Trunk();
   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 Trunk implements Vehicle, FourWheeler{
 public void print() {
   Vehicle.super.print();
   FourWheeler.super.print();
   Vehicle.blowHorn();
   System.out.println("我是一輛汽車！");
  }
}

Java 8 API添加了一個新的抽象稱為流Stream，可以讓你以一種宣告的方式處理資料。

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

Stream API可以極大提供Java程式設計師的生產力，讓程式設計師寫出高效率、乾淨、簡潔的程式碼。

這種風格將要處理的元素集合看作一種流， 流在管道中傳輸， 並且可以在管道的節點上進行處理， 比如篩選， 排序，聚合等。

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

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

生成流

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

·       stream()−為集合建立序列流。

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

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

Stream 提供了新的方法 'forEach'來迭代流中的每個資料。以下程式碼片段使用 forEach 輸出了10個隨機數：

Randomrandom = newRandom(); random.ints().limit(10).forEach(System.out::println);

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

filter 方法用於通過設定的條件過濾出元素。以下程式碼片段使用 filter方法過濾出空字串：

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

limit

limit 方法用於獲取指定數量的流。 以下程式碼片段使用 limit方法打印出 10 條資料：

Randomrandom = newRandom(); random.ints().limit(10).forEach(System.out::println);

sorted 方法用於對流進行排序。以下程式碼片段使用 sorted方法對輸出的 10 個隨機數進行排序：

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

parallelStream 是流並行處理程式的代替方法。以下例項我們使用 parallelStream來輸出空字串的數量：

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

我們可以很容易的在順序執行和並行直接切換。

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); 
StringmergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", ")); 
System.out.println("合併字串: " + mergedString);

統計

另外，一些產生統計結果的收集器也非常有用。它們主要用於int、double、long等基本型別上，它們可以用來產生類似如下的統計結果。

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5); 
int SummaryStatisticsstats = integers.stream().mapToInt((x) -> x).summaryStatistics(); 
System.out.println("列表中最大的數 : " + stats.getMax()); 
System.out.println("列表中最小的數 : " + stats.getMin()); 
System.out.println("所有數之和 : " + stats.getSum()); System.out.println("平均數 : " + stats.getAverage());

package com.tencent;
 
import java.util.*;
import java.util.stream.Collectors;
 
public class Java8Tester {
 
 public static void main(String[] args) {
   System.out.println("使用 Java 7：");
 
   List<String> strings = Arrays.asList("abc","", "bc", "efg", "abcd", "","jkl");
   System.out.println("列表：" + strings);
 
   long count = getCountEmptyStringUsingJava7(strings);
   System.out.println("空字元數量為: " +count);
   count = getCountLength3UsingJava7(strings);
 
   System.out.println("字串長度為 3 的數量為: " + count);
 
   // 刪除空字串
   List<String> filtered = deleteEmptyStringsUsingJava7(strings);
   System.out.println("篩選後的列表: " +filtered);
 
   // 刪除空字串，並使用逗號把它們合併起來
   String mergedString = getMergedStringUsingJava7(strings, ",");
   System.out.println("合併字串: " +mergedString);
   List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
 
   // 獲取列表元素平方數
   List<Integer> squaresList = getSquares(numbers);
   System.out.println("平方數列表: " +squaresList);
   List<Integer> integers = Arrays.asList(1, 2, 13, 4, 15, 6, 17, 8,19);
 
   System.out.println("列表: " + integers);
   System.out.println("列表中最大的數 : " +getMax(integers));
   System.out.println("列表中最小的數 : " +getMin(integers));
   System.out.println("所有數之和 : " +getSum(integers));
   System.out.println("平均數 : " +getAverage(integers));
   System.out.println("隨機數: ");
 
   // 輸出10個隨機數
   Random random = new Random();
 
   for (int i = 0; i < 10; i++) {
     System.out.println(random.nextInt());
    }
 
   System.out.println("使用 Java 8：");
   System.out.println("列表：" + strings);
 
   count = strings.stream().filter(String::isEmpty).count();
   System.out.println("空字串數量為：" +count);
 
   count = strings.stream().filter(string -> string.length() ==3).count();
   System.out.println("字串長度為 3 的數量為: " + count);
 
   filtered = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.toList());
   System.out.println("篩選後的列表: " +filtered);
 
   mergedString = strings.stream().filter(string ->!string.isEmpty()).collect(Collectors.joining(", "));
   System.out.println("合併字串: " +mergedString);
 
   squaresList = numbers.stream().map(i -> i *i).distinct().collect(Collectors.toList());
   System.out.println("Squares List: " + squaresList);
 
   System.out.println("列表: " + integers);
 
   IntSummaryStatistics stats = integers.stream().mapToInt(x ->x).summaryStatistics();
   System.out.println("列表中最大的數 : " +stats.getMax());
   System.out.println("列表中最小的數 : " + stats.getMin());
   System.out.println("所有數之和 : " +stats.getSum());
   System.out.println("平均數 : " +stats.getAverage());
 
   System.out.println("隨機數: ");
 
   random.ints().limit(10).sorted().forEach(System.out::println);
 
   // 並行處理
   count = strings.parallelStream().filter(String::isEmpty).count();
   System.out.println("空字串的數量為：" +count);
  }
 
 private static List<String>deleteEmptyStringsUsingJava7(List<String> strings) {
   List<String> filteredList = new ArrayList<>();
 
   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 long getCountLength3UsingJava7(List<String>strings) {
   int count = 0;
 
   for (String string : strings) {
 
     if (string.length() == 3) {
       count++;
     }
    }
   return count;
  }
 
 private static long getCountEmptyStringUsingJava7(List<String>strings) {
   int count = 0;
 
   for (String string : strings) {
 
     if (string.isEmpty()) {
       count++;
     }
    }
   return count;
  }
 
 private static List<Integer> getSquares(List<Integer>numbers) {
   List<Integer> squaresList = new ArrayList<>();
 
   for (Integer number : numbers) {
     Integer square = number * number;
 
     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 > max) {
       max = number;
     }
    }
   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 < min) {
       min = number;
     }
    }
   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();
  }
}

Optional 類是一個可以為null的容器物件。如果值存在則isPresent()方法會返回true，呼叫get()方法會返回該物件。

Optional 是個容器：它可以儲存型別T的值，或者僅僅儲存null。Optional提供很多有用的方法，這樣我們就不用顯式進行空值檢測。

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

package com.tencent;
 
import java.util.Optional;
 
public class Java8Tester {
 
 public static void main(String[] args) {
   Java8Tester tester = new Java8Tester();
   Integer value1 = null;
   Integer value2 = 10;
// Optional.ofNullable - 允許傳遞為 null 引數
   Optional<Integer> a = Optional.ofNullable(value1);
// Optional.of - 如果傳遞的引數是 null，丟擲異常 NullPointerException
   Optional<Integer> b = Optional.of(value2);
   System.out.println(tester.sum(a, b));
  }
 
 private 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(0);
//Optional.get - 獲取值，值需要存在
   Integer value2 = b.get();
   return value1 + value2;
  }
}

Nashorn 一個javascript 引擎。

從JDK 1.8開始，Nashorn取代Rhino(JDK 1.6, JDK1.7)成為Java的嵌入式JavaScript引擎。Nashorn完全支援ECMAScript 5.1規範以及一些擴充套件。它使用基於JSR 292的新語言特性，其中包含在JDK 7中引入的 invokedynamic，將JavaScript編譯成Java位元組碼。

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

jjs

jjs是個基於Nashorn引擎的命令列工具。它接受一些JavaScript原始碼為引數，並且執行這些原始碼。

package com.tencent;
 
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
 
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) {
     e.printStackTrace();
    }
   System.out.println(result.toString());
  }
}
var BigDecimal = Java.type('java.math.BigDecimal');
 
function calculate(amount, percentage) {
   var result = new BigDecimal(amount).multiply(newBigDecimal(percentage).divide(new BigDecimal('100'), 2,BigDecimal.ROUND_HALF_EVEN));
 
   return result.toPlainString();
}
 
var result = calculate(568000000000000000023,13.9);
print(result); 

日期時間 API

Java 8通過釋出新的Date-TimeAPI (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）的操作。

本地化日期時間 API

package com.tencent;
 
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;
 
public class Java8Tester {
 
 public static void main(String[] args) {
   Java8Tester tester = new Java8Tester();
 
   tester.testLocalDateTime();
  }
 
 public void testLocalDateTime() {
   // 獲取當前的日期時間
   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);
  }
}

使用時區的日期時間API

package com.tencent;
 
import java.time.ZoneId;
import java.time.ZonedDateTime;
 
public class Java8Tester {
 
 public static void main(String[] args) {
   Java8Tester tester = new Java8Tester();
 
   tester.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);
  }
}

在Java 8中，Base64編碼已經成為Java類庫的標準。

Java 8 內建了 Base64 編碼的編碼器和解碼器。

Base64工具類提供了一套靜態方法獲取下面三種BASE64編解碼器：

基本：輸出被對映到一組字元A-Za-z0-9+/，編碼不新增任何行標，輸出的解碼僅支援A-Za-z0-9+/。

URL：輸出對映到一組字元A-Za-z0-9+_，輸出是URL和檔案。

MIME：輸出隱射到MIME友好格式。輸出每行不超過76字元，並且使用'\r'並跟隨'\n'作為分割。編碼輸出最後沒有行分割。

package com.tencent;
 
importjava.io.UnsupportedEncodingException;
import java.util.Base64;
import java.util.UUID;
 
public class Java8Tester {
 
 public static void main(String[] args) {
   try {
     // 使用基本編碼
     String base64encodedString =Base64.getEncoder().encodeToString("learn java 8 fromrunoob".getBytes("UTF8"));
      System.out.println("Base64 編碼字串 (基本)：" +base64encodedString);
 
     // 解碼
     byte[] base64decodedBytes =Base64.getDecoder().decode(base64encodedString);
     System.out.println("原始字串：" + newString(base64decodedBytes, "UTF8"));
 
     base64encodedString =Base64.getUrlEncoder().encodeToString("TutorialsPoint?java8".getBytes("UTF8"));
     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("UTF8");
     String mimeEncodedString =Base64.getMimeEncoder().encodeToString(mimeBytes);
     System.out.println("Base64 編碼字串 (MIME):" + mimeEncodedString);
    }catch (UnsupportedEncodingException e) {
     e.printStackTrace();
    }
  }
}