寫在前面
??你們好，我是小莊，很高興能和你們一起學習Java，如果您對Java感興趣的話可關注我的動態.
??寫博文是一種習慣，在這程序中能夠梳理和鞏固知識，

我們開始吧！

一、陣列

在Java基礎知識篇我們已經簡單的了解陣列
陣列是Java里面最基礎的資料結構，陣列是一個存放多個資料的容器

1、陣列的特點有哪些呢？

• 資料是同一型別的，比如都是int型別；
• 資料是線性排序的，可通過索引進行訪問資料，如: a[1]；
• 資料的長度(空間)一旦定義，則不能改變

陣列分為一維陣列和多維陣列，實際上，多維陣列是陣列的陣列，存盤的方式是一行一行存盤，線性存盤，

2、陣列的定義和初始化：

int[] a;//只是宣告，并沒有初始化，也可以這樣宣告 int a[];
int[] b=new int[2];//宣告陣列并初始化一個可以存盤2個整數的陣列
b[0]=3;b[1]=5;//初始化陣列的值
int[] c=new int[]{1,2,3};//宣告的同時初始化，長度為3，值為1，2，3

陣列的索引是從0開始的，操作陣列時要注意陣列越界的問題，

int[] a=new int[3];//宣告并初始化了陣列長度為3的陣列
a[0]=1;//給陣列第一個元素（索引為0）賦值
a[2]=10;//給陣列第三個元素(索引為2)賦值
a[3]=6;//錯誤，陣列越界，陣列長度為3，但最后的元素為a[3-1]

3、操作陣列

//給陣列賦值
//宣告并初始化10個長度的整型陣列
int[] a=new int[10];
//定義輸入
Scanner in=new Scanner(System.in);
//a.length表示獲取陣列的長度，注意：獲取字串長度使用的是length(),多了()
for(int i=0;i<a.length;i++){//進行遍歷陣列逐個賦值
    a[i]=in.nextInt();
}
//獲取陣列中第i位數,陣列索引從0開始
int b=a[2];//此時b的值可以獲取索引為2的整數

//for each遍歷陣列方式
for(int element:a){//a表示陣列的變數，element表示陣列的元素
    System.out.println(element);//對陣列的元素逐個輸出
}

4、多維陣列

這里我們用二維陣列進行講解，理解了二維陣列之后多維陣列自然理解了，

二維陣列和我們上面講的一維陣列的定義有些不一樣，二維陣列必須在定義的同時設定好存放的空間（長度）

int a[ ][ ]=new int [ i ][ j ]; i表示行數，j表示列數
注意：
int a[ ][ ]=new int[ ][ ]; 這樣定義是錯誤的；必須設定好長度
int a[ ][ ]=new int[ ][3];這樣定義也是錯誤的，行數必須定義
int[ ][ ] b=new int[2][2]{{0,1},{1,2}}；這樣定義也是錯誤的
int a[ ][ ]=new int[2][ ];這樣定義是正確的 ,列數可以不被定義
陣列越界問題

5、多維陣列的定義和初始化

//定義了一個兩行的陣列，具體多少列還不清楚
int[][] a = new int[2][];
//定義了一個兩行三列的陣列
int[][] c = new int[2][3];
//定義的同時初始化，下面是兩行三列的二維陣列
int[][] b = new int[][]{{1,2}, {2, 3}, {4, 5}};

6、操作多維陣列

//定義了一個兩行三列的陣列
int[][] a = new int[2][3];
//定義輸入
Scanner in=new Scanner(System.in);
//通過for嵌套回圈進行賦值二維陣列，先遍歷某一行，然后遍歷這一行中的列對應的值
for(int i=0;i<2;i++){//索引從0開始，這里i=0
	for(int j=0;j<3;j++){//索引從0開始，這里j=0
		//給二維陣列賦值
		a[i][j]=in.nextInt();
	}
}
//通過for each遍歷二維陣列
for(int[] i:a){
	for(int j:i){
	  System.out.println(j);
	}
}
//通過for回圈遍歷二維陣列
for(int i=0;i<2;i++){//索引從0開始，這里i=0
	for(int j=0;j<3;j++){//索引從0開始，這里j=0
		//列印結果
		System.out.println(a[i][j]);
	}
}

二、List串列

