Java集合中的框架2

一、HashMap類和Hashtable類的用法TreeMap與ConcurrentHashMap

Map介面--集合介面--主要處理的是鍵值對結構的資料

鍵值對結構的資料---就是一個完成的資料是由鍵和鍵所對應的值組合而成的資料

例如:

  書的目錄就是一種鍵值對結構

 【標題----頁碼】

 

Map介面下的子類

1.HashMap類--public class HashMap【基於雜湊表的實現的Map介面】

允許null的值和null鍵

資料儲存是無序的

不能有重複的鍵，重複的鍵被算作是一個資料。

構造方法:

HashMap() 構造一個空的 HashMap ，預設初始容量（16）和預設負載係數（0.75）。

HashMap(int initialCapacity) 構造一個空的 HashMap具有指定的初始容量和預設負載因子（0.75）。

HashMap(int initialCapacity, float loadFactor) 構造一個空的 HashMap具有指定的初始容量和負載因子。

HashMap(Map<? extends K,? extends V> m) 構造一個新的 HashMap與指定的相同的對映 Map 。

package com.wangxing.hashmaptest;

import java.util.HashMap;

public class HashMapTest1 {
	public static void main(String[] args) {
		//Map 介面下的子類
		//HashMap類
		//允許null的值和null鍵
		//資料儲存時無序的
		//不能有重複的鍵，重複的鍵被算作是一個資料
		//構造方法：
		//HashMap()構造一個空的HashMap，預設初始容量（16）和預設負載係數（0.75）
		  HashMap<Object, Object> hashMap=new HashMap<>();
		  
		  //HashMap(int initialCapacity)構造一個空的HashMap具有指定的初始容量和預設負載因子（0.75）
		  HashMap<Object, Object> hashMap2=new HashMap<>(30);
		  
		  //HashMap(int initialCapacity,float loadFactor)構造一個空的HashMap具有指定的初始容量和指定的負載因子
		  HashMap<Object, Object> hashMap3=new HashMap<>(30, 0.5F);
		  
		  //HashMap(Map m)構造一個新的HashMap與指定的相同的對映Map
		  HashMap<Object, Object> hashMap4=new HashMap<>(hashMap3);
		  
		  
	}

}

例項方法:

void	clear() 清空集合。
Object		put(Object key, Object value) 向集合中新增鍵值對資料
boolean		containsKey(Object key) 判斷集合中是否包含指定的鍵
boolean		containsValue(Object value) 判斷集合中是否包含指定的值
Object		get(Object key) 根據指定的鍵得到該鍵對應的值
boolean		isEmpty() 判斷集合是否為空。
int		size() 得到集合中鍵值對元素的個數
V		remove(Object key)  根基指定的鍵刪除對應的鍵值對資料值
Set		keySet() 得到集合中所有的鍵儲存到Set集合中
Collection		values() 得到集合中所有的值儲存到Collection集合中
Set<Map.Entry<K,V>>		entrySet() 得到集合中所有的鍵值對資料Set集合中

package com.wangxing.hashmaptest;

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

public class HashMapTest2 {
		public static void main(String[] args){
			//HashMap類的常用例項方法
			//允許null的值和null鍵
			//資料儲存是無序的
			//不能有重複的鍵，重複的鍵被算作是一個資料
			HashMap<Object, Object> hashMap=new HashMap<>();
			//Object put(Object key,Object value)向集合中新增鍵值對資料
			hashMap.put("hello", 1234);
			hashMap.put(1234, "hello");
			hashMap.put(12.5, true);
			hashMap.put(false, 123.1);
			hashMap.put(null, "null鍵");
			hashMap.put("null值", null);
			hashMap.put(null, null);//會被算作一個
			
			// int  size()得到集合中鍵值對元素的個數
			System.out.println("size=="+hashMap.size());
			
			//boolean  containsKey(Object key)判斷集合中是否包含指定的鍵
			String containsKey=(hashMap.containsKey("helloworld"))?"存在":"不存在";
			System.out.println("containskey=="+containsKey);
			
			//boolean  containsValue(Object value)判斷集合中是否存在指定的值
			String  containsValue=(hashMap.containsValue("helloworld"))?"存在":"不存在";
			System.out.println("containsvaule=="+containsValue);
			
			//Object get(Object key)根據指定的鍵得到該鍵對應的值
			System.out.println("get=="+hashMap.get("hello"));
			
			//V  remove(Object key)根據指定的鍵刪除對應的鍵值對資料值
			hashMap.remove("null值");
			System.out.println("size=="+hashMap.size());
			
			//void clear()清空集合
			//hashMap.clear();
			//boolean isEmpty()判斷集合是否為空
			String pd=(hashMap.isEmpty())?"是":"否";
			System.out.println("集合是否為空？"+pd);
			
			/*
			 * Set  keySet()得到集合中所有的鍵儲存到Set集合中
			 * Collectionvalue()方法用於檢查HashMap中的單個鍵或多個鍵是否對映了特定值。它使用Value作為引數，如果該值由對映中的任何鍵對映，則返回True
			 * Set<Map.Entry<k,v>>  entrySet()得到集合中所有的鍵值對資料Set集合中
			 * 
			 */
			Set set=hashMap.keySet();
			boolean  collection=hashMap.containsValue("hello");
			
			System.out.println(collection);
			
			Set<Map.Entry<Object,Object>> maps=hashMap.entrySet();
			System.out.println("maps=="+maps);
		}
}

