Java程式設計師必備基礎：JDK 5-15都有哪些經典新特性

前言

JDK 15釋出啦~ 我們一起回顧JDK 5-15 的新特性吧，大家一起學習哈~

本文已經收錄到github

❝
https://github.com/whx123/JavaHome
❞

「公眾號：撿田螺的小男孩」

Java 5 新特性

1. 泛型

泛型本質是引數化型別，解決不確定具體物件型別的問題。

 List<String> strList=new ArrayList<String>();

2. 增強迴圈（for-each）

for-each迴圈簡化了集合的遍歷。

String [] str = {"關注","公眾號","撿田螺的小男孩"};
for (String temp:str) {
     System.out.println(temp);
}

3. 自動封箱拆箱

自動裝箱: 就是將基本資料型別自動轉換成對應的包裝類。
自動拆箱：就是將包裝類自動轉換成對應的基本資料型別。

包裝型別有：Integer,Double,Float,Long,Short,Character和Boolean

Integer i =666;  //自動裝箱
int a= i;     //自動拆箱

4. 列舉

關鍵字enum可以將一組具名的值的有限集合建立為一種新的型別，而這些具名的值可以作為常規的程式元件使用，這就是列舉型別。

enum SeasonEnum {
    SPRING,SUMMER,FALL,WINTER;
}

5. 可變引數

我們在定義方法引數的時候不確定定義多少個，就可以定義為「可變引數」，它本質上是一個「陣列」。

public static void main(String[] args) throws Exception {
    String [] str = {"關注","公眾號","撿田螺的小男孩"};
    testVarargs(str);
    String str1 = "關注公眾號，撿田螺的小男孩";
    testVarargs(str1);
}
//可變引數String... args
private static void testVarargs(String... args) {
    for (String arg : args) {
        System.out.println(arg);
    }
}

6. 註解

可以把註解理解為程式碼裡的特殊標記，這些標記可以在編譯，類載入，執行時被讀取，並執行相應的處理。

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

7.靜態匯入

通過import static類，就可以使用類裡的靜態變數或方法。看一下例子哈~

import static java.lang.System.out; //靜態匯入System類的靜態變數out
public class Test {
    public static void main(String[] args) throws Exception {
        String str1 = "關注公眾號，撿田螺的小男孩";
        System.out.println(str1); //常規寫法
        out.println(str1);  //靜態匯入，可以直接使用out輸出
    }
}

8. 執行緒併發庫（JUC）

JDK5 豐富了執行緒處理功能，java.util.concurrent包提供了以下的類、介面：

❝

執行緒池：ExecutorService介面
執行緒護斥：Lock 類
執行緒通訊：Condition介面
同步佇列：ArrayBlockingQueue類
同步集合：ConcurrentHashMap類
❞

Java 6 新特性

1.Desktop類和SystemTray類

JDK 6在java.awt包下，新增了兩個類：Desktop類和SystemTray類

❝

「Desktop類」: 用來開啟系統預設瀏覽器瀏覽指定的URL,開啟系統預設郵件客戶端發郵件等
「SystemTray類」:用來在系統托盤區建立一個托盤程式,如果在微軟的Windows上，它被稱為“工作列”狀態區域。
❞

//獲取Desktop例項
Desktop desktop = Desktop.getDesktop();
desktop.browse(URI.create("https://www.baidu.com"));

2. 使用JAXB2來實現物件與XML之間的對映

JAXB,即Java Architecture for XML Binding,可以實現物件與XML之間的對映，常用註解如下:

❝

@XmlRootElement：註解在類上面，對應xml的跟元素，使用name屬性定義根節點的名稱。
@XmlElement：指定一個欄位或get/set方法對映到xml的節點，使用name屬性定義這個根節點的名稱。
@XmlAttribute：將JavaBean物件的屬性對映為xml的屬性,使用name屬性為生成的xml屬性指定別名。
@XmlAccessorType:定義對映這個類中的何種型別都需要對映到xml。
@XmlSchema: 將包對映到XML名稱空間
❞

「看個例子吧~」

public class JAXB2XmlTest {

    public static void main(String[] args) throws JAXBException, IOException {
        
        List<Singer> list = new ArrayList<>();
        list.add(new Singer("jay", 8));
        list.add(new Singer("eason", 10));

        SingerList singerList = new SingerList();
        singerList.setSingers(list);

        String str = JAXB2XmlTest.beanToXml(singerList, SingerList.class);
        String path = "C:\\jay.txt";
        BufferedWriter bfw = new BufferedWriter(new FileWriter(new File(path)));
        bfw.write(str);
        bfw.close();

    }

