JDK和IDE

IDE

    集成開發環境（IDE，Integrated Development Environment ）是用於提供程序開發環境的應用程序，通常包括代碼編輯器、編譯器、調試器和圖形用戶界面工具。集成了代碼編寫功能、分析功能、編譯功能、調試功能等一體化的開發軟件服務套。全部具有這一特性的軟件或者軟件套（組）均可以叫集成開發環境。

JDK

   JDK(Java Development Kit) 是 Java 語言的軟件開發工具包( SDK)。

   SE(J2SE)，standard edition，標準版，是咱們一般用的一個版本，從JDK 5.0開始，更名爲Java SE。

   EE(J2EE)，enterprise edition，企業版，使用這種JDK開發J2EE應用程序，從JDK 5.0開始，更名爲Java EE。

   ME(J2ME)，micro edition，主要用於移動設備、嵌入式設備上的java應用程序，從JDK 5.0開始，更名爲Java ME。

   沒有JDK的話，沒法編譯Java程序，若是想只運行Java程序，要確保已安裝相應的JRE。

JDK1.7特性

1，switch中可使用字串了
String s = "test";  
switch (s) {  
case "test" :  
     System.out.println("test");
case "test1" :  
    System.out.println("test1");
    break ;  
default :  
    System.out.println("break");
    break ;  
}

2.運用List<String> tempList = new ArrayList<>(); 即泛型實例化類型自動推斷
3.語法上支持集合，而不必定是數組

final List<Integer> piDigits = [ 1,2,3,4,5,8 ];  
4.新增一些取環境信息的工具方法

File System.getJavaIoTempDir() // IO臨時文件夾

File System.getJavaHomeDir() // JRE的安裝目錄

File System.getUserHomeDir() // 當前用戶目錄

File System.getUserDir() // 啓動java進程時所在的目錄5

5.Boolean類型反轉，空指針安全,參與位運算

Boolean Booleans.negate(Boolean booleanObj)

True => False , False => True, Null => Null

boolean Booleans.and(boolean[] array)

boolean Booleans.or(boolean[] array)

boolean Booleans.xor(boolean[] array)

boolean Booleans.and(Boolean[] array)

boolean Booleans.or(Boolean[] array)

boolean Booleans.xor(Boolean[] array)

6.兩個char間的equals
boolean Character.equalsIgnoreCase(char ch1, char ch2)
7.安全的加減乘除
int Math.safeToInt(long value)

int Math.safeNegate(int value)

long Math.safeSubtract(long value1, int value2)

long Math.safeSubtract(long value1, long value2)

int Math.safeMultiply(int value1, int value2)

long Math.safeMultiply(long value1, int value2)

long Math.safeMultiply(long value1, long value2)

long Math.safeNegate(long value)

int Math.safeAdd(int value1, int value2)

long Math.safeAdd(long value1, int value2)

long Math.safeAdd(long value1, long value2)

int Math.safeSubtract(int value1, int value2)

8.map集合支持併發請求，且能夠寫成 Map map = {name:"xxx",age:18};

JDK1.8特性

  

前幾天電腦上的JDK自動更新到1.8，這兩天瞭解了一下JDK1.8的一些新特性。下面就來淺談一下我所瞭解的。

