Java學習筆記16（集合！HashSet, ArrayList, HashMap）

文章目錄

• 集合概述（容器類）
• List與ArrayList
• • 特點
  • list具體方法
  • • 添加元素list.add方法
    • 索引
    • list.addAll(index,value)
    • 查找資料list.indexOf(),list.lastindexOf()
    • 移除資料list.remove(index）
    • 改值list.set(index,value)
    • 切片list.subList（a,b）
    • 清單長度list.size()
    • 結論：
• Set,HashSet
• • 周遊集合元素的方法
• Map
• • 特點
  • Map接口與HashMap類
  • TreeMap

集合概述（容器類）

Java集合類存放于 java.util 包中

Java 集合可分為 Set、List 和 Map 三種大體系

Set：無序、不可重複的集合

List：有序，可重複的集合

Map：具有映射關系的集合

接口：Set，List，Map不是直接使用的，而是通過他們的實作類！

個人感覺：

對應python裡面的集合，清單，字典

List與ArrayList

ArrayList是可執行個體化的

特點

清單（和python裡清單一樣，但是這裡把清單屬于集合！）

List 代表一個元素有序、且可重複的集合，集合中的每個元素都有其對應的順序索引

List 允許使用重複元素，可以通過索引來通路指定位置的集合元素。

List 預設按元素的添加順序設定元素的索引。

List 集合裡添加了一些根據索引來操作集合元素的方法

list具體方法

添加元素list.add方法

看代碼學習！

import java.util.List;
import java.util.ArrayList;

public class Test5 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("v");
		list.add("v2");
		list.add("v");//清單可重複
		list.add("b");
		list.add("a");
		System.out.println(list);
	
	}

}
           

備注：

很方法，會自動提示import

import java.awt.List;（不是這個，why?先留着這個問題）

import java.util.List;

import java.util.ArrayList;

索引

list.get(index)

list.add(index,“value”);

public class Test5 {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		list.add("v");
		list.add("v2");
		list.add("v");//清單可重複
		list.add("b");
		list.add("a");
		System.out.println(list);
		System.out.println(list.get(3));//索引第四個元素，因為從0開始，下标
		
		list.add(0,"a");
		System.out.println(list);//結果為[a, v, v2, v, b, a]

	}

}
           

list.addAll(index,value)

List<String> list1 = new ArrayList<String>();
		list1.add("acdf");
		list1.add("9989");
		
		list.addAll(0,list1);
		System.out.println(list);//[acdf, 9989, a, v, v2, v, b, a]
           

查找資料list.indexOf(),list.lastindexOf()

第一個出現元素 的下标和最後一個出現元素的下标。