遍歷HashMap集合：

package com.wangxing.hashmaptest;

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class HashMapTest3 {
	public static void main(String[] args) {
		//HashMap的遍歷
		HashMap<Object,Object> hashMap=new HashMap<Object, Object>();
		hashMap.put("hello",1234);
		hashMap.put(1234,"hello");
		hashMap.put(12.5,true);
		hashMap.put(false,168.5);
		hashMap.put(null,"null鍵");
		hashMap.put("null值",null);
		
		//遍歷集合中所有的鍵儲存到Set集合中Set keySet()
		Set<Object> objects=hashMap.keySet();
		for (Object key : objects) {
			System.out.println("key=="+key);
		}
		
		System.out.println("----------");
		Iterator<Object> iterator=objects.iterator();
		while(iterator.hasNext()){
			Object object=iterator.next();
			System.out.println("key2=="+object);
		}
		
		System.out.println("-------------");
		//遍歷集合中所有值儲存到Collection集合中 values()
		Collection<Object> collection=hashMap.values();
		for (Object val : collection) {
			System.out.println("val=="+val);
		}
		System.out.println("----------------");
		
		Iterator<Object> iterator2=collection.iterator();
		while(iterator2.hasNext()){
			Object val2=iterator2.next();
			System.out.println("val2=="+val2);
		}
		System.out.println("------------------");
		//Set<Map.Entry<K,V>>  entrySet()得到集合中所有的鍵值對資料Set集合中
		Set<Map.Entry<Object, Object>> objects2=hashMap.entrySet();
		
		
		System.out.println("obj1=="+objects2);
		
		
		for (Map.Entry<Object, Object> entry : objects2) {
			System.out.println(entry.getKey()+"---"+entry.getValue());
		}
		
		
		for (Object object : objects2) {
			System.out.println("obj22"+object);
		}
		
		
		
		
		
	}
}

 

2.Hashtable類---public class Hashtable<K,V> 該類實現了一個雜湊表，它將鍵對映到值。

1. 無序
2. 不能有null鍵/null值
3. 用作鍵的物件必須實現hashCode方法和equals方法。
4. 不能有重複的鍵，重複的鍵被算作是一個資料。
5. 執行緒安全

構造方法

Hashtable() 構造一個新的，空的雜湊表，預設初始容量（11）和負載因子（0.75）。

Hashtable(int initialCapacity) 構造一個新的，空的雜湊表，具有指定的初始容量和預設負載因子（0.75）。

Hashtable(int initialCapacity, float loadFactor) 構造一個新的，空的雜湊表，具有指定的初始容量和指定的負載因子。

Hashtable(Map<? extends K,? extends V> t) 構造一個與給定地圖相同的對映的新雜湊表。

package com.wangxing.hashtable;

import java.util.HashMap;
import java.util.Hashtable;

public class HashtableTest1 {
	public static void main(String[] args) {
		//Hashtable類
		//無序
		//不能有null鍵/null值
		//用作鍵的物件必須實現hashCode方法和equals方法
		//不能有重複的鍵，重複的鍵被算作是一個資料
		//執行緒安全
		
		//構造方法
		//Hashtable()構造一個新的，空的雜湊表，預設初始容量（11）和負載因子（0.75）
		Hashtable<Object, Object> hashtable=new Hashtable<>();
		
		//Hashtable(int initialCapacity)構造一個新的，空的雜湊表，具有指定的初始容量和預設的負載因子
		Hashtable<Object, Object> hashtable2=new Hashtable<>(30);
		
		//Hashtable(int initialCaoacity,float loadDactor)構造一個新的，空的雜湊表，具有指定的初始容量和指定的負載因子
		Hashtable<Object, Object> hashtable3 = new Hashtable<>(30, 0.5F);
		
		//Hashtable(Map t)構造一個與給定地圖相同的對映的新的雜湊表
		Hashtable<Object, Object> hashtable4=new Hashtable<>(hashtable);
		HashMap<Object, Object> hashMap=new HashMap<>();
		Hashtable<Object, Object> hashtable5=new Hashtable<>(hashMap);
		
		
		
	}

}

