集合大滿貫III

Map接口概述

Map接口是將鍵映射到值的對象。一個映射不能包含重複的鍵；每個鍵最多隻能映射到一個值。
cn—>中國
uk—>英國
us—>美國

Map常用方法

clear()

從此映射中移除所有映射關係（可選操作）。

containsKey(Object key)

如果此映射包含指定鍵的映射關係，則返回 true。

containsValue(Object value)

如果此映射將一個或多個鍵映射到指定值，則返回 true。

entrySet()

返回此映射中包含的映射關係的 Set 視圖。

equals(Object o)

比較指定的對象與此映射是否相等。

get(Object key)

返回指定鍵所映射的值；如果此映射不包含該鍵的映射關係，則返回 null。

hashCode()

返回此映射的哈希碼值。

isEmpty()

如果此映射未包含鍵-值映射關係，則返回 true。

keySet()

返回此映射中包含的鍵的 Set 視圖。

put(K key, V value)

將指定的值與此映射中的指定鍵關聯（可選操作）。

putAll(Map<? extends K,? extends V> m)

從指定映射中將所有映射關係複製到此映射中（可選操作）。

remove(Object key)

如果存在一個鍵的映射關係，則將其從此映射中移除（可選操作）。

size()

返回此映射中的鍵-值映射關係數。

Map常用實現類

HashMap

基於哈希表的Map接口的實現。此實現提供所有可選的映射操作，並允許使用null值和null鍵。此類不保證映射的順序。
存儲特點：
相對無序存儲，元素以鍵值對形式存在，鍵不可以重複，值可以重複，元素整體排重，可以快速的通過鍵查找到所對應的值，通過哈希表實現的集合。
Map集合的排重，只需要重寫鍵所屬的類的hashCode和equals方法即可。

Map集合的排重代碼實現

//Person作爲鍵
public class Person {
	private String name;
	private int age;
	public Person() {
		super();
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int hashCode() {
		return age + name.length();
	}
	@Override
	public boolean equals(Object obj) {
		if(obj instanceof Person) {
			Person p = (Person) obj;
			if(p.name.equals(name)&&p.age==age) {
				return true;
			}
		}
		return false;
	}
}
//Dog類作爲值
public class Dog {
	private String name;
	public Dog(String name) {
		super();
		this.name = name;
	}
	public Dog() {
		super();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	public String toString() {
		return "Dog [name=" + name + "]";
	}
}
//測試類
public class Demo {
	public static void main(String[] args) {
		HashMap<Person, Dog> map = new HashMap<>();
		map.put(new Person("zhangsan", 12), new Dog("大黃"));
		map.put(new Person("lisi", 12), new Dog("旺財"));
		map.put(new Person("zhangsan", 12), new Dog("二哈"));
	}
}

//map集合中若向集合中添加相同鍵的鍵值對時，新的值會將舊的值覆蓋。
上述代碼中map集合中有兩個鍵值對，分別爲：張三-12---二哈，lisi-12---旺財

LinkedHashMap

存儲特點：
	有序存儲，元素排重，通過鏈表實現的集合。

Hashtable

此類實現一個哈希表，該哈希表將鍵映射到相應的值。任何非null對象都可以用作鍵或值。

HashMap與Hashtable的區別

1）Hashtable線程安全的，而HashMap線程不安全的
2）Hashtable中不允許存在null的鍵和null值，但是HashMap中允許null的鍵和null值

Map集合的遍歷

1、使用keySet方法與get方法結合

public class Demo {
    public static void main(String[] args){
      	HashMap<String, Integer> map = new HashMap<>();
      	map.put("aaa", 12);
      	map.put("bbb", 13);
      	map.put("ccc", 14);
      	//通過keySet獲取map中所有鍵
      	Set<String> set = map.keySet();
      	//獲取set的迭代器
      	Iterator<String> it = set.iterator();
        while(it.hasNext()){
          	String s = it.next();
          	//通過迭代的鍵，找到對應的值，一起輸出
          	System.out.println(s+"---"+map.get(s));
        }
    }
}

2、使用Map.Entry方法

調用Map集合的entrySet方法，相當於將Map集合轉成一個Set集合，再通過Set集合的遍歷方式遍歷即可。

public class Demo {
	public static void main(String[] args) {
		HashMap<String, Integer> map = new HashMap<>();
		map.put("aaa", 111);
		map.put("bbb", 222);
		map.put("ccc", 333);
		//將map轉成一個Set集合
		Set<Map.Entry<String, Integer>> set = map.entrySet();
		//遍歷set
		Iterator<Map.Entry<String, Integer>> it = set.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
	}
}

Collections工具類

此類完全由在 Collection 上進行操作或返回 Collection 的靜態方法組成。對集合進行操作時，可以使用這個類中的靜態方法。

1.同步線程
/*
	static <T> Collection<T> synchronizedCollection(Collection<T> c) 
          返回指定 collection 支持的同步（線程安全的）collection。 
	static <T> List<T> synchronizedList(List<T> list) 
          返回指定列表支持的同步（線程安全的）列表。 
	static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) 
          返回由指定映射支持的同步（線程安全的）映射。 
	static <T> Set<T> synchronizedSet(Set<T> s) 
          返回指定 set 支持的同步（線程安全的）set。 
*/
		Collection c = Collections.synchronizedCollection(new ArrayList());
		List s = Collections.synchronizedList(new ArrayList());
		Map m = Collections.synchronizedMap(new HashMap());
2.排序
 /*
		static <T extends Comparable<? super T>> void sort(List<T> list) 
          根據元素的自然順序 對指定列表按升序進行排序。 
		*/
		ArrayList<Integer> list = new ArrayList<>();
		list.add(-10);
		list.add(5);
		list.add(3);
		list.add(7);