    private static String beanToXml(Object obj, Class<?> load) throws JAXBException {
        JAXBContext context = JAXBContext.newInstance(load);
        Marshaller marshaller = context.createMarshaller();
        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
        marshaller.setProperty(Marshaller.JAXB_ENCODING, "GBK");
        StringWriter writer = new StringWriter();
        marshaller.marshal(obj,writer);
        return writer.toString();
    }
}
public class Singer {

    private String name;
    private int age;
    public Singer(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @XmlAttribute(name="name")
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @XmlAttribute(name="age")
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
@XmlRootElement(name="list")
public class SingerList {

    private List<Singer> singers;
    
    @XmlElement(name="singer")
    public List<Singer> getSingers() {
        return singers;
    }

    public void setSingers(List<Singer> singers) {
        this.singers = singers;
    }
}

「執行效果：」

<?xml version="1.0" encoding="GBK" standalone="yes"?>
<list>
    <singer age="8" name="jay"/>
    <singer age="10" name="eason"/>
</list>

3.輕量級 Http Server API

JDK 6中提供了簡單的Http Server API，可以構建嵌入式Http伺服器,同時支援Http和Https協議。HttpServer會呼叫HttpHandler實現類的回撥方法來處理客戶端請求,這裡使用者只需實現HttpHandler介面就可以了。

/**
 * 根據Java提供的API實現Http伺服器
 */
public class MyHttpServer {

    /**
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        //建立HttpServer伺服器
        HttpServer httpServer = HttpServer.create(new InetSocketAddress(8080), 10);
        //將 /jay請求交給MyHandler處理器處理
        httpServer.createContext("/", new MyHandler());
        httpServer.start();
    }
}

public class MyHandler implements HttpHandler {

    public void handle(HttpExchange httpExchange) throws IOException {
        //請求頭
        Headers headers = httpExchange.getRequestHeaders();
        Set<Map.Entry<String, List<String>>> entries = headers.entrySet();

        StringBuffer response = new StringBuffer();
        for (Map.Entry<String, List<String>> entry : entries){
            response.append(entry.toString() + "\n");
        }
        //設定響應頭屬性及響應資訊的長度
        httpExchange.sendResponseHeaders(200, response.length());
        //獲得輸出流
        OutputStream os = httpExchange.getResponseBody();
        os.write(response.toString().getBytes());
        os.close();
    }
}

4. 插入式註解處理API

❝
JDK 6提供了插入式註解處理API，可以讓我們定義的註解在編譯期而不是執行期生效，從而可以在編譯期修改位元組碼。lombok框架就是使用該特性來實現的，Lombok通過註解的方式，在編譯時自動為屬性生成構造器、getter/setter、equals、hashcode、toString等方法，大大簡化了程式碼的開發。
❞

5. STAX

STAX，是JDK6中一種處理XML文件的API。

public class STAXTest {

    public static void main(String[] args) throws Exception {

        XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
        XMLEventReader xmlEventReader = xmlInputFactory.createXMLEventReader(new FileInputStream("C:\\jay.xml"));
        XMLEvent event = null;
        StringBuffer stringBuffer = new StringBuffer();
        while (xmlEventReader.hasNext()) {
            event = xmlEventReader.nextEvent();
            stringBuffer.append(event.toString());
        }
        System.out.println("xml文件解析結果：");
        System.out.println(stringBuffer);
    }
}

「執行結果:」

xml文件解析結果：
<?xml version="1.0" encoding='GBK' standalone='yes'?><list>
    <singer name='jay' age='8'></singer>
    <singer name='eason' age='10'></singer>
</list>ENDDOCUMENT

6. Common Annotations

❝
Common annotations原本是Java EE 5.0(JSR 244)規範的一部分，現在SUN把它的一部分放到了Java SE 6.0中。隨著Annotation元資料功能加入到Java SE 5.0裡面，很多Java 技術都會用Annotation部分代替XML檔案來配置執行引數。
❞

以下列舉Common Annotations 1.0裡面的幾個Annotations:

@Generated：用於標註生成的原始碼
@Resource：用於標註所依賴的資源，容器據此注入外部資源依賴，有基於欄位的注入和基於setter方法的注入兩種方式。
@Resources：同時標註多個外部依賴，容器會把所有這些外部依賴注入
@PostConstruct：標註當容器注入所有依賴之後執行的方法，用來進行依賴注入後的初始化工作，只有一個方法可以標註為PostConstruct 。
@PreDestroy：當物件例項將要被從容器當中刪掉之前，要執行的回撥方法要標註為PreDestroy

7. Compiler API

javac編譯器可以把.java的原始檔編譯為.class檔案，JDK 6的新特性Compiler API(JSR 199)也可以動態編譯Java原始檔。

public class CompilerApiTest {
    public static void main(String[] args) throws Exception {
        JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
        StandardJavaFileManager standardJavaFileManager = javaCompiler.getStandardFileManager(null,null,null);
        Iterable<? extends JavaFileObject> javaFileObjects = standardJavaFileManager.getJavaFileObjects("C:\\Singer.java");
        javaCompiler.getTask(null, standardJavaFileManager, null, null, null, javaFileObjects).call();
        standardJavaFileManager.close();
    }
}

執行結果：會在C目錄生成Singer.class檔案

8. 對指令碼語言的支援（如: ruby, groovy, javascript）

JDK6增加了對指令碼語言的支援(JSR 223)，原理是將指令碼語言編譯成位元組碼，這樣指令碼語言也能享用Java平臺的諸多優勢，包括可移植性，安全等。JDK6實現包含了一個基於Mozilla Rhino的指令碼語言引擎,因此可以支援javascript，當然JDK也支援ruby等其他語言

public class JavaScriptTest {

    public static void main(String[] args) throws Exception {
        ScriptEngineManager factory = new ScriptEngineManager();
        ScriptEngine engine = factory.getEngineByName("JavaScript");
        String script;
        try {
            script = "print('Hello')";
            engine.eval(script);// 執行指令碼
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//output
Hello

Java 7 新特性

1.switch 支援String字串型別。

String singer = "jay";
switch (singer) {
       case "jay" :
            System.out.println("周杰倫");
             break;
       case "eason" :
            System.out.println("陳奕迅");
            break ;
       default :
            System.out.println("其他");
            break ;
   }

2.try-with-resources，資源自動關閉

JDK 7 之前:

BufferedReader br = new BufferedReader(new FileReader("d:七里香.txt"));
try {
   return br.readLine();
} finally {
   br.close();
}

JDK 7 之後：

/*
 * 宣告在try括號中的物件稱為資源，在方法執行完畢後會被自動關閉
 */
try (BufferedReader br = new BufferedReader(new FileReader("d:七里香.txt")) {
   return br.readLine();
}

3. 整數型別如（byte，short，int，long）能夠用二進位制來表示

//0b或者0B表示二進位制
int a = 0b010;
int b = 0B010;

4. 數字常量支援下劃線

int a = 11_11;//a的值為1111，下劃線不影響實際值，提升可讀性

5. 泛型例項化型別自動推斷,即”<>”

JDK 7 之前：

Map<String, List<String>> map = new HashMap<String, List<String>>();

JDK 7之後：

//不須宣告型別,自動根據前面<>推斷其型別
Map<String, List<String>> map = new HashMap<>();

6.一個catch中捕獲多個異常型別，用（|）分隔開

JDK 7之前

try{
   //do something
} catch (FirstException e) {
     logger.error(e);
} catch (SecondException e) {
     logger.error(ex);
}

JDk 7之後

try{
   //do something
} catch (FirstException | SecondException e) {
     logger.error(e);
}

7. 增強的檔案系統

Java7 提供了全新的NIO2.0 API，方便檔案管理的編碼。如，可以在java.nio.file包下使用Path、Paths、Files、WatchService等常用型別。

Path path = Paths.get("C:\\jay\\七里香.txt"); //建立Path物件
byte[] bytes= Files.readAllBytes(path);  //讀取檔案
System.out.println(path.getFileName()); //獲取當前檔名稱
System.out.println(path.toAbsolutePath()); // 獲取檔案絕對路徑
System.out.println(new String(bytes, "utf-8"));

8. Fork/join 框架

Java7提供的一個用於並行執行任務的框架，是一個把大任務分割成若干個小任務，最終彙總每個小任務結果後得到大任務結果的框架。

Fork/join計算1-1000累加值：

public class ForkJoinPoolTest {

    private static final Integer DURATION_VALUE = 100;

    static class ForkJoinSubTask extends RecursiveTask<Integer>{

        // 子任務開始計算的值
        private Integer startValue;
        // 子任務結束計算的值
        private Integer endValue;

        private ForkJoinSubTask(Integer startValue , Integer endValue) {
            this.startValue = startValue;
            this.endValue = endValue;
        }

        @Override
        protected Integer compute() {
            //小於一定值DURATION,才開始計算
            if(endValue - startValue < DURATION_VALUE) {
                System.out.println("執行子任務計算：開始值 = " + startValue + ";結束值 = " + endValue);
                Integer totalValue = 0;
                for (int index = this.startValue; index <= this.endValue; index++) {
                    totalValue += index;
                }
                return totalValue;
            } else {
                // 將任務拆分，拆分成兩個任務
                ForkJoinSubTask subTask1 = new ForkJoinSubTask(startValue, (startValue + endValue) / 2);
                subTask1.fork();
                ForkJoinSubTask subTask2 = new ForkJoinSubTask((startValue + endValue) / 2 + 1 , endValue);
                subTask2.fork();
                return subTask1.join() + subTask2.join();
            }
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // Fork/Join框架的執行緒池
        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinTask<Integer> taskFuture =  pool.submit(new ForkJoinSubTask(1,1000));

        Integer result = taskFuture.get();
        System.out.println("累加結果是:" + result);

    }
}

執行結果：

...
執行子任務計算：開始值 = 189;結束值 = 250
執行子任務計算：開始值 = 251;結束值 = 313
執行子任務計算：開始值 = 314;結束值 = 375
執行子任務計算：開始值 = 376;結束值 = 438
執行子任務計算：開始值 = 439;結束值 = 500
執行子任務計算：開始值 = 501;結束值 = 563
執行子任務計算：開始值 = 564;結束值 = 625
執行子任務計算：開始值 = 626;結束值 = 688
執行子任務計算：開始值 = 689;結束值 = 750
執行子任務計算：開始值 = 751;結束值 = 813
執行子任務計算：開始值 = 814;結束值 = 875
執行子任務計算：開始值 = 876;結束值 = 938
執行子任務計算：開始值 = 939;結束值 = 1000
累加結果是:500500

Java 8 新特性

1.lambada表示式

Lambda 允許把函式作為一個方法的引數，傳遞到方法中

語法格式：

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

程式碼示例：

Arrays.asList("jay", "Eason", "SHE").forEach(
       ( String singer ) -> System.out.print( singer + ",") );

2. 函式式介面

Lambda的設計者為了讓現有的功能與Lambda表示式很好相容，設計出函式式介面。

函式式介面是指只有一個函式的介面，可以隱式轉換為lambada表示式。
Java 8 提供了註解@FunctionalInterface，顯示宣告一個函式式介面。
java.lang.Runnable和java.util.concurrent.Callable是函式式介面的例子~

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

3. 方法引用

方法引用提供了非常有用的語法，可以直接引用已有Java類或物件（例項）的方法或構造器。它與Lambda表示式配合使用，可以減少冗餘程式碼，使程式碼更加簡潔。

//利用函式式介面Consumer的accept方法實現列印，Lambda表示式如下
Consumer<String> consumer = x -> System.out.println(x);
consumer.accept("jay");
//引用PrintStream類（也就是System.out的型別）的println方法，這就是方法引用
consumer = System.out::println;
consumer.accept("關注公眾號撿田螺的小男孩");

4. 預設方法

預設方法就是一個在接口裡面有了一個實現的方法。它允許將新方法新增到介面，但不強制實現了該介面的類必須實現新的方法。

public interface ISingerService {
    // 預設方法
    default void sing(){
        System.out.println("唱歌");
    }
    void writeSong();
}

//JaySingerServiceImpl 不用強制實現ISingerService的預設sing()方法
public class JaySingerServiceImpl implements ISingerService {
    @Override
    public void writeSong() {
        System.out.println("寫了一首七里香");
    }
}

5.Stream API

Stream API，支援對元素流進行函式式操作，它整合在Collections API 中，可以對集合進行批量操作。常用API：

filter 篩選
map流對映
reduce 將流中的元素組合起來
collect 返回集合
sorted 排序
flatMap 流轉換
limit返回指定流個數
distinct去除重複元素

public class Singer {

    private String name;
    private Integer songNum;
    private Integer age;
    ...
}

List<Singer> singerList = new ArrayList<Singer>();
singerList.add(new Singer("jay", 11, 36));
singerList.add(new Singer("eason", 8, 31));
singerList.add(new Singer("JJ", 6, 29));

List<String> singerNameList = singerList.stream()
                .filter(singer -> singer.getAge() > 30)  //篩選年齡大於30
                .sorted(Comparator.comparing(Singer::getSongNum))  //根據歌曲數量排序
                .map(Singer::getName)  //提取歌手名字
                .collect(Collectors.toList()); //轉換為List

6. Optional

Java 8引入Optional類，用來解決NullPointerException。Optional代替if...else解決空指標問題，使程式碼更加簡潔。