1、List的介紹:

List的特點

• 允許重復資料
• 資料型別一致
• 有序的，底層實作Collection介面

List的實作

• ArrayList（非同步，讀取速度快，陣列方式存盤）
• LinkedList（非同步的，讀取速度一般，洗掉插入速度快，鏈表方式存盤）
• Vector（同步的，讀取速度慢）

2、ArrayList

import java.util.ArrayList;
public class  ArrayListTest{
	public static void main(String[] args){
		//宣告ArrayList串列，型別為Integer物件,int的包裝類
		ArrayList<Integer> a=new ArrayList<>();
		//往串列添加元素
		a.add(2);
		a.add(0,3);
		//獲取串列中的第一個元素
		System.out.println(a.get(0));
		//獲取串列元素數
		System.out.println(a.size());
		//判斷串列是否為空,此時為false
		System.out.println(a.isEmpty());		
		//判斷串列是否包含指定的元素
		System.out.println(a.contains(3));
		//串列的遍歷
		for(int i=0;i<a.size();i++){
			System.out.println(a.get(i));
		}
		//洗掉下標為0的元素
		a.remove(0);
		//清空串列
		a.clear();	
	}
}

3、LinkedList

ArrayList的方法LinkedList同樣都有，但是，LinkedList有自己特殊的方法，
因為LinkedList是鏈表存盤的，所以提供了鏈表相關的方法：

其他方法和ArrayList一樣操作，我就不重復寫了

import java.util.LinkedList;

public class  LinkedListTest{
	public static void main(String[] args){
		//宣告LinkedList
		LinkedList<Integer> a=new LinkedList<>();
		a.push(2);
		a.push(3);
		//通過toString()方法查看存盤情況
		System.out.println(a.toString());
		a.pop();
		//通過toString()方法查看存盤情況
		System.out.println(a.toString());
		//往尾部添加,add()方法一樣
		a.addLast(4);
		a.add(5);
		//通過toString()方法查看存盤情況
		System.out.println(a.toString());
		//往頭部添加
		a.addFirst(1);
		//通過toString()方法查看存盤情況
		System.out.println(a.toString());
	}
}

運行結果：

[3, 2]
[2]
[2, 4, 5]
[1, 2, 4, 5]

Vector的用法和ArrayList幾乎是一樣的，都是陣列存盤，主要的區別是Vector是同步的，這里就不對Vector講解了

如果想讓ArrayList同步，可這樣實作:使用Collections.synchronizedList()方法進行封裝

ArrayList<Integer> a=(ArrayList<Integer>) Collections.synchronizedList(new ArrayList>());

小結：
??1、ArrayList是不同步的，適合做大量的查詢，效率高
??2、LinkedList是不同步的，適合做大量的插入和洗掉操作，效率高
??3、Vector是同步的
??4、想要實作同步，可以用Collections.synchronizedList()方法進行封裝

四、Set集合

1、Set的介紹

集合的特點

• 不允許重復資料
• 資料型別一致
• 不同步的，想要同步必須使用Collections.synchronizedList()方法進行封裝

Set的實作

• HashSet 使用散列存盤，無序的
• LinkedHashSet 使用散列存盤和樹形結構存盤的結合，有序的
• TreeSet 使用樹形結構存盤，有序的

2、HashSet

不同步，可以容納null元素

import java.util.HashSet;
public class  HashSetTest{
	public static void main(String[] args){
		//宣告HashSet
		HashSet<Integer> h=new HashSet<>();
		//往串列添加元素
		h.add(null);
		h.add(2);
		h.add(3);
		h.add(40000);
		h.add(3);//重復，不添加
		h.add(6);	
		//遍歷結果
		for(Integer item:h) {
			System.out.println(item);
		}
		System.out.println("----遍歷結束-----");
		//獲取串列元素數
		System.out.println(h.size());
		//判斷串列是否為空,此時為false
		System.out.println(h.isEmpty());		
		//判斷串列是否包含指定的元素
		System.out.println(h.contains(3));
		
		//這里定義另一個集合，并添加元素
		HashSet<Integer> h2=new HashSet<>();
		h2.add(1);
		h2.add(3);
		//計算兩個集合的交集
		h.retainAll(h2);
		System.out.println("它們的交集是："+h);
		//洗掉指定元素
		h.remove(3);
		//清空串列
		h.clear();
	}
}