例項方法

void		clear() 清空集合。
Object		put(Object key, Object value) 向集合中新增鍵值對資料
boolean		containsKey(Object key) 判斷集合中是否包含指定的鍵
boolean		containsValue(Object value) 判斷集合中是否包含指定的值
Object		get(Object key) 根據指定的鍵得到該鍵對應的值
boolean		isEmpty() 判斷集合是否為空。
int		size() 得到集合中鍵值對元素的個數
V		remove(Object key)  根基指定的鍵刪除對應的鍵值對資料值
Set		keySet() 得到集合中所有的鍵儲存到Set集合中
Collection		values() 得到集合中所有的值儲存到Collection集合中
Set<Map.Entry<K,V>>		entrySet() 得到集合中所有的鍵值對資料Set集合中
Enumeration<K>		keys() 返回此雜湊表中鍵的列舉。
Enumeration<V>		elements() 返回此雜湊表中值的列舉。

//建立一個作為put方法引數的物件

package com.wangxing.hashtable;

public class UserBean {

}

package com.wangxing.hashtable;

import java.util.Enumeration;
import java.util.Hashtable;

public class HashteabeTest2 {
		public static void main(String[] args) {
			//Hashtable類的常用例項方法
			//無序
			//不能有null鍵/null值
			//用作鍵的物件必須實現hashCode方法和equals方法
			//不能有重複的鍵，重複的鍵被算作是一個資料
			//執行緒安全
			
			Hashtable<Object, Object> hashtable=new Hashtable<>();
			
			//Object put(Object key,Object Value)向集合中新增鍵值對資料
			hashtable.put("hello", 12134);
			hashtable.put(1234, "hello");
			hashtable.put(12.3, "hello");
			hashtable.put(true, false);
//			 java.lang.NullPointerException
//			 at java.util.Hashtable.put(Unknown Source)
			//hashtable.put(null, "null鍵");
			
			//用作鍵的物件必須實現hashCode方法和equals方法
			UserBean user=new UserBean();
			hashtable.put(user, "userBean");
			
			//int size()得到集合中鍵值對與元素的個數
			System.out.println("size=="+hashtable.size());
			
			//boolean  containsKey(Object key)判斷集合中是否半酣指定的鍵
			System.out.println("containskey=="+hashtable.containsKey("user"));
			
			//boolean  containsValue(Object value)判斷集合中是否包含指定的值
			System.out.println("containsValue=="+hashtable.containsValue("userBean"));
			
			//Object get(Object key)根據指定的鍵得到該鍵對應的值
			System.out.println("get=="+hashtable.get(user));
			
			//V  remover(Object key)根據指定的鍵刪除對應的鍵的值
			hashtable.remove("hello");
			System.out.println("size=="+hashtable.size());
			
			//void clear()清空集合 hashtable.clera();
			//isEmpty()判斷集合是否為空
			System.out.println("isEmpty=="+hashtable.isEmpty());
			
			/*
			Set	keySet() 得到集合中所有的鍵儲存到Set集合中
			Collection	values() 得到集合中所有的值儲存到Collection集合中 
			Set<Map.Entry<K,V>>	entrySet() 得到集合中所有的鍵值對資料Set集合中
			Enumeration<K>	keys() 返回此雜湊表中鍵的列舉。 
			Enumeration<V>	elements() 返回此雜湊表中值的列舉。 
			*/
			Enumeration<Object> enumeration=hashtable.keys();
			while (enumeration.hasMoreElements()) {
				Object key = (Object) enumeration.nextElement();
				System.out.println("key=="+key);
			}
			Enumeration<Object> enumeration2=hashtable.elements();
			while (enumeration2.hasMoreElements()) {
				Object value = (Object) enumeration2.nextElement();
				System.out.println("value=="+value);
			}
			
			
		
		}

}

遍歷Hashtable集合：

