JAVA內置數據結構概述

1. 內存單位的轉換
2. JAVA基本數據類型和轉換
3. 串，數組，集合
4. 包裝類

---

一、內存單位的轉換

8bit(位)=1Byte(字節)
1024Byte(字節)=1KB
1024KB=1MB
1024MB=1GB
1024GB=1TB

---

二、JAVA基本數據類型和轉換

分類：
Java基本數據類型就8種，其他都是引用型的。
Java四類八種基本數據類型：
第一類：整型 byte short int long
第二類：浮點型 float double
第三類：邏輯型 boolean(它只有兩個值可取true false)
第四類：字符型 char

存儲位置：
在棧中可以直接分配內存的數據是基本數據類型。
引用數據類型：是數據的引用在棧中，但是他的對象在堆中。

字節：
boolean 布爾型 1/8
byte 字節類型 1
char 字符型 2 一個字符能存儲一箇中文漢字
short 短整型 2
int 整數類型 4
float 浮點類型（單精度） 4
long 長整形 8
double 雙精度類型（雙精度） 8

默認：
Java中默認的整數類型是int類型，如果要定義爲float型，則要在數值後加上l或L；
默認的浮點型也是雙精度浮點，如果要定義爲float型，則要在數值後加上f或F。

轉換
基本數據類型自動轉換
byte->short,char -> int -> long
float -> double
int -> float
long -> double
記住：小可轉大，大轉小會失去精度！

---

補充數據類型BigDecimal：

BigDecimal aDouble =new BigDecimal(1.22);
System.out.println("construct with a double value: " + aDouble);
BigDecimal aString = new BigDecimal("1.22");
System.out.println("construct with a String value: " + aString);

你認爲輸出結果會是什麼呢？如果你沒有認爲第一個會輸出1.22，那麼恭喜你答對了，輸出結果如下：
construct with a doublevalue:
1.2199999999999999733546474089962430298328399658203125
construct with a String value: 1.22

BigDecimal a =new BigDecimal("1.22");
System.out.println("construct with a String value: " + a);
BigDecimal b =new BigDecimal("2.22");
a.add(b);
System.out.println("aplus b is : " + a);

我們很容易會認爲會輸出：
construct with a Stringvalue: 1.22
a plus b is :3.44
但實際上a plus b is : 1.22

---

三、串、數組、集合

串的操作：
Character 是進行單個字符操作
String 字符串常量（不可變，操作後生成新的對象）
StringBuffer 動態字符串變量（線程安全）
StringBuilder 動態字符串變量（非線程安全）
[注]
String常用的方法有：+, charAt, length, subString
String 轉換成StringB類可以用,appead, insert, 反之用toString方法
常用正則表達式匹配：

Pattern p = Pattern.compile("[A-z][0-9]+");
Matcher m = p.matcher(s);
ArrayList<String> al = new ArrayList<String>();
while (m.find()) {
    al.add(m.group());
}

數組的操作：
Java數組自身的操作是很少的，需要導入其他的操作包或者類
定義

String[] aArray = new String[5];
String[] bArray = {"a","b","c", "d", "e"};
String[] cArray = new String[]{"a","b","c","d","e"};

排序和打印

int[] a = { 1, 2, 3, 4 };
Arrays.sort(a);
System.out.println(Arrays.toString(a));

數組變成動態數組

String[] stringArray = { "a", "b", "c", "d", "e" };
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
System.out.println(arrayList);
// [a, b, c, d, e]

檢查數組是否包含

String[] stringArray = { "a", "b", "c", "d", "e" };
boolean b = Arrays.asList(stringArray).contains("a");
System.out.println(b);
// true

連接2個數組

int[] intArray = { 1, 2, 3, 4, 5 };
int[] intArray2 = { 6, 7, 8, 9, 10 };
// Apache Commons Lang library
int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);

數組變成字符輸出

String j = StringUtils.join(new String[] { "a", "b", "c" }, ", ");
System.out.println(j);
// a, b, c

數組轉化成集合

Set<String> set = new HashSet<String>(Arrays.asList(stringArray));
System.out.println(set);
//[d, e, b, c, a]

數組的翻轉

int[] intArray = { 1, 2, 3, 4, 5 };
ArrayUtils.reverse(intArray);
System.out.println(Arrays.toString(intArray));
//[5, 4, 3, 2, 1]

數組元素的刪除

int[] intArray = { 1, 2, 3, 4, 5 };
int[] removed = ArrayUtils.removeElement(intArray, 3);//create a new array
System.out.println(Arrays.toString(removed));

---

集合操作：

常用的集合框架類：
Collection：集合（一般不直接用）
List ：可重複，有序
Set：不重複，無序
Map：鍵值對

ArrayList：效率高
Vector ：效率低
Stack ：後進先出

HashSet：不重複
LinkedHashSet：不重複，鏈表
TreeSet：不重複，有序

HashMap ：無序
TreeMap ：有序
HashTable：有序

集合框架的操作：
熟練的在串，數組，集合之間的轉換是很有必要的。

集合中逆序的使用：

// 自己是迴文則返回，自己不是迴文則補全迴文
public static String getHuiWen(String str) {
    if (isHuiWen(str) == true)
        return str;
    else {
        String goal = "";
        String LeftMax = getMaxSubStringFromLeft(str);
        String strSub = str.substring(LeftMax.length(), str.length());
        String sb = new StringBuilder().append(strSub).reverse().toString();
        goal = sb + str;
        return goal;
    }
}

集合迭代器的使用：

 list l = new ArrayList();
 l.add("aa");
 l.add("bb");
 l.add("cc");
 for (Iterator iter = l.iterator(); iter.hasNext();) {
  String str = (String)iter.next();
  System.out.println(str);
 }
 /*迭代器用於while循環
 Iterator iter = l.iterator();
 while(iter.hasNext()){
  String str = (String) iter.next();
  System.out.println(str);
 }
 */

---

四、包裝類
包裝類的主要：
Java是面向對象的，但是基本數據類型不是對象，做成對象後才能傳遞到某一些方法裏。

包裝類（Integer、Long、Byte、Double、Float、Short）都是抽象類Number的子類，所有的包裝類如下：
byte
Byte
boolean
Boolean
short
Short
char
Character
int
Integer
long
Long
float
Float
double
Double

和基本數據類型一樣使用：

Integer a = 10;
a = a + 10;
System.out.println(a);

基本類型和包裝類轉換

int n = 10;
Integer in = new Integer(100);
Integer in1 = new Integer(n);
int m = in.intValue();

數字字符串變成數字

String s = “123”;
int n = Integer.parseInt(s);

給定進制的轉換

//將字符串”120”按照十進制轉換爲int，則結果爲120
int n = Integer.parseInt(“120”,10);
//將字符串”12”按照十六進制轉換爲int，則結果爲18
int n = Integer.parseInt(“12”,16);
//將字符串”ff”按照十六進制轉換爲int，則結果爲255
int n = Integer.parseInt(“ff”,16);

數字轉化成數字字符

int m = 1000;
String s = Integer.toString(m);
//或者
String s = m + "";