運行結果：

null
40000
2
3
6
----遍歷結束-----
5
false
true
它們的交集是：[3]

LinkedHashSet 繼承HashSet，但是有序的，add()方法添加后遍歷是有序的，因為LinkedHashSet上面所有的方法都是HashSet繼承的，并且沒有重寫，所以這里不對LinkedHash進行介紹，

3、TreeSet

基于TreeMap實作，不可以容納null元素，
根據compareTo()方法指定Comparator排序

import java.util.TreeSet;
public class  TreeTest{
	public static void main(String[] args){
		//宣告TreeSet
		TreeSet<Integer> t=new TreeSet<>();
		//往串列添加元素
		//t.add(null);錯誤
		t.add(2);
		t.add(3);
		t.add(40000);
		t.add(3);//重復，不添加
		t.add(6);	
		//遍歷結果
		for(Integer item:t) {
			System.out.println(item);
		}
		System.out.println("----遍歷結束-----");
		//獲取串列元素數
		System.out.println(t.size());
		//判斷串列是否為空,此時為false
		System.out.println(t.isEmpty());		
		//判斷串列是否包含指定的元素
		System.out.println(t.contains(3));
		//洗掉指定元素
		t.remove(3);
		//清空串列
		t.clear();
	}
}

運行結果：

2
3
6
40000
----遍歷結束-----
4
false
true

從中我們發現：TreeSet遍歷是從小到大的，有序的

4、在物件中使用Set

我們知道，Set集合是不重復的，那么，如果我們在一個物件中使用它時該怎么使用呢？

第一、使用HashSet和LinkedSet時，必須在類中重寫Object類的equals()、hashCode()和toString()方法，否則無法判斷是否重復
第二、使用TreeSet時，必須實作Comparable介面，即實作compareTo()方法

例一：新建一個Cat.java類，使用HashSet（LinkedSet）存盤Cat物件

public class Cat{
	private int size;
	//有參構造
	public Cat(int s) {	
		this.size=s;
	}
	//獲取size
	public int getSize() {
		return size;
	}
	//重寫Ojbect類的equals方法
	public boolean equals(Object o) {
		System.out.println("equals正在被呼叫");
		if(0==size-((Cat) o).getSize()) {
			return true;
		}else {
			return false;
		}
	}
	//重寫Object類的hashCode方法
	public int hashCode() {
		System.out.println("hashCode正在被呼叫");
		return size;
	}
	public String toString() {
		System.out.println("toString正在呼叫");
		return size+"";
	}
}

例二：新建Dog.java類，使用TreeSet存盤物件

public class Dog implements Comparable{
	private int size;
	//有參構造
	public Dog(int s) {	
		this.size=s;
	}
	//獲取size
	public int getSize() {
		return size;
	}
	@Override
	public int compareTo(Object o) {
		//若物件的值和傳進來的值相等，則回傳0
		return size-((Dog)o).getSize();
	}
}

最后我們進行測驗

import java.util.HashSet;
import java.util.TreeSet;
public class Test{
	public static void main(String[] args){
		//宣告HashSet
		HashSet<Cat> hc=new HashSet<>();
		//宣告TreeSet
		TreeSet<Dog> td=new TreeSet<>();
		//往串列添加元素
		hc.add(new Cat(1));
		hc.add(new Cat(2));
		hc.add(new Cat(2));
		System.out.println(hc.size());
		System.out.println("----HashSet使用結束----");
		
		td.add(new Dog(1));
		td.add(new Dog(2));
		td.add(new Dog(2));
		System.out.println(td.size());
		System.out.println("----TreeSet使用結束----");
	}
}

五、Map映射

1、Map的介紹

數學中使用的映射關系是定義域和值域,Map就是以鍵值對方式存盤
一個鍵對應一個值（key:value）
Map的特點

• 以鍵值對的方式進行存盤

Map的實作

• HashMap 不同步，速度快，資料量大
• Hashtable 同步，速度慢，資料量小
• Properties 同步，檔案格式，資料量小

2、HashMap

最多允許一條記錄的鍵為null，并允許null的值，不支持執行緒同步,訪問速度快，

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