		System.out.println(list);
		Collections.sort(list);//默認升序
		System.out.println(list);
3.將集合中的元素進行反轉
/*
		static void reverse(List<?> list) 
          反轉指定列表中元素的順序。 
		*/
		Collections.reverse();
4.將集合元素打亂
/*
		static void shuffle(List<?> list) 
          使用默認隨機源對指定列表進行置換。 
		*/
5.獲取集合中的最大值、最小值
/*
		static T max(Collection coll) 
         根據元素的自然順序，返回給定 collection 的最大元素。
		  
		static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll) 
         根據元素的自然順序 返回給定 collection 的最小元素。 
		*/
		int n1 = Collections.max(list);
6.替換
/*
		static <T> boolean 
 replaceAll(List<T> list, T oldVal, T newVal) 
          使用另一個值替換列表中出現的所有某一指定值 
		*/
		//原因：List集合是不排重的，使用新的元素將集合中出現的所有的舊的元素替換掉
		Collections.replaceAll(list,5,100);
7.統計指定元素在集合中出現的次數
/*
		static int frequency(Collection<?> c, Object o) 
          返回指定 collection 中等於指定對象的元素數。 
		*/
		int num = Collections.frequency(list,5);
8.二分法查找
/*
		static <T> int 
 					binarySearch(List<? extends Comparable<? super T>> list, T key) 
          使用二分搜索法搜索指定列表，以獲得指定對象。 
		*/
		//前提：必須是排好序的集合
		int index = Collections.binarySearch(list,-10);

		//注意：Collections工具類中的方法只操作Collection接口，主要操作的是List接口	
9.集合和數組的轉換
//1數組轉成集合，集合不能做添加、刪除操作
	public static void arrayToList() {
		String[] names= {"張三","李四","王五"};
		List<String> list=Arrays.asList(names);
		
		System.out.println("list："+list);
		//添加
		//list.add("趙六");
		//刪除
		//list.remove(0);
		//System.out.println("添加或刪除之後list："+list);
		list.set(0, "本偉");
		System.out.println("替換之後:"+list);
		
	}
	//2 集合轉成數組
	public static void listToArray() {
		ArrayList<String> arrayList=new ArrayList<>();
		arrayList.add("蘋果");
		arrayList.add("小米");
		arrayList.add("華爲");
		arrayList.add("三星");
		
		//數組
		String[] arr=arrayList.toArray(new String[0]);
		System.out.println("--------遍歷數組-------");
		for (String string : arr) {
			System.out.println(string);
		}
	}

總結

Collection
|_____List （特點：有序的，可以重複）
|___ArrayList （存儲結構:數組）
|___LinkedList （雙向鏈表）
|___Vector 數組
|___Stack （棧）先進後出
|
|_____Set（特點:無序的，不能重複）
|__HashSet 哈希表(數組加鏈表) 1 執行hashCode()來計算存儲的位置,2 執行equals比較結果
|LinkedHashSet 哈希表 可以保證順序
|TreeSet 自平衡紅黑二叉樹 1 元素要實現Comparable接口,2 定製比較器 Comparator
Map(特點：存儲鍵值對，鍵不能重複，值可以重複，無序)
| HashMap 哈希表 1 執行hashCode()來計算存儲的位置 ，2 執行equals比較結果
| Hashtable 哈希表 不能存儲null鍵和null值，線程安全的 jdk1.0
|_______LinkedHashMap 哈希表 可以保證順序
|_______TreeMap 自平衡紅黑二叉樹 1 key 要實現Comparable接口 ，2 定製比較器 Comparator

collection是一個單例集合的根接口
collections是操作集合對象的一個工具類。
Arrays:用於對數組操作的工具類
asList(T[])；將數組變成集合
toArray();集合變數組。

1.簡述HashSet和LinkedHashSet之間的區別
LinkedHashSet繼承自HashSet，HashSet內部使用HashMap，源碼更少、更簡單，唯一的區別是LinkedHashSet內部使用的是LinkHashMap。這樣做的意義或者好處就是LinkedHashSet中的元素順序是可以保證的，也就是說遍歷序和插入序是一致的。

2、comparable 和comparator區別

1.集合元素需要實現comparable接口，叫做自然排序，comparator是比較器，實現定製排序
2.comparable中的compareTo()一個參數,Comparator中compare()兩個參數，返回值是int類型
如果返回0，表示兩個比較元素相同
大於0，前面大於後面
小於0，前面小於後面