package com.wangxing.hashtable;

import java.util.Collection;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import javax.print.attribute.standard.MediaName;

public class HashtableTest3 {
		public static void main(String[] args) {
			//Hashtable類的遍歷
			Hashtable<Object, Object> hashtable=new Hashtable<>();
			hashtable.put("hello",1234);
			hashtable.put(1234,"hello");
			hashtable.put(12.5,true);
			hashtable.put(false,168.5);
			//遍歷所有鍵  Set keyset()/Enumeration<K> keys()
			Set<Object> keys=hashtable.keySet();
			for (Object key : keys) {
				System.out.println("key=="+key);
			}
			
			System.out.println("----------------------");
			Iterator<Object> iterator=keys.iterator();
			while (iterator.hasNext()) {
				Object key = (Object) iterator.next();
				System.out.println("key=="+key);
			}
			System.out.println("------------------");
			/*
			Set	keySet() 得到集合中所有的鍵儲存到Set集合中
			Collection	values() 得到集合中所有的值儲存到Collection集合中 
			Set<Map.Entry<K,V>>	entrySet() 得到集合中所有的鍵值對資料Set集合中
			Enumeration<K>	keys() 返回此雜湊表中鍵的列舉。 
			Enumeration<V>	elements() 返回此雜湊表中值的列舉。 
			*/
			Enumeration<Object> enumeration=hashtable.keys();
			while (enumeration.hasMoreElements()) {
				Object key = (Object) enumeration.nextElement();
				System.out.println("key=="+key);
			}
			System.out.println("------------");
			
			//遍歷所有值  Collection  values()/Enumeration<V> elements()
			Collection<Object> collection=hashtable.values();
			for (Object value : collection) {
				System.out.println("value=="+value);
			}
			System.out.println("------------");
			Iterator<Object> iterator2=collection.iterator();
			while (iterator2.hasNext()) {
				Object value= (Object) iterator2.next();
				System.out.println("value=="+value);
			}
			System.out.println("------------------");
			
			Enumeration<Object> enumeration2=hashtable.elements();
			while(enumeration2.hasMoreElements()){
				Object val=enumeration2.nextElement();
				System.out.println("val=="+val);
			}
			System.out.println("-----------------");
			//Set<Map.Entry<K,V>>  entrySet()得到集合中所有鍵值對資料Set集合中
			Set<Map.Entry<Object, Object>> set=hashtable.entrySet();
			for(Object val:set){
				System.out.println("val=="+val);
			}
			System.out.println("------------------");
			for (Map.Entry<Object, Object> entry : set) {
				System.out.println(entry.getKey()+"~~~"+entry.getValue());
			}
			
		}
}

3.TreeMap類--紅黑樹基於NavigableMap實現【有序】

 

4.ConcurrentHashMap類---執行緒安全，支援高併發，雜湊表

 

二、HashMap類與Hashtable類與TreeMap類與ConcurrentHashMap類的區別

 

HashMap類	Hashtable類
可以有null鍵/null值	不能有null鍵/null值
HashMap繼承AbstractMap類	Hashtable繼承Dictionary類
預設容量為16	預設容量為11
將容量變為原來的2倍。	將容量變為原來的2倍加1
執行緒不安全	執行緒安全

HashMap底層實現原理

HashMap基於hashing原理，我們通過put()和get()方法儲存和獲取物件。當我們將鍵值對傳遞給put()方法時，它呼叫鍵物件的hashCode()方法來計算hashcode，讓後找到bucket位置來儲存值物件。當獲取物件時，通過鍵物件的equals()方法找到正確的鍵值對，然後返回值物件。HashMap使用連結串列來解決碰撞問題，當發生碰撞了，物件將會儲存在連結串列的下一個節點中。 HashMap在每個連結串列節點中儲存鍵值對物件。當兩個不同的鍵物件的hashcode相同時會發生什麼？ 它們會儲存在同一個bucket位置的連結串列中。鍵物件的equals()方法用來找到鍵值對。

HashMap類	ConcurrentHashMap類
執行緒不安全	執行緒安全

 

Hashtable類	ConcurrentHashMap類
執行緒安全高併發是效率低	執行緒安全高併發是效率高

HashTable裡使用的是synchronized關鍵字，這其實是對物件加鎖，鎖住的都是物件整體，當Hashtable的大小增加到一定的時候，效能會急劇下降，因為迭代時需要被鎖定很長的時間。