public class  MathTest{
	public static void main(String[] args){
		//宣告HashMap并設定鍵值對型別均為String字串型
		HashMap<String,String> map=new HashMap<>();
		//添加鍵值對
		map.put("name", "張三");
		map.put("height","170cm" );
		//當鍵相同，后面的值會覆寫前面的
		map.put("height", "180cm");
		//根據鍵獲取值
		String result=map.get("height");
		//列印結果
		System.out.println(result);
		//根據鍵替換值
		map.replace("name", "李四");
		//查看結果
		System.out.println(map.get("name"));
		//獲取鍵值對個數,map.size()
		System.out.println("元素個數為："+map.size());
		//判斷鍵值對是否為空,map.isEmpty()
		System.out.println(map.isEmpty());
		//獲取所有值
		System.out.println(map.values());
		
		//定義一個key和value,后面用
		String key;
		String value;
		System.out.println("-----使用EntrySet迭代器遍歷-----");
		Iterator<Entry<String,String>> et=map.entrySet().iterator();
		while(et.hasNext()) {
			//System.out.println(et.next());輸出格式：key=value
			Map.Entry<String, String> ite=et.next();
			key=ite.getKey();
			value=ite.getValue();
			//列印結果
			System.out.println("鍵:"+key+" 值:"+value);
		}
		System.out.println("-----使用EntrySet迭代器遍歷結束-----");
		System.out.println();
		
		System.out.println("-----使用keySet迭代器遍歷-----");
		
		Iterator<String> it=map.keySet().iterator();
		while(it.hasNext()) {
			key=it.next();
			value=map.get(key);
			//列印結果
			System.out.println("鍵:"+key+" 值:"+value);
			
		}
		System.out.println("-----使用keySet迭代器遍歷結束-----");
		//根據鍵進行洗掉元素
		map.remove("height");
		//獲取鍵值對個數
		System.out.println("元素個數為："+map.size());
		//清空
		map.clear();
		//獲取鍵值對個數
		System.out.println("元素個數為："+map.size());
	}
}

列印結果：

180cm
李四
元素個數為：2
false
[李四, 180cm]
-----使用EntrySet迭代器遍歷-----
name=李四
height=180cm
-----使用EntrySet迭代器遍歷結束-----

-----使用keySet迭代器遍歷-----
鍵:name 值:李四
鍵:height 值:180cm
-----使用keySet迭代器遍歷結束-----
元素個數為：1
元素個數為：0

簡單介紹
LinkedHashMap ：維持插入順序的HashMap（遍歷順序和插入順序保持一致）
TreeHashMap: 自然數的方式排序，比如數字是從小到大排序

這兩個Map和HashMap的關系類似于HashSet和LinkedHashSet、HashSet和TreeSet的關系

3、Hashtable

• 無序的
• 適合資料量小的資料
• 同步
• key和value都不支持null元素

這里的用法和HashMap一樣，代碼大部分重復，只需要改定義

Hashtable<String,String> map=new Hashtable<>();

改完之后運行結果：

180cm
李四
元素個數為：2
false
[180cm, 李四]
-----使用EntrySet迭代器遍歷-----
鍵:height 值:180cm
鍵:name 值:李四
-----使用EntrySet迭代器遍歷結束-----

-----使用keySet迭代器遍歷-----
鍵:height 值:180cm
鍵:name 值:李四
-----使用keySet迭代器遍歷結束-----
元素個數為：1
元素個數為：0

從中可以說明Hashtable是無序的

4、Properties

• 繼承Hashtable類
• 可以將k-v對保存到檔案中
• 適合資料少的組態檔，比如資料庫的配置
• 除了繼承Hashtable的方法外，有自己的方法

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.Properties;