咱們都知道，Java是不能多繼承的，可是能夠多實現。它與C++不一樣，C++是能夠多繼承的。儘管Java能夠實現多個接口，可是接口中只能有抽象方法，不能有具體的實現。可是在JDK1.8中，接口裏新增了默認方法。 能夠對默認方法進行具體的實現，可是這個方法必須是default。 看下面這段代碼：

 1 interface AA{  2 public int add(int a,int b); //申明方法  3 default void sing(String name){ //默認方法  4 System.out.println("The song name is " + name);  5  }  6 }  7  8 public class CC implements AA{  9 public static void main(String[] args){ 10 AA aa = new AA(){ //匿名內部類 11 public int add(int a,int b){ 12 return (a + b); 13  } 14  }; 15 aa.sing("The Bird And The Bee"); //方法調用 16 System.out.println(aa.add(5,3)); 17  } 18 }

在接口AA中，咱們有兩個方法，而且有一個默認方法。在main函數中，咱們對AA中的add方法進行實現，以後調用AA中的兩個方法，這段代碼是正確 的。如今來想一個問題，既然如今接口中能夠有方法的實現，並且接口又是能夠多繼承的，那麼若是兩個接口中有一樣的方法簽名的兩個方法，那麼在實現這兩個接 口的實現類中，會有衝突嗎？ 

接口C繼承了接口A和B，而在A，B中有相同方法簽名的函數。注：函數的方法簽名包括：函數名，參數個數，參數類型以及順序，不包括返回值。代碼以下：

 

 1 interface A1{  2 default int add(int a,int b){  3 return (a + b);  4  }  5 default void say(){  6 System.out.println("Hello,I am A1");  7  }  8 }  9 10 interface B1{ 11 default int subtraction(int a,int b){ 12 return (a - b); 13  } 14 default void say(){ 15 System.out.println("Hello,I am B1"); 16  } 17 } 18 19 interface C1 extends A1,B1{}

上面這段代碼在編譯時候會出現錯誤。

以後咱們稍稍修改一下咱們的接口C1，讓它覆蓋父接口的say()方法。並完善咱們代碼：

 1 interface A1{  2 default int add(int a,int b){  3 return (a + b);  4  }  5 default void say(){  6 System.out.println("Hello,I am A1");  7  }  8 }  9 10 interface B1{ 11 default int subtraction(int a,int b){ 12 return (a - b); 13  } 14 default void say(){ 15 System.out.println("Hello,I am B1"); 16  } 17 } 18 19 interface C1 extends A1,B1{ 20  @Override 21 default void say(){ 22 //B1.super.say(); 指定調用父接口中的say() 23 System.out.println("Hello,I am C1"); //有本身的實現 24  } 25 } 26 27 public class Test implements C1{ 28 public static void main(String[] args){ 29 Test t = new Test(); 30  t.say(); 31 System.out.println(t.add(3,5)); 32 System.out.println(t.subtraction(5,2)); 33  } 34 }

咱們使用覆蓋父類的方式來避免上面錯出現的衝突。在覆蓋方法中，咱們能夠有本身的實現，也能夠指定實現某個父接口中的方法。好，解決了這個問題， 咱們來繼續思考另一個問題，若是一個子類繼承一個基類並實現了一個接口，而且不幸的事，基類中有一個方法是接口中的默認方法，此時又會出現衝突嗎？

代碼以下：

 1 interface A1{  2 default int add(int a,int b){  3 System.out.println("add() in interface A1 ---> ");  4 return (a + b);  5  }  6 default void say(){  7 System.out.println("Hello,I am interface A1");  8  }  9 } 10 11 class A2{ 12 public int add(int a,int b){ 13 System.out.print("add() in class A2 ---> "); 14 return (a + b); 15  } 16 public void say(){ 17 System.out.println("Hello,I am class A2"); 18  } 19 } 20 21 public class Test extends A2 implements A1{ 22 public static void main(String[] args){ 23 Test t = new Test(); 24  t.say(); 25 System.out.println(t.add(3,5)); 26  } 27 }

運行結果以下：

從結果能夠看出， 當基類和接口中的默認方法具備相同方法簽名的函數時，子類優先繼承基類中的函數實現，而不是父接口中的默認方法。 若是父類沒有相同的方法簽名，子類纔會繼承接口中的默認方法。說了這麼多關於默認方法，想想JDK1.8爲何要新增長這一特性呢？因爲 Collection庫須要爲批處理操做添加新的方法，如forEach()，stream()等，可是不能修改現有的Collection接口——若是 那樣作的話全部的實現類都要進行修改，包括不少客戶自制的實現類。拿forEach()方法來講，之前咱們遍歷一個集合的時候，都是本身寫遍歷操做的代 碼，相信下面這段代碼咱們都是很熟悉的：

 1 import java.util.*;  2  3 public class Newlist{  4 public static void main(String[] args){  5 List<String> strList = new ArrayList<String>();  6 strList.add("123");  7 strList.add("234");  8 strList.add("345");  9 strList.add("456"); 10 strList.add("567"); 11 12 for(String list : strList){ 13  System.out.println(list); 14  } 15  } 16 }

可是如今沒必要要這麼麻煩了，咱們能夠直接使用現成的方法進行遍歷。使用下面這行代碼，代替上面的for循環，便可。

list.forEach(o->{System.out.println(o);});

forEach()方法在List接口中就是一個默認方法，因此全部實現了這個接口，繼承這接口的類或接口都具備這個方法，這就是新增默認方法的緣由。

這行代碼又引出了一個新特性-->lambda表達式。 lambda表達式就是一個匿名函數，主要用於替換之前普遍使用的內部匿名類，各類回調，好比事件響應器、傳入Thread類的Runnable等。 Java8有一個短時間目標和一個長期目標。短時間目標是：配合「集合類批處理操做」的內部迭代和並行處理（上面將已經講到）；長期目標是將Java向函數式 編程語言這個方向引導（並非要徹底變成一門函數式編程語言，只是讓它有更多的函數式編程語言的特性，關於函數式編程語言和命令式編程語言請參看這篇博客 http://blog.jobbole.com/42178/ ），也正是因爲這個緣由，Oracle並無簡單地使用內部類去實現λ表達式，而是使用了一種更動態、更靈活、易於未來擴展和改變的策略（invokedynamic）。下面舉個簡單例子瞭解lambda表達式：

 1 interface A{ //函數接口  2 public int add(int a,int b);  3 boolean equals(Object obj);  4 default void say(){  5 System.out.println("Hello,I am A");  6  }  7 }  8 public class Lambda implements A{  9 public static void main(String[] args){ 10 /* A a = new A(){ 匿名內部類實現add() 11  public int add(int a,int b){ 12  return (a+b); 13  } 14  }; */ 15 A a = (x,y)->{return (x+y);}; 16  a.say(); 17 System.out.println(a.add(5,3)); 18  } 19 }

在上面的main中咱們使用了lambda表示式對接口A中add()方法進行了實現，上面註釋是咱們不使用表達式而是使用匿名內部類去實現接口中的非默認方法。能夠看出， λ 表達式是由(參數)、->、{}三部分構成的。左邊是接口定義方法的參數，能夠省略參數類型，而且只有當方法僅惟一參數時，小括號才能省略，沒有參 數應該寫成()。表達式右邊是代碼塊，也就是咱們平時書寫函數體中的內容。請注意：可以使用λ表達式的目標類型必須是函數接口，函數接口的定義是：一個接 口，若是隻有一個顯式聲明的抽象方法，那麼它就是一個函數接口。通常用@FunctionalInterface標註出來（也能夠不標）。說的簡單一點就 是在一個接口中只有一個顯示申明的函數。在上面的例子中，咱們的接口A就是函數接口，由於只有一個顯示申明的add()。你可能疑惑，那equals方法 呢？equals方法是Object的，全部的接口都會聲明Object的public方法——它是隱式的。 下面舉一個線程的例子：

 1 public class Lambda{  2 public static void main(String[] args){  3 Thread tt = new Thread(new Runnable(){ //通常作法  4 public void run(){  5 for(int i=0;i<100;i++){  6 System.out.println("normal function!");  7  }  8  }  9  }); 10 11 Thread tt = new Thread(()->{ //使用lambda表示式 12 for(int i=0;i<100;i++){ 13 System.out.println("lambda expression!"); 14  } 15  }); 16  tt.start(); 17  } 18 }

JDK1.8有不少新特性，我列出的只是很小一部分，做爲Java語言忠實的粉絲，感受學習Java愈來愈有趣。