在前邊的博文中，我已經介紹了Java核心的容器IO等，現在我來說一下java中的數據類型。在java中，一切東西皆為對象（這句話意思是java中絕大數情況都用對象），極少數不是對象的，也存在與之對應的對象（比如基本數據類型存在與之對應的包裝類，數組有List對象可以代替）
Java中數據類型 主要有“基本數據類型”、“String”、“引用類型” （基本的引用類型不多做介紹，在下一篇博文中着重介紹“枚舉”，也算是引用類型的一種）
一：基本數據類型
1.1基本數據類型的定義
byte、char、int、 float 、double、long...這些屬於java的基本數據類型。具體用法可以參照 （Java基本數據類型總結 ) .在java看來，使用基本類型並不是面向對象的設計，於是提供一些專門的包裝類。實際開發中，不需要我們考慮到底是用基本類型還是包裝類（Java提供了自動裝箱機制）。當然基本類型還是有必要學習一下的。
1.1.1按種類了解基本類型
基本類型可以分為三類，字符類型char，布爾類型boolean以及數值類型byte、short、int、long、float、double。JAVA中的數值類型不存在無符號的，它們的取值范圍是固定的，不會隨着機器硬件環境或者操作系統的改變而改變
Java決定了每種簡單類型的大小，並不隨着機器結構的變化而變化。這正是Java程序具有很強移植能力的原因之一。下表列出了Java中定義的簡單類型、占用二進制位數及對應的封裝器類。
| 簡單類型 |
boolean |
byte |
char |
short |
Int |
long |
float |
double |
void |
| 二進制位數 |
1 |
8 |
16 |
16 |
32 |
64 |
32 |
64 |
-- |
| 封裝器類 |
Boolean |
Byte |
Character |
Short |
Integer |
Long |
Float |
Double |
Void |
這張表可以簡單的看一下，但不推薦花費太多時間（實際開發不需要，如果是應付考試還是需要記一下的）。因為 Java語言之所以流行就是希望程序員可以消耗更少的心力在語法上，從而省出更多的時間去整理具體的業務邏輯。在基本數據類型這一塊，Java提供自動裝箱機制，下面簡單介紹一下自動裝箱。
1.1.2Java中自動裝箱
自動裝箱就可以簡單的理解為將基本數據類型封裝為對象類型，來符合java的面向對象。比如你可以直接把一個int值復制給一個Integer對象
//聲明一個Integer對象 Integer num = 10;
自動裝箱的時候，存在一個細節點就是“對於值從–128到127之間的值，它們被裝箱為Integer對象后，會存在內存中被重用，始終只存在一個對象”,測試如下
//在-128~127 之外的數
Integer num1 = 297; Integer num2 = 297;
System.out.println("num1==num2: "+(num1==num2)); // 在-128~127 之內的數 Integer num3 = 97; Integer num4 = 97; System.out.println("num3==num4: "+(num3==num4)); //測試結果：num1==num2: false \n num3==num4: true
有時候，只能用包裝類，不能用基本數據類型，比如集合內
具體的細節可以參考這幾位仁兄的博客 （Java 自動裝箱與拆箱(Autoboxing and unboxing)，java 自動裝箱與拆箱）
1.2 基本數據類型的保存位置
基本類型存儲在棧中，處於效率考慮，基本類型保存在棧中。延伸一下，包裝類保存在堆中（注意我之前說過的-127到128之間的包裝類Integer）
1.3 堆棧的簡單介紹（這個和基本數據類型沒有太大關系相當於是擴展內容）
Java的堆是一個運行時數據區，不需要程序代碼來顯式的釋放，由垃圾回收來負責即可。堆的優勢是可以動態地分配內存 大小，生存期也不必事先告訴編譯器（因為是在運行時動態分配內存的，Java的垃圾收集器會自動收走這些不再使用的數據）。但缺點是，由於要在運行時動態分配內存，存取速度較慢。
棧的優勢是，存取速度比堆要快，僅次於寄存器，棧數據可以共享。但缺點是，存在棧中的數據大小與生存期必須是確定的，缺乏靈活性。棧中主要存放一些基本類型的變量數據（int, short, long, byte, float, double, boolean, char）和引用數據類型（這個和基本數據類型無關，不多做介紹）
1.3.1 數據共享簡單介紹
//基本數據類型的共享和對象不一樣，對象共享的本質上是引用,對象修改會影響另外一個變量，基本類型只是共享的值，當值修改時，實際上是讓變量又重新指向了另一個地方
public static void main(String[] args) { int a = 5; int b = 5;//一定是先找棧里有沒有5，有就讓b也指向5 a = 6; //先找棧里有沒有6，如果沒有則新建6並讓a指向
System.out.println(b); }
1.3.2 局部變量與成員變量保存位置簡單介紹
對於成員變量和局部變量：成員變量就是方法外部，類的內部定義的變量；局部變量就是方法或語句塊內部定義的變量。局部變量必須初始化。
- 形式參數是局部變量，局部變量的數據存在於棧內存中。棧內存中的局部變量隨着方法的消失而消失。
- 成員變量存儲在堆中的對象里面，由垃圾回收器負責回收
1.class BirthDate {
2. private int day; //day是成員變量
3. private int month;
4. private int year;
5. public BirthDate(int d, int m, int y) {
6. day = d; //d是局部變量
7. month = m;
8. year = y;
9. }
10. 省略get,set方法………
11.}
1.3.3 java中常量簡單介紹
- 十六進制整型常量：以十六進制表示時，需以0x或0X開頭，如0xaa,0X9f。
- 八進制整型常量：八進制必須以0開頭，如0123，034。
- 長整型： 長整型必須以L作結尾，如9L,342L。
- 浮點數常量： 由於小數常量的默認類型是double型，所以float類型的后面一定要加f(F)。同樣帶小數的變量默認為double類型。 如：float f;f=1.3f;//必須聲明f。
- 字符常量： 字符型常量需用兩個單引號括起來（注意字符串常量是用兩個雙引號括起來）。Java中的字符占兩個字節。
1.4 Java基本類型的“類型轉換”
簡單類型數據間的轉換,有兩種方式:自動轉換和強制轉換,通常發生在表達式中或方法的參數傳遞時。
1.4.1 自動轉換：是JVM根據條件自動幫助我們轉換，可以簡單了解一下轉換規則。
當一個較"小"數據與一個較"大"的數據一起運算時,系統將自動將"小"數據轉換成"大"數據,再進行運算 。
這些類型由"小"到"大"分別為 (byte，short，char)--int--long--float—double，這里我們所說的"大"與"小",並不是指占用字節的多少,而是指表示值的范圍的大小 。所以byte --char--short之間不可以自動轉換
1.4.2 強制轉換：
將"大"數據轉換為"小"數據時，你必須使用強制類型轉換。即你必須采用下面這種語句格式： int n=(int)3.14159/2;可以想象，這種轉換肯定可能會導致溢出或精度的下降
- 表達式的數據類型自動提升 eg 所有的byte,short,char型的值將被提升為int型；
- 包裝類和基本類型轉換 ：實際上Java存在一個自動裝箱的機制，他可以自動轉換。但是，我們可以用構造器轉為包裝類；用包裝類對象的xxxValue()把包裝類轉為基本類型
- 其它類型間轉為字符串：①調用類的串轉換方法:X.toString(); ②自動轉換:X+""; ③使用String的方法:String.volueOf(X);
- 字符串轉為其它類型 ①先轉換成相應的封裝器實例,再調用對應的方法轉換成其它類型 new Double("3.1").doubleValue().或者Double.valueOf("32.1").doubleValue()②靜態parseXXX方法String s = "1";byte b = Byte.parseByte( s );
- Date類與其它數據類型的相互轉換 ：整型和Date類之間並不存在直接的對應關系，只是你可以使用int型為分別表示年、月、日、時、分、秒，這樣就在兩者之間建立了一個對應關系 。具體轉換，可能用到format類
1.4.3 備注
只有boolean不參與數據類型的轉換
二：String類型
在實際開發中 String使用非常廣泛。於是Java設計者針對String做了非常多的優化來提高效率，這雖然提高了程序的效率，但是在一定程度上也會給我們開發提高了難度，於是在Thinking in Java中單獨把String當作一個章節。下面我會從整體上總結一下String,一些具體的方法可以去查詢API（Java API）
2.1 String創建方式
new是按照面向對象的標准語法，在內存使用上存在比較大的浪費。所以String對象的創建是不需要new的（這樣可以提高效率，但是如果用new創建字符串也不會報錯）
2.1.1在這里，延伸一下，java中創建對象的方式一共存在五種：
分別是 new 關鍵字、Class類的 newInstance 方法、Constructor類的 newInstance 方法、String對象的 clone方法、反序列化機制。但是String對象還有一種特殊的創建方式，就是通過使用 “ 或 ’ 包裹字符序列
public static void main(String[] args)
{
String s = "Hello World!";//實際上當""的時候java就創建了該對象
System.out.println(s);
}
下面的代碼詳細的對比了java的正常創建形式（“”）和 new的區別 (參照自 深入理解Java：String ）,在這里，我推薦一下 String的原理與用法總結 。該博主圖畫的還是挺清晰的，一目了然
public static void main(String[] args) {
String s1 = "abc"; // ↑ 在字符串池創建了一個對象 String s2 = "abc"; // ↑ 字符串pool已經存在對象“abc”(共享),所以創建0個對象，累計創建一個對象 System.out.println("s1 == s2 : " + (s1 == s2)); // ↑ true 指向同一個對象， System.out.println("s1.equals(s2) : " + (s1.equals(s2))); String s3 = new String("abc"); // ↑ 創建了兩個對象，一個存放在字符串池中，一個存在與堆區中； // ↑ 還有一個對象引用s3存放在棧中 String s4 = new String("abc"); // ↑ 字符串池中已經存在“abc”對象，所以只在堆中創建了一個對象 System.out.println("s3 == s4 : " + (s3 == s4)); // ↑false s3和s4棧區的地址不同，指向堆區的不同地址 System.out.println("s3.equals(s4) : " + (s3.equals(s4))); // ↑true s3和s4的值相同 System.out.println("s1 == s3 : "+(s1==s3)); //↑false 存放的地區多不同，一個棧區，一個堆區 System.out.println("s1.equals(s3) : "+(s1.equals(s3))); //↑true 值相同 /** * 情景三： * 由於常量的值在編譯的時候就被確定(優化)了。 * 在這里，"ab"和"cd"都是常量，因此變量str3的值在編譯時就可以確定。 * 這行代碼編譯后的效果等同於： String str3 = "abcd"; */ String str1 = "ab" + "cd"; //1個對象 String str11 = "abcd"; System.out.println("str1 = str11 : "+ (str1 == str11)); /** * 情景四： * 局部變量str2,str3存儲的是存儲兩個拘留字符串對象(intern字符串對象)的地址
* 第三行代碼原理(str2+str3)： * 運行期JVM首先會在堆中創建一個StringBuilder類， * 同時用str2指向的拘留字符串對象完成初始化， * 然后調用append方法完成對str3所指向的拘留字符串的合並， * 接着調用StringBuilder的toString()方法在堆中創建一個String對象， * 最后將剛生成的String對象的堆地址存放在局部變量str4中
* 而str5存儲的是字符串池中"abcd"所對應的拘留字符串對象的地址。 * str4與str5地址當然不一樣了 * 內存中實際上有五個字符串對象： * 三個拘留字符串對象、一個String對象和一個StringBuilder對象。 */ String str2 = "ab"; //1個對象 String str3 = "cd"; //1個對象 String str4 = str2+str3; String str5 = "abcd"; System.out.println("str4 = str5 : " + (str4==str5)); // false //↑------------------------------------------------------over /** * 情景五： * JAVA編譯器對string + 基本類型/常量 是當成常量表達式直接求值來優化的。 * 運行期的兩個string相加，會產生新的對象的，存儲在堆(heap)中 */ String str6 = "b"; String str7 = "a" + str6; String str67 = "ab"; System.out.println("str7 = str67 : "+ (str7 == str67)); //↑str6為變量，在運行期才會被解析。 final String str8 = "b"; String str9 = "a" + str8; String str89 = "ab"; System.out.println("str9 = str89 : "+ (str9 == str89)); //↑str8為常量變量，編譯期會被優化 }
2.1.2 簡單的概括一下：
用“”創建對象的時候，String對象是放到常量池中，只會創建一個，每次都是先去找一下常量池有沒有該字符串
用 new創建對象，會在隊中創建一個對象，然后在棧內創建該對象應用，每次都是新創建
2.2 String類初始化后是不可變的(immutable)
String類初始化之后不可變，因為java設計者不希望我們方法傳參是字符串的時候，方法內修改會影響外邊的串，所以采取了一種傳遞拷貝的方式（也就是傳值）
String ss = "this is the origen String";
TestString.showString(ss);
public static void showString(String s){ System.out.println(s); }
2.2.1 Java中String不可變是怎么一回事
java中，一旦產生String對象，該對象就不會在發生變化。但是String另一方面的確提供了修改String的方法。這看起來很矛盾，實際上是我們沒有仔細的了解那些修改的方法
比如replace(),如果可以看到源碼，可以清楚的看到該方法實際上新產生一個字符串，替換操作是針對新的字符串。（下圖參考自參考Java進階01 String類，簡單的表示replace()方法調用時
s的變化）
下邊的代碼 ：我在原字符串的基礎上添加了一句話，然后判斷他們是否相同（如果是同一個對象修改，==輸出結果應該是true）
String s1 = "我";
s1+="我想在加點東西";
system.out.println(s1 == s2)//輸出結果是false
思考一下 "s1指向的對象中的字符串是什么"（我們潛意識的認為s1也會被修改，但是當s2 = "s2"時，實際上s2的引用已經被修改，它和s1沒關系了）
String s1 = "s1";
String s2 = s1; s2 = "s2";//s1指向的對象中的字符串是什么?
System.out.println(s1);//輸出結果是s1
再重復一遍，無論是修改字符串的方法還是對字符串賦值，都和普通的對象不同。賦值是讓字符串指向一個新的字符串，方法傳參是copy一份值，傳入進去。
再比如說：String str=”kv”+”ill”+” “+”ans”; 就是有4個字符串常量，首先”kv”和”ill”生成了”kvill”存在內存中，然后”kvill”又和” ” 生成 “kvill “存在內存中，最后又和生成了”kvill ans”;並把這個字符串的地址賦給了str
所以 + 會產生很多臨時變量。下文中會說到StringBuilder 來避免這種情況。不過有一種特殊情況。 "ab"+"cd" 在JVM編譯后和"abcd"一樣
String str1 = "ab" + "cd"; //1個對象
String str11 = "abcd";
System.out.println("str1 = str11 : "+ (str1 == str11));
2.2.2 Java是怎樣做到String的不可變的
在String源碼中 ，使用private final char value[]來實現字符串的存儲,就是因為final,才說String類型是不可變
/** The value is used for character storage. */
private final char value[];
2.3 String的保存位置
深入一點，我們了解一下String保存的位置（可以參考java+內存分配及變量存儲位置的區別[轉]，java中的String類常量池詳解）
String常量是保存在常量池中。JVM中的常量池在內存當中是以表的形式存在的， 對於String類型，有一張固定長度的CONSTANT_String_info表用來存儲文字字符串值，注意：該表只存儲文字字符串值，不存儲符號引用。說到這里，對常量池中的字符串值的存儲位置應該有一個比較明了的理解了。在程序執行的時候,常量池會儲存在Method Area,而不是堆中。常量池中保存着很多String對象; 並且可以被共享使用，因此它提高了效率
什么是常量池
常量池指的是在編譯期被確定，並被保存在已編譯的.class文件中的一些數據。
除了包含代碼中所定義的各種基本類型（如int、long等等）和對象型（如String及數組）的常量值(final)還包含一些以文本形式出現的符號引用。
2.4主要的方法
- s.length() 返回s字符串長度
- s.charAt(2) 返回s字符串中下標為2的字符
- s.substring(0, 4) 返回s字符串中下標0到4的子字符串
- s.indexOf("Hello") 返回子字符串"Hello"的下標
- s.startsWith(" ") 判斷s是否以空格開始
- s.endsWith("oo") 判斷s是否以"oo"結束
- s.equals("Good World!") 判斷s是否等於"Good World!" ==只能判斷字符串是否保存在同一位置。需要使用equals()判斷字符串的內容是否相同。
- s.compareTo("Hello Nerd!") 比較s字符串與"Hello Nerd!"在詞典中的順序， 返回一個整數，如果<0，說明s在"Hello Nerd!"之前 如果>0，說明s在"Hello Nerd!"之后 如果==0，說明s與"Hello Nerd!"相等。
- s.trim() 去掉s前后的空格字符串，並返回新的字符串
- s.toUpperCase() 將s轉換為大寫字母，並返回新的字符串
- s.toLowerCase() 將s轉換為小寫，並返回新的字符串
- s.replace("World", "Universe") 將"World"替換為"Universe"，並返回新的字符串
2.5:簡單概括總結String中的細節點
總體來說，如果你還是對String感到困惑，不如把握住一點就是“ 創建時間” 如果編譯期就知道是啥，會丟到常量池.
-
單獨使用""引號創建的字符串都是常量,編譯期就已經確定存儲到String Pool中；
-
使用new String("")創建的對象會存儲到heap中,是運行期新創建的；
-
使用只包含常量的字符串連接符如"aa" + "aa"創建的也是常量,編譯期就能確定,已經確定存儲到String Pool中；
-
使用包含變量的字符串連接符如"aa" + s1創建的對象是運行期才創建的,存儲在heap中；
-
intern()： String實例調用該方法可以讓JVM檢查常量池，如果沒有實例的value屬性對應的字符串序列，就將本實例放入常量池，如果有則返回常量池中相對應的實例的引用而不是當前實例的引用
2.6 StringBuilder 和StringBuffer 和 +
首先StringBuilder 和StringBuffer區別是 StringBuffer線程安全（存在一堆synchronized）
其次，我們推薦用StringBuilder 而不是+ ,雖然+號在jvm中本質也是建StringBuilder,但是每s = s+"1";都會引入一個StringBuilder對象
String [] aaa = {"1","2","3"};
for (String s : aaa) { s+="1";//每循環一次，都會產生一個StringBuilder對象 }
另外：StringBuilder允許我們在聲明的時候指定大小，避免我們多次分配緩存
三：Java引用類型
Java有 5種引用類型（對象類型）：類 接口 數組 枚舉 標注。
new 的對象會放到java堆中，然后把引用放到棧內，這里不多加敘述