ConcurrentHashMap使用了分割，將一個map分成多個小的hashtable，對map的一部分進行上鎖。保證同步的同時，有提高了效能。

 

HashMap類	Hashtable類	TreeMap類
無序  雜湊表	無序  雜湊表	有序的key-value集合  紅黑樹實現
HashMap繼承AbstractMap類	Hashtable繼承Dictionary類	繼承AbstractMap類 NavigableMap介面
執行緒不安全	執行緒安全	執行緒不安全

三、認識Collections類【集合類的幫助類】

public class Collections----此類僅由靜態方法組合或返回集合

靜態方法不需要物件就可以直接呼叫

此類中的方法都是靜態方法，靜態方法為了幫助我們更加方便的操作集合中的資料。

static <T extends Comparable<? super T>> void	sort(List<T> list) 根據其元素的natural ordering對指定的列表進行排序。
static void	reverse(List<?> list) 反轉指定列表中元素的順序。
static <T> void	copy(List<? super T> dest, List<? extends T> src) 將所有元素從一個列表複製到另一個列表中。
static <T extends Object & Comparable<? super T>> T	max(Collection<? extends T> coll) 根據其元素的 自然順序返回給定集合的最大元素。
static <T extends Object & Comparable<? super T>> T	min(Collection<? extends T> coll)  根據其元素的 自然順序返回給定集合的最小元素。

package com.wangxing.collections;

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

public class CollectionsTest1 {
		public static void main(String[] args) {
			//Collections類【集合類的幫助類】
			//此類中的方法都是靜態方法，靜態方法為了幫助我們更加方便的操作集合中的資料
			
			ArrayList arrayList=new ArrayList<>();
			arrayList.add(123);
			//型別轉換錯誤
			// java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.Boolean
			//arrayList.add(true);
			arrayList.add(12);
			arrayList.add(3);
			arrayList.add(345);
			for (Object object : arrayList) {
				System.out.println("排序前：--"+object);
			}
			
			//static void sort(List<T>list)根據元素的natural ordering對指定的列表進行排序
			Collections.sort(arrayList);
			for (Object object : arrayList) {
				System.out.println("排序後---"+object);
			}
			
			//static void  reverse(List<?>list)反轉指定列表中的元素順序
			Collections.reverse(arrayList);
			for (Object object:arrayList){
				System.out.println("反轉後=="+object);
			}
			
			//static T max(Collection<?extendsT>coll)根據其元素的自然順序返回給定集合的最大元素
			System.out.println("最大元素--"+Collections.max(arrayList));
			
			//static T min(Collection<?extends T>coll)根據其元素的自然順序返回給定集合的最小元素
			System.out.println("最小元素--"+Collections.min(arrayList));
			
			//static <T> void  copy(List<?super T>dest,List<? extends T>src)將所有元素從一個列表複製到另一個列表中
			ArrayList arrayList2=new ArrayList<>();
			arrayList2.add("zhangsan");
			arrayList2.add("lisi");
			//arrayList2.add("wangwu");
			//arrayList2.add("zhaoliu");
			//java.lang.IndexOutOfBoundsException: Source does not fit in dest
			//下表越界
			/*
			 * copy()方法是：

                                       得到原來集合的大小， int srcSize = src.size();
                                      如果srcSize大於dest.size，將會丟擲異常
               if (srcSize > dest.size())
               throw new IndexOutOfBoundsException(“Source does not fit in dest”);
			 */
			//arrayList2.add("test");
			
			//源集合arraylist2==目標集合arraylist【源集合中的元素會覆蓋目標集合中的元素】
		/*
			Collections.copy(arrayList, arrayList2);
			for(Object object:arrayList){
				System.out.println("copy後=="+object);
			}
			*/
			
		//源集合arrayList2<目標集合arrayList【源集合中的元素會覆蓋目標集合中的元素，會有遺留】
		/*
			Collections.copy(arrayList, arrayList2);	
			for (Object object : arrayList) {
				System.out.println("copy後=="+object);
			}
			*/
			
		//源集合list2  >  目標集合list1  [java.lang.IndexOutOfBoundsException]
			/*
			Collections.copy(arrayList, arrayList2);
			for(Object  obj:arrayList){
				System.out.println("copy後--"+obj);
			}
			*/	
			

注意與Arrays的比較
			
		}
}

四、Collection介面與Collections類的區別

Collection介面	Collections類
Interface	Class
包含了一些集合的基本操作方法【增刪改查】	集合框架的幫助類對集合的排序，搜尋以及序列化的操作