------Java培訓、Android培訓、iOS培訓、.Net培訓、期待與您交流！ -------
一,集合概念
之前我們存儲大量的對象，可以使用數組：
但數組有兩個缺陷：
1.其長度一旦確定，後期不能更改；對於元素的新增、刪除就十分的不方便；
2.數組只能存儲一種類型的數據。
爲了解決上述問題，也爲了我們程序員更加方便的存儲大量的對象，Java爲我們提供了一種"類":集合類；
1.集合：它的作用跟數組一樣，就是存儲大量對象的；
2.跟數組不同的：
1).使用集合可以是我們程序員不用關心"長度"的概念，"集合"對於我們來說，似乎像個"無底洞"，可以存儲無限數量的對象；
2).集合可以存儲任何的"對象"；(但後期我們也是經常會存儲一種對象)
public class Demo {
public static void main(String[] args) {
//1.定義容器：集合類：ArrayList
ArrayList list = new ArrayList();
//2.實例化若干多的Student對象
for(int i = 0;i < 10000; i++){
//直接實例化，並向集合中添加對象(注意：這裏添加的也是對象的引用)
list.add( new Student("姓名：" + i,i + 10));//姓名：0,10
}
//經過上述的第2步後，集合中添加了10000個Student對象的引用；
//3.遍歷集合
for(int i = 0;i < list.size();i++){
//從集合中取出Student引用
Student s = (Student)list.get(i);//跟數組差不多，這裏調用的是get()方法，獲取一個Student的引用.由於get方法返回的是Object類型，所以這裏強轉一下
System.out.println(s.name + "," + s.age);
}
//假如，原集合存儲的對象有增加，這時可以直接向集合中繼續添加元素
for(int i = 10000;i < 20000; i++){
//直接實例化，並向集合中添加對象(注意：這裏添加的也是對象的引用)
list.add( new Student("姓名：" + i,i + 10));//姓名：0,10
}
}
}
第二講 Collection
一,Collection
1.它是所有List和Set集合的跟接口；
2.它內部定義了List和Set所應具有的方法；
學習：從Collection接口開始；
使用：從子類開始：ArrayList
Collection中定義的常用方法：
1.添加：
//大家以後看到某個方法的形參或返回值是E的話，那麼就先把它視作：Object類型：
boolean add(Object e)：向集合中添加元素；如果此 collection 由於調用而發生更改，則返回 true
boolean addAll(Collection c)
2.刪除：
boolean remove(Object o)：移除元素：此 collection 由於調用而發生更改），則返回 true 。
void clear()：清空集合
boolean removeAll(Collection c)
3.判斷：
boolean contains(Object o)：判斷參數在集合中是否存在；存在：返回true，否則返回false
boolean isEmpty():判斷集合爲空；
boolean containsAll(Collection c)
4.獲取：
int size()：獲取集合內的元素的數量；
boolean retainAll(Collection c)
二,Collection中的一些批量操作 的方法：
添加
boolean addAll(Collection c)：指定 collection 中的所有元素都添加到此 collection 中（可選操作）。
刪除
boolean removeAll(Collection c)：移除此 collection 中那些也包含在指定 collection 中的所有元素（可選操作）。
判斷：
boolean containsAll(Collection c)：如果此 collection 包含指定 collection 中的"所有元素"，則返回 true。
boolean retainAll(Collection c)：移除此 collection 中未包含在指定 collection 中的所有元素。
代碼:
import java.util.ArrayList;
import java.util.Collection;
public class CollectionMethod {
public static void main(String[] args) {
methodSingle();
System.out.println("====================");
methodAll();
}
public static void methodSingle(){
//使用子類ArrayList
Collection list = new ArrayList();
//向集合中添加引用（這裏添加字符串）
list.add("劉若英");
list.add("劉德華");
list.add("劉詩詩");
list.add("劉惜君");
//打印集合：
System.out.println("原集合：" + list);
//測試：remove(Object o);
System.out.println("移除劉若英:" + list.remove("劉若英"));//true
System.out.println("移除後：" + list);
//4.void clear()：清空集合
/*list.clear();
System.out.println("集合被清空了：" + list);*/
//5.boolean contains(Object o)：判斷參數在集合中是否存在；存在：返回true，否則返回false
System.out.println("判斷劉若英是否存在：" + list.contains("劉若英"));
System.out.println("判斷劉德華是否存在：" + list.contains("劉德華"));
//6.boolean isEmpty():判斷集合爲空；
/*System.out.println("集合是否爲空：" + list.isEmpty());
list.clear();
System.out.println("清空後，判斷是否爲空：" + list.isEmpty());*/
//7.int size()：獲取集合內的元素的數量；
System.out.println("集合內元素的數量：" + list.size());
}
public static void methodAll(){
//集合1
Collection list1 = new ArrayList();
list1.add("劉若英");
list1.add("劉德華");
list1.add("劉詩詩");
list1.add("劉惜君");
//集合2
Collection list2 = new ArrayList();
list2.add("王心凌");
list2.add("王力宏");
list2.add("王光良");
list2.add("王菲");
//addAll()
list1.addAll(list2);//合班
System.out.println("合班之後list1中的元素：" + list1);
System.out.println("list2中的元素：" + list2);
//removeAll();
/* list1.removeAll(list2);//再分班
System.out.println("分班後，list1中的元素：" + list1);
System.out.println("list2中的元素：" + list2);
*/
//containsAll
System.out.println("list1中包含list2中的所有元素嗎？" + list1.containsAll(list2));
Collection list3 = new ArrayList();
list3.add("毛爺爺");
list3.add("鐵娘子");
list3.add("奧巴馬");
list3.add("金正恩");
System.out.println("list1中包含list3中的所有元素嗎？" + list1.containsAll(list3));
//retainAll()
list2.retainAll(list3);
System.out.println("移除list2中未包含在list3中的所有元素:" + list2);
System.out.println("list2中的元素;" + list2);
System.out.println("list3中的元素：" + list3);
Collection list4 = new ArrayList();
list4.add("aa");
list4.add("bb");
Collection list5 = new ArrayList();
list5.add("cc");
list5.add("dd");
list4.retainAll(list5);
System.out.println("list4 中的所有元素：" + list4);
System.out.println("list5 中的所有元素：" + list5);
}
}
三,迭代器：java.util.Iterator(接口)
成員方法：
1.boolean hasNext():判斷是否可以返回下一個元素；
2.Object next():返回下一個元素；
兩種遍歷方式:
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/*
*
*
*
*/
public class CollectionTraverse {
public static void main(String[] args) {
methodTraverseFirst();
System.out.println("===========");
methodTraverseSecond();
}
/*
* 方法一：
*
*/
public static void methodTraverseFirst() {
//實例化一個集合
Collection list = new ArrayList();
//填充集合
list.add("王心凌");
list.add("張韶涵");
list.add("辛曉琪");
list.add("蔡依林");
//獲取數組
Object[] objArray = list.toArray();
//遍歷數組
for(int i = 0;i < objArray.length ; i++){
//由於toArray()方法返回的是Object類型的數組，而我們存儲的是String對象。可以將Object強制轉換爲String
String s =(String) objArray[i];
System.out.println("數組："+s);
}
}
public static void methodTraverseSecond(){
//1.實例化一個集合
Collection list = new ArrayList();
//2.填充集合
list.add("王心凌");
list.add("張韶涵");
list.add("辛曉琪");
list.add("蔡依林");
//3.使用迭代器遍歷：
Iterator it = list.iterator();
while(it.hasNext()){
Object o = it.next();
System.out.println("Iterator：" + o);
}
}
}
第三講 List
一,層次
Collection(接口):
|--List(接口):
|--ArrayList(類)
二,List接口的特點：
1.有序的；
2.可以根據整數的索引訪問元素(類似於數組的使用)；
3.允許重複的元素；
三,List接口中的特有方法：
void add(int index,Object element):在index的位置上插入元素element，原索引上的元素依次後移；
Object remove(int index)：移除列表中指定位置的元素（可選操作）。將所有的後續元素向左移動（將其索引減 1）。返回從列表中移除的元素。
Object get(int index):取index位置上的元素。(它就類似於數組的下標)
Object set(int index,E element)：將element替換原index位置上的元素；
LitsIterator listIterator()：List接口特有的Iterator()，同樣是用來遍歷元素的。
四,|--List接口：
|--ArrayList類：內部數組實現；線程不安全的。效率高
|--Vector類：內部數組實現；線程安全的。效率低；
|--LinkedList類：鏈表實現：線程不安全的。效率高；
五,Iterator接口：是單向的，只能向下遍歷；
|--ListIterator接口：
|--特有的方法：
hasPrevious()：如果可以向上遍歷，返回true
previous():獲取前一個元素；
import java.util.ArrayList;
import java.util.List;
public class ListMethod {
public static void main(String[] args) {
//實例化一個集合
List list = new ArrayList();
//先使用Collection的add添加一些元素
list.add("紫薇");
list.add("爾康");
list.add("五阿哥");
//1.void add(int index,Object element)
//在ccc前面加一個XXX
list.add(2,"小燕子");
System.out.println("add方法之後的集合：" + list);
list.add(3,"漱芳齋");//OK的
System.out.println("add方法之後的集合：" + list);
//2.Object remove(int index)：
list.remove(3);
System.out.println("移除掉之後的元素：" + list);
//3.Object get(int index)
System.out.println("獲取索引爲3的元素：" + list.get(3));
//4.Object set(int index,E element)
//將XXX改爲YYY
list.set(3, "皇阿瑪");
System.out.println("替換後爲：" + list);
}
}1
六,Collection(接口)
|--List(接口):特點：1.有序的；2.可以存儲重複元素；
|--ArrayList:
1.數組實現：
2.線程不安全，效率高；
|--Vector:
1.數組實現：
2.線程安全，效率低；
|--LinkedList:
1.鏈表：
2.線程不安全的，效率高；
七,Collection(接口)
|--List(接口):
|--Vector(類):
1.數組實現。查詢快，增刪慢；
2.線程安全，效率低；
Vector是List的子類，所以：它具有List和Collection的所有功能；
另外Vector又增加了一些特有的功能：
public void addElement(Object obj):向集合添加一個obj，添加到集合的末尾；
public Object elementAt(int index)：獲取index位置上的元素；作用等同於：List-->get(int index);
public Enumeration elements():返回一個枚舉；
八,LinkedList的特有方法：
public void addFirst(E e)及addLast(E e)
public E getFirst()及getLast()
public E removeFirst()及public E removeLast()
如果將LinkeList作爲鏈表使用：
1.使用addFirst()進行添加；
使用get(int index)進行獲取；
2.使用addFirst()進行添加；
使用getFirst()獲取；
使用removeFirst()移除第一個元素；
3.使用add(Object o)進行添加；
使用getLast()進行獲取
使用removeLast()移除最後的元素；
如果將LinkedList作爲普通的集合使用：
1.使用add()添加；
2.使用get()獲取；
第四講 泛型
一,泛型概念
1.集合就像倉庫，可以裝任何的引用類型；因爲它的add()方法接收的是Object類型的。
2.對於集合類，看似功能比較強大，可以添加任何類型的引用。
但取出的時候，也比較費事，
3.我們以後使用集合類，經常是向集合中添加一種類型的引用；
4.這時，Java爲我們提供了一種語法功能：可以將一個集合，在定義時，同時定義這個集合中只能存放
什麼類型的元素。這種功能就叫：泛型；
5.例如：我們需要定義一個只存儲"字符串"的集合
ArrayList<String> list = new ArrayList<String>();
或
ArrayList<String> list = new ArrayList<>();(我會經常使用這種形式)
或
ArrayList<String> list = new ArrayList();
6.通過JAD查看反編譯的class文件，我們發現，泛型的信息已經沒有了。
所以：泛型只是在編譯期所具有的一種行爲，這種行爲能夠規範一個集合內只能存儲我們定義的某種類型。
如果向集合中存儲其它類型，編譯器會產生編譯錯誤。
7.泛型可以定義泛型類,泛型方法,泛型接口
二,泛型的通配符
1.<?>:
1).這種變量可以指向什麼樣的對象：具有任何泛型的集合。
2).這種集合可以存儲什麼類型的數據：什麼都不能存；
3).這種集合獲取時，可以用什麼類型接收：只能用Object。因爲使用了？,所以不確定裏面存了什麼類型；
作用：這種聲明的引用，只能獲取，不能存入。它一般用於"方法的返回值"的聲明；
2.<? extends E>:
1).這種變量可以指向什麼樣的對象：此聲明的集合意味着此變量只能指向具有E或E的子類泛型的集合對象；
2).這種集合可以存儲什麼類型的數據：因爲某個具體的子類不確定，所以什麼類型的對象都不能存；
3).這種集合獲取時，可以用什麼類型接收：使用E及E的父類類型接收都可以；
作用：這種聲明的引用，只能獲取，不能存入。它一般也是用於"方法的返回值"聲明；
3.<? super E>:
1).這種變量可以指向什麼樣的對象：任何具有E及E的父類類型泛型的集合對象；
2).這種集合可以存儲什麼類型的數據：任何的E及E的子類類型都可以；
3).這種集合獲取時，可以用什麼類型接收：取出時只能用Object接收。
作用：這種聲明的引用，可以存入元素，但不能用除Object外的其它類型接收。這種聲明的格式一般用在"方法的形參"
第五講 增強for循環
一,格式：for(數據類型 變量名 : 集合對象名/數組名)
1.增強for不使用循環變量；
2.根據自己的需要，如果需要使用循環變量，那麼就使用普通的for循環；
如果不需要循環變量，只是簡單的遍歷一下集合或數組，那麼使用增強for的語法會簡潔許多。
3.增強for類似於迭代器，通過它對集合進行遍歷時，仍然不能使用集合對象對集合內部進行修改，否則將拋出：併發修改異常：java.util.ConcurrentModificationException
第六講 Set(接口)
一,Collection(接口):
|--List(接口)：有序的，可以存儲重複值；
|--ArrayList(類）：
|--Vector(類）：
|--LinkedList(類):
|--Set(接口)：無序的(取出時跟存入的順序不一致)。不能存儲重複值
它沒有新增任何方法，我們使用Collection中的方法就可以操作Set集合了。
|--HashSet(子類)：
注意：Set保證唯一性的方式：先判斷hashCode，如果hashCode一致再判斷equals()
二,LinkedHashSet類
特點：
1.由鏈表保證：有序(取出時跟存入的順序一致)；
2.由哈希表保證元素唯一：
它沒有特有的成員，都是繼承下來的。
三,TreeSet類
1.內部使用"樹"結構：
2."樹"結構，存儲數據的特點：將數據進行排序：
這種排序會先進行比較，比較有兩種方式
使用TreeSet存儲元素，要求元素必須具有"比較的功能"
我們怎麼才能具有比較的功能：
方式一：將我們的類實現：Comparable接口，重寫compareTo()-->自然排序；
方式二：我們的類不用實現任何接口，在實例化TreeSet時，給TreeSet傳遞一個"比較器對象"，這個比較器
對象一定要是：實現Comparator接口，重寫compare()方法
第七講 List接口和Set接口的小結
一,Collection:
|--List:有序的；可以存儲重複值；
|--ArrayList:數組實現。線程不安全的，效率高；
|--Vector:數組實現。線程安全，效率低；
|--LinkedList:鏈表實現。線程不安全，效率高；
|--Set:無序的；不能存儲重複值；
|--HashSet:哈希表實現。線程不安全的，效率高；
判斷重複元素：
利用元素對象的：hashCode()和equals()
兩個方法如果都返回true，那麼就認爲是重複元素，不存儲；
|--LinkedHashSet:鏈表和哈希表實現。線程不安全的，效率高；
利用鏈表保證"有序"；
利用哈希表保證"唯一";
|--TreeSet:二叉樹實現。線程不安全，效率高；
可對元素排序。判斷重複元素，以及對元素排序的方式：
1.自然排序：我們自定義的類必須實現Comparable接口
重寫裏面的compareTo()方法；
2.比較器：我們的類不需要實現任何接口。
在實例化TreeSet時，要爲TreeSet傳遞一個比較器對象，這個對象必須實現Comparator接口
重寫裏面compare()方法；
--比較器優先
第八講 Map接口
一,1.Map接口跟Collection接口沒有關係：
2.Map接口是一個單獨的接口，它使用另外的同Collection完全不同的方式存儲、管理數據；
3.Map集合存儲元素的特點：使用"鍵值對"；
4.之前我們使用Collection集合，存入時，就是簡單的向集合中存儲；
取出時：使用數組、迭代器、List集合中增加了一個帶"索引"的
5.有時候，我們存儲一個對象，會給它"起個名字"，獲取對象時，用這個名字就可以取出這個對象。
這時候，對於我們取出對象，非常的方便；
6.使用Map存儲對象：存儲時，要給對象起個名字，存入時，連名字和對象一起存儲。
名字：鍵(key) 要存儲的對象：值(Value);
二,Map接口的基本方法：
1.添加：
V put(K key,V value)：向集合中添加元素；如果存儲相同的鍵，不同的值，新值會替換舊值，鍵不變；
2.刪除：
V remove(Object key)：根據某個"鍵"，刪除元素；返回被刪除的Value
void clear()：清空集合；
3.判斷：
boolean containsKey(Object key):集合是否包含鍵key，包含返回true，否則返回false
boolean containsValue(Object value):集合是否包含值value，包含返回true,否則返回false
boolean isEmpty():判斷集合是否爲空。
4.獲取
int size()
V get(Object key)
Set<K> keySet()
Collection<V> values()
Set<Map.Entry<K,V>> entrySet()
三,LinkedHashMap類
1.內部使用鏈表結構，和哈希表結構；
2.此Map是有序的；
四,TreeMap類：
1.內部使用紅黑樹結構；
2.樹結構會對內部的"鍵"進行排序：
1).自然排序：類要實現Comparable接口，重寫compareTo()
2).比較器排序：類要實現Comparator接口，重寫compare()方法；
第九講 Collections工具類
一,此類沒有提供能使用的構造方法，內部包含了大量對Collection集合進行操作的一些"靜態方法"；
public static <T> void sort(List<T> list)：根據元素的自然順序 對指定列表按升序進行排序。
public static <T> int binarySearch(List<?> list,T key)：在集合list中查找key，使用二分查找：
參數說明：
list - 要搜索的列表。
key - 要搜索的鍵。
public static <T> T max(Collection<?> coll):根據元素的自然順序，返回給定 collection 的最大元素。
public static void reverse(List<?> list):反轉指定列表中元素的順序。
public static void shuffle(List<?> list):將內部的元素隨機打亂