移除資料list.remove(index）

根據索引remove

改值list.set(index,value)

根據索引set

切片list.subList（a,b）

根據索引a,b 切一段，左開右閉。

List<String> list2 = list.subList(2,5);
		System.out.println(list2);//[a, v, v2]
           

清單長度list.size()

結論：

Vector是一個古老的集合，通常建議使用 ArrayList

ArrayList 是線程不安全的，而 Vector 是線程安全的。

即使為保證 List 集合線程安全，也不推薦使用 Vector

Set,HashSet

我們說的集合，都是HashSet

周遊集合元素的方法

Iterator 接口主要用于周遊 Collection 集合中的元素，Iterator 對象也被稱為疊代器

Java 5 提供了 foreach 循環疊代通路 Collection

方法在代碼裡。

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

public class Test3 {
	public static void main(String[] args) {
//		Set set = new HashSet();
		//<Object>就是任何類型的都行
		Set<Object> set = new HashSet<Object>();//與上面的等價
		set.add(1);//添加元素
		set.add("a");
//		
		System.out.println(set);
//		
//		set.remove(1);//移除元素
//		
//		System.out.println(set);
//		
//		System.out.println(set.contains(1));//判斷是否包含元素
//		
//		set.clear();//清空集合
//		
//		System.out.println(set);
		
		set.add("a");
		set.add("b");
		set.add("c");
		set.add("d");
		
//		set.add("d");//set集合是存的值是不重複
		set.add(1);
		set.add(true);
		set.add(null);
		
		System.out.println(set);
		//使用疊代器周遊集合
		Iterator it = set.iterator();
		
		while(it.hasNext()){
			System.out.println(it.next());
		}
		
		//for each疊代集合,推薦使用這種
		for(Object obj : set){
			//這個的意思是把set的每一個值取出來，指派給obj，直到循環set的所有值
			System.out.println(obj);
		}
		
		System.out.println(set.size());//擷取集合的元素個數
		
		//如果想要讓集合隻能存同樣類型的對象，怎麼做
		//使用泛型<type>
		Set<String> set1 = new HashSet<String>();//比如指定String為集合的泛型，那麼這個集合不能存String類型之外的資料
		
		set1.add("sbc");
//		set1.add(1);//不行了，隻能字元串類型了
	}
}
           

集合是無序的！！！

為了有序咋辦？

TreeSet是自然排序，從小到大。預設情況下，TreeSet 采用自然排序。

import java.util.Set;
import java.util.TreeSet;//為了有序集合
public class Test4 {
	public static void main(String[] args) {
		Set<Integer> set = new TreeSet<Integer>();		
		set.add(3);
		set.add(5);
		set.add(7);
		set.add(9);
		System.out.println(set);
		
	}

}

           

周遊集合set，強制for循環

//周遊集合set
		for(Integer i : set) {
			System.out.println(i);
		}
           

如果不是數字怎麼排序？

如果需要實作定制排序，則需要在建立 TreeSet 集合對象時，提供一個 Comparator 接口的實作類對象。由該 Comparator 對象負責集合元素的排序邏輯

import java.util.Comparator;//為了定制排序
import java.util.Set;
import java.util.TreeSet;//為了有序集合
public class Test4 {
	//step4
	public static void main(String[] args) {
		Person p1 = new Person(18,"Tom");//因為有參構造，這裡可以直接寫參數。
		Person p2 = new Person(18,"Tom1");
		Person p3 = new Person(14,"Tom3");
		Person p4 = new Person(16,"Tom4");
		Person p5 = new Person(10,"Tom5");
		
		//step5
		//然後建立set，去排序
		Set <Person> set = new TreeSet<Person>(new Person());//指明泛型為Person
		set.add(p1);
		set.add(p2);
		set.add(p3);
		set.add(p4);
		set.add(p5);
		
		//step6
		//**強制for循環**
		for(Person p:set) {
			System.out.println(p.name +  ""+ p.age);
		}
		
	}
	
}

/**
 * 定制排序
 * @author jkjkjk
 *
 */
class Person implements Comparator<Person>{
	
	//step3
	public Person() {
		
	}
	
	//有參構造
	public Person(int age, String name) {
		this.age = age;
		this.name = name;
	}//然後再去new Person類
	
	//step1
	int age;
	String name;
	//step2
	@Override
	public int compare(Person o1, Person o2) {
		// TODO Auto-generated method stub
		if(o1.age > o2.age) {
			return 1;
			
		}else if(o1.age < o2.age){
			return -1;
		}else {
			return 0;
		}
		//再去寫構造
		
	}
	
	
}
           

Map

特點

Map 用于儲存具有映射關系的資料，是以 Map 集合裡儲存着兩組值，一組值用于儲存 Map 裡的 Key，另外一組用于儲存 Map 裡的 Value

Map 中的 key 和 value 都可以是任何引用類型的資料

Map 中的 Key 不允許重複，即同一個 Map 對象的任何兩個 Key 通過 equals 方法比較中傳回 false

**Key 和 Value 之間存在單向一對一關系，即通過指定的 Key 總能找到唯一的，**确定的 Value。

Map接口與HashMap類

看代碼學習！

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


public class Test6 {
	public static void main(String[] args) {
		//new HashMap這個類，指派給map,指明泛型，是一對的
		Map<String, Integer> map = new HashMap<String, Integer>();
		
		map.put("b", 1);//添加資料
		map.put("c", 2);
		map.put("e", 2);
		System.out.println(map);//{b=1, c=2, e=2}
		
		System.out.println(map.get("b"));//根據key取值
		
		map.remove("c");//根據key移除鍵值對
		System.out.println(map);//{b=1, e=2}
		
		System.out.println(map.containsKey("a"));//判斷目前的map集合是否包含指定的key
//		
		System.out.println(map.containsValue(10));//判斷目前的map集合是否包含指定的value
//		
	map.clear();//清空集合
           

周遊map,注意！

第一種方法，周遊key,

Set<String> keys = map.keySet();//import java.util.Set;
		
		for(String key:keys) {
			System.out.println(map.get(key));
		}
           

這種方法效率低

第一種方法，map.entrySet()

//通過map.entrySet();周遊map集合
		Set<Entry<String, Integer>> entrys = map.entrySet();//import java.util.Map.Entry;
		for(Entry<String, Integer> en : entrys){
			System.out.println("key: " + en.getKey() + ", value: " + en.getValue());
		}
		//key: b, value: 1
		//key: e, value: 2
           

TreeMap

TreeMap 存儲 Key-Value 對時，需要根據 Key 對 key-value 對進行排序。TreeMap 可以保證所有的 Key-Value 對處于有序狀态。

TreeMap 的 Key 的排序：

自然排序：TreeMap 的所有的 Key 必須實作 Comparable 接口，而且所有的 Key 應該是同一個類的對象，否則将會抛出 ClasssCastException

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;


public class Test6 {
	public static void main(String[] args) {
		//new HashMap這個類，指派給map1,指明泛型，是一對的
		Map<Integer,String> map1 = new HashMap<Integer,String>();
		
		map1.put(6, "xx33");//添加資料
		map1.put(2, "xx34");//添加資料
		map1.put(3, "xxx1");//添加資料
		map1.put(1, "xxx");//添加資料
		
		System.out.println(map1);//{1=xxx, 2=xx34, 3=xxx1, 6=xx33}
		
		Map<Integer,String> map2 = new TreeMap<Integer,String>();
		
		map2.put(6, "xx33");//添加資料
		map2.put(2, "xx34");//添加資料
		map2.put(3, "xxx1");//添加資料
		map2.put(1, "xxx");//添加資料
		
		System.out.println(map2);//{1=xxx, 2=xx34, 3=xxx1, 6=xx33}
		
		
	}

}
           

定制排序（了解）：建立 TreeMap 時，傳入一個 Comparator 對象，該對象負責對 TreeMap 中的所有 key 進行排序。此時不需要 Map 的 Key 實作 Comparable 接口

天天學一點點，開心一點點，頭發還剩億點點！