java --集合

總結：
1.HashSet與HashMap的區別？
HashSet只是實現了HashMap中的key。
2.HashSet去重原理？
當向HashSet中添加對象時，首先會調用對象的hashCode()方法，計算該對象的hash值，該值決定了該對象在HashSet中存儲位置，若是該值沒有被佔用，則直接插入；若是被佔用了，則經過equals()來比較這兩個對象是否相同，若是相同，則後一個對象不能被添加進來。
3.HashSet與TreeSet的聯繫與區別？
3.1它們均可以去重，treeSet能夠排序。
3.2向TreeSet中存放的元素必須是同一種類型。
3.3TreeSet中的元素從小到大排序
排序原理：向TreeSet中添加自定義類時，必需要重寫compareTo方法，該方法決定使用什麼規則來排序。
4.TreeMap與TreeSet同樣
都須要重寫hashCode方法與equals()方法，並且還須要實現compareTo方法。
5.Collection線程安全問題
只有hashTable與vector是線程安全的
若是須要線程安全，則須要加上synchronized轉換
//線程安全
List<Integer> list2 = Collections.synchronizedList(list);

#1.java集合能夠分爲Collection和Map兩大致系。
##1.collection接口
它有兩個子接口
Set：元素無序、不可重複，無序指的是在內存中的位置是無序的
List：元素有序、能夠重複
##2.Map接口
它是key-value的集合。
#2.Collection經常使用方法

public class TestCollection {
	@Test
	public void testCollection(){
		Collection<Object> collection = new ArrayList<>();
		//1.size():返回集合中元素的個數
		System.out.println(collection.size());
		//2.add(Object obj)：向集合中添加一個元素  
		collection.add(100);
		collection.add("panda");
		collection.add(new Date());
		//3.addAll(Collection coll)：將集合coll中全部的元素都添加到目前的集合中
		Collection<Object> collection2 = new ArrayList<>();
		collection2.addAll(collection);
		System.out.println(collection2);
		//4.isEmpty()：判斷該集合是否爲空  
		System.out.println(collection2.isEmpty());
		//5.clear()：清空集合元素
		collection2.clear();
		//6.contains(Object obj)：判斷集合中是否包含指定的元素
		System.out.println(collection.contains(100));
		//7.containsAll(Collection coll)：判斷當前集合是否包含coll中所有的元素
		Collection<Object> collection3 = new ArrayList<>();
		collection3.add("panda");
		System.out.println(collection.containsAll(collection3));
		//8.retainAll(Collection coll)：求當前集合與coll共有的元素，交集
		System.out.println(collection.retainAll(collection3));
		//9.remove(Object obj)：刪除集合中obj元素，成功返回true
		System.out.println(collection.remove("zhangsan"));
		//10.removeAll(Collection coll)：求差集，成功返回true
		System.out.println(collection.removeAll(collection3));
		//11.equals(Object obj)：判斷集合中的全部元素是否徹底相同
		System.out.println(collection.equals(collection3));
		//12.toArry()：將集合轉換成數組
		Object[] obj = collection.toArray();
		System.out.println(obj);
		//13.iterator()：用來遍歷集合
		Iterator<Object> iterator = collection.iterator();
		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	}
}

#3.List經常使用方法
list繼承collection，所以，也繼承了collection的全部方法。
##3.1.ArrayList

public class TestList {
	@Test
	public void testList(){
		
		List<Object> list = new ArrayList<>();
		list.add(111);
		list.add(222);
		list.add(333);
		//1.set(int index, E element)：修改index處的元素
		list.set(1, 444);
		System.out.println(list);
		//2.add(int index, E element):在index處插入一個元素
		list.add(1, 555);
		System.out.println(list);
		//3.indexOf(Object obj)：判斷obj這個元素在list中首次出現的位置，若是不存在，返回-1.
		System.out.println(list.indexOf(666));
		//4.lastIndexOf(Object obj)：判斷obj這個元素在list中最後一次出現的位置，若是不存在，返回-1.
		System.out.println(list.indexOf(777));
		//5.subList(int fromIndex, int toIndex)：截取list，包含fromIndex，不包含toIndex
		System.out.println(list.subList(1, 3));
	}
}

##3.2LinkedList
數組鏈表，適用於頻繁的插入與刪除。插入與刪除操做只須要修改相應的指針便可。
#4.Set經常使用方法
##4.1HashSet