public class  PropertiesTest{
	public static void main(String[] args) throws IOException{
		//寫入Properties操作
		WriteProperties("Test.properties","name","張三");
		WriteProperties("Test.properties","height","180cm");
		System.out.println("---GetAllProperties---");
		//讀取Properties全部資訊
		GetAllProperties("Test.properties");
		根據key讀取value
		String key="name";
		System.out.println();
		System.out.println("---GetValueByKey---");
		String value=GetValueByKey("Test.properties",key);
		System.out.println("根據"+key+"獲取的值為："+value);
	}
	//寫入Properties資訊
	public static void WriteProperties(String filePath,String pKey,String pValue) throws IOException {
		File file=new File(filePath);
		//檔案不存在
		if(!file.exists()) {
			//新建檔案
			file.createNewFile();
		}
		Properties p=new Properties();
		OutputStream out=new FileOutputStream(filePath);
		//設定鍵值對
		p.setProperty(pKey, pValue);
		//將此屬性串列（鍵和元素對）寫入此 Properties表中
		p.store(out, pValue);
		//關閉流
		out.close();
	}
	//讀取Properties全部資訊
	public static void GetAllProperties(String filePath) throws IOException {		
		Properties p=new Properties();
		InputStream in=new BufferedInputStream(new FileInputStream(filePath));
		//加載所有的鍵值對
		p.load(in);
		//獲取組態檔的名字
		Enumeration e=p.propertyNames();
		//迭代遍歷
		while(e.hasMoreElements()) {
		//獲取鍵
		String key=	(String)e.nextElement();
		//根據鍵獲取值
		String value=p.getProperty(key);
		System.out.println("key:"+key+" value:"+value);
		}
	}
	//根據key讀取value
	public static String GetValueByKey(String filePath,String key){
	InputStream in=null;
		try {
			Properties p=new Properties();
			in=new BufferedInputStream(new FileInputStream(filePath));
			//加載所有的鍵值對
			p.load(in);
			//根據傳進來的key獲取值
			String value=p.getProperty(key);
			//回傳值
			return value;
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return null;
		}finally{
			try {
				in.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}	
	}
}

溫馨提示：這里涉及到檔案讀寫操作，如不了解，請看下一篇文章
運行結果：

---GetAllProperties---
key:height value:180cm
key:name value:張三

---GetValueByKey---
根據name獲取的值為：張三

六、工具類

• Arrays類
• Collections類

不存盤資料，但是提供一些方法，提高我們的作業效率

1、Arrays

import java.util.Arrays;
import java.util.Random;

public class  ArraysTest{
	public static void main(String[] args){
		//new一個隨機函式
		Random r=new Random();
		//創建一個長度為5的陣列
		int[] a=new int[5];
		for(int i=0;i<a.length;i++) {
			//給陣列設定亂數
			a[i]=r.nextInt();
		}
		//使用工具類Arrays排序
		Arrays.sort(a);
		//重新給一個數指定一個值，然后查找
		a[3]=666;
		//使用二分查找進行查值
		int result=Arrays.binarySearch(a, 666);
		System.out.println("666的位置是："+result);
		
		//把陣列a的值拷貝給陣列b,只拷貝前三個
		int[] b=Arrays.copyOf(a, 3);
		
		//給陣列a批量賦值,全部賦值為66
		Arrays.fill(a, 66);
		//從第1個元素到第3個元素進行批量賦值為1 
		Arrays.fill(a,0,3,1);//[0,3)
		for(int item:a) {
			System.out.println(item);
		}
		System.out.println(a.equals(b));
	}
}

運行結果：

666的位置是：3
1
1
1
66
66
false

2、Collections

Collection處理的物件是Collection和它的子類

import java.util.ArrayList;
import java.util.Collections;

public class  CollectionsTest{
	public static void main(String[] args){
		//定義一個陣列串列
		ArrayList<Integer> list=new ArrayList<>();
		//存盤資料
		list.add(1);
		list.add(12);
		list.add(3);
		list.add(20);
		//排序
		Collections.sort(list);
		for(int item:list) {
			System.out.println(item);
		}
		//二分查找
		int result=Collections.binarySearch(list, 3);
		//列印結果
		System.out.println("3在串列中的位置為："+result);
		//獲取最大值
		int max=Collections.max(list);
		System.out.println("最大值為："+max);
		//獲取最小值
		int min=Collections.min(list);
		System.out.println("最小值為："+min);
		//批量操作,全部賦值666
		Collections.fill(list, 666);
		System.out.println("--批量操作后結果--");
		for(int item:list) {
			System.out.println(item);
		}
	}
}

運行結果：

1
3
12
20
1
最大值為：20
最小值為：1
--批量操作后結果--
666
666
666
666

本篇內容結束，謝謝閱讀

上一篇：Java常用類別庫

下一篇：正在更新中…