public class TestSet {
	@Test
	public void testSet(){
		HashSet<Object> set = new HashSet<>();
		set.add(null);
		set.add(123);
		set.add(new String("AA"));
		set.add(new String("AA"));
		//打印結果：[null, AA, 123]
		//能夠看到"AA"去重了
		//String默認重寫了hashCode和equals方法
		System.out.println(set);
		set.add(new Car("ford", 200000));
		set.add(new Car("ford", 200000));
		//打印結果：[null, AA, Car [brand=ford, price=200000], 123]
		//這裏重寫了Car的hashCode和equals方法
		//set中的元素存儲原理--使用了hash算法
		//當向set中添加對象時，首先調用對象的hashCode()方法，計算該對象的hash值
		//該值決定了該對象在set中的存儲位置。若此位置之間沒有被佔用，則直接存入。
		//若是被佔用了，則經過equals()比較這兩個對象是否相同
		//若是相同，則後一個對象不能在添加進來
		System.out.println(set);
	}
}

##4.2TreeSet

public void testSet(){
		/**
		 * TreeSet:
		 * 1.向TreeSet中添加的元素必須是同一個類型
		 * 2.TreeSet中的元素從小到大排序(去重了)
		 * 3.添加本身定義的類時，須要實現Comparable，且重寫compareTo方法，重寫該方法即規定按照什麼規則排序
		 * 4.注意:自定義類的全部屬性都必須參與比較，不然會出現數據丟失的狀況
		 */
		Set<Object> set = new TreeSet<>();
		set.add(new Car("ford", 20000));
		set.add(new Car("bmw", 50000));
		set.add(new Car("audi", 40000));
		//我是按照價格排序
		System.out.println(set);
	}

@Override
	public int compareTo(Car o) {
		//注意：該類的全部屬性都要參與比較
		//這樣的話，能夠實現多個屬性排序
		int i = this.price.compareTo(o.price);
		if (i == 0) {
			return this.brand.compareTo(o.brand);
		}
		return i;
	}

#4.map
##4.1 hashMap

public class TestMap {
	@Test
	public void testMap(){
		Map<String, Object> map = new HashMap<>();
		map.put("123", "張三");
		map.put("456", "李四");
		map.put("345", "王五");
		//1.遍歷key值
		Set<String> key = map.keySet();
		Iterator<String> it = key.iterator();
		String tmp = "";
		while (it.hasNext()) {
			tmp = (String) it.next();
			System.out.println(tmp);
		}
		//2.遍歷value
		Collection<Object> coll = map.values();
		Iterator<Object> it2 = coll.iterator();
		String tmp2 = "";
		while (it2.hasNext()) {
			tmp2 = (String) it2.next();
			System.out.println(tmp2);
		}
		//3.遍歷k-v對
		Set<Entry<String, Object>> set = map.entrySet();
		Iterator<Entry<String, Object>> it3 = set.iterator();
		String tmpKey = "";
		Object tmpValue = null;
		while (it3.hasNext()) {
			Entry<String, Object> en = it3.next();
			tmpKey = en.getKey();
			tmpValue = en.getValue();
			System.out.println("key:"+tmpKey+"---value:"+tmpValue);
		}
	}
}

##4.2TreeMap
同TreeSet同樣排序，須要重寫hashcode、equals方法，同時須要實現comparable的compareTo方法。
##4.3properties
1.在工程路徑下新建db.properties文件
在配置文件輸入信息

user = root
password = 123456

測試properties文件

public void testMap() throws FileNotFoundException, IOException{
		Properties prop  = new Properties();
		prop.load(new FileInputStream(new File("db.properties")));
		String user = prop.getProperty("user");
		//打印root
		System.out.println(user);
	}

#5.操做集合工具類Collections

public void testMap() {
		
		List<Integer> list = new ArrayList<>();
		list.add(12);
		list.add(45);
		list.add(35);
		list.add(28);
		System.out.println("天然順序："+list);
		//反轉list中的元素
		Collections.reverse(list);
		System.out.println("倒轉："+list);
		//對list中的元素隨機排序
		Collections.shuffle(list);
		System.out.println("隨機排序："+list);
		//對list中的元素從小到大排序
		Collections.sort(list);
		System.out.println("由小到大排序："+list);
		//交換list中兩個元素的位置
		Collections.swap(list, 1, 3);
		System.out.println("交換1和3位置："+list);
		//找list中元素的最大值
		System.out.println("最大值："+Collections.max(list));
	}

#6.Collection線程安全問題
線程安全概念：若是咱們某段代碼在某個(或某些)進程中有多個線程運行，換句話說，存在一段代碼，在進程中有多個線程會同時使用它，若是多個線程和單個線程運行的結果是同樣的，則說明線程是安全的。
線程安全問題是由 全局變量 和 靜態變量 引發的。若全部的線程對全局變量、靜態變量只有讀操做而沒有寫操做，則說這個全局變量、靜態變量是線程安全的；不然當多個線程對全局變量、靜態變量進行寫操做時，須要考慮線程同步，不然會引發線程安全問題。
Collection接口中，只有hashtable與vector是線程安全的；其它的線程都不安全。
若是須要線程安全，則須要加上synchronized轉換。

//線程安全
List<Integer> list2 = Collections.synchronizedList(list);

則list2是線程安全的。