集合基礎

集合類的由來：
JAVA是面向對象的，對象用來封裝特有數據，對象多了就須要儲存起來，當對象的個數不肯定的時候，那麼就用集合容器進行存儲。

集合的特色：
　　1.集合的長度是可變的

　　2.用於存儲對象的容器

　　3.不能夠存儲基本數據類型

體系：
　　集合容器由於內部的數據結構不一樣，有多種具體容器，不斷的向上提取，造成了集合框架。

Collection接口：
　　常見的方法

　　1.增長

1
2
boolean add（Object obj）//添加一個對象
boolean addAll（Collection coll）//添加一個集合
　　2.刪除

1
2
3
boolean remove(Object Obj)//刪除一個對象
boolean removeAll(Collection coll)刪除集合中全部與coll相同的對象
void clear()清空
　　3.判斷

1
2
3
boolean contains(Object Obj)//判斷一個對象是否存在
boolean containsAll(Collection coll)//判斷集合中是否擁有coll總的全部對象
boolean isEmpty()//奇怪的很，沒有元素返回true
　　4.獲取

int size()//獲取對象的個數
Iterator iterator()//獲取對象，下面的代碼是這個方法的實現
Iterator接口

　　對集合進行迭代迭代器

　　這個接口是對全部的Collection容器進行元素獲取的公共接口

　　hasNext（）若是next仍然有元素能夠迭代，就返回true

　　next（）返回迭代的下一個元素

方法一：

1
2
3
4
Iterator it = coll.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
方法二：節約空間，經常使用

1
2
3
for(Iterator it = coll.iterator();it.hasNext();){
System.out.println(it.next());
}
這種迭代的獲取與直接打印( print(coll) )的區別在於，打印的是一串字符串，而迭代取得是單獨的對象，能夠對他們單獨處理

　　5.其餘

1
2
boolean retainAll（Collection coll）//取交集，刪除與coll集合中不一樣的元素
Object toArray()//將集合轉成數組
List:
　　1.有序（存入和取出順序一致）

　　2.元素都有索引（腳標）

　　3.元素能夠重複

經常使用子類：

　　1.Vector：內部是數組數據結構，同步的，增刪查詢都很慢。（基本淘汰）

　　2.ArrayList:內部是數組數據結構，不一樣步的，代替了Vector。查詢很快

　　3.LinkedList:內部是鏈表數據結構的，不一樣步的。增刪很快

常見的方法：

　　1.添加

1
2
void add(index,element)//在指定的位置插入對象
void add(index,collection)//在指定的位置插入集合
　　2.刪除

1
Object remove(index)//刪除指定位置的對象，返回值爲被刪除的對象
　　3.修改（只有List才具備增刪改查，collection都不具有）

1
Object set(index,element)//返回值爲被修改的對象，即修改前的對象
　　4.獲取

1
2
Object get(index)//返回值爲獲取的對象
List subList(from,to)//返回指定範圍的對象<br>int indexOf(Object)//返回對象的位置，從頭開始找<br>int lastIndexOf(Object)//返回對象的位置，從尾開始找
　　

list特有的取出元素的方法（只有list有set不具有）：

1
2
3
for(int x=0;x<list.size();x++){
System.out.println(list.get(x));
}
　　

ListIterator:
　　1.Iterator的子接口

　　2.能夠實如今迭代過程當中完成對元素的操做（增刪改查）注意：只有List集合具有該迭代功能

若是有下面的代碼（在迭代的過程當中，增長元素）

1
2
3
4
5
6
7
8
9
Iterator it =list.iterator();
while(it.hasNext()){
Object obj=it.next();
if(obj=="b"){
list.add("e");
}else{
System.out.println(obj);
}
}
　　這裏會發生異常，緣由是在迭代的過程當中，操做集合，產生了併發。

解決問題：

　　1.在迭代的時候不能操做集合，容易產生異常

　　2.使用ListIterator接口來完成在迭代過程當中對元素的更多的操做

1
2
3
4
5
6
7
8
9
10
11
12
13
ListIterator it = list.listIterator();//獲取列表迭代器對象
while(it.hasNext()){
Object obj=it.next();
if(obj=="b"){
it.add("e");
System.out.println(obj);
}else{
System.out.println(obj);
}
}
while(it.hasPrevious()){//若是前一個任然有元素能夠迭代，那麼就返回true
System.out.println(it.previous());//返回前一個元素
}
　　

Vector：
​ 　　Enumeration：

　　　　​ 1.這個接口淘汰了，基本不用

​ 　　　　2.這個接口的功能與Iterator接口的功能是重複來的

​ 　　　　3.Iterator接口添加了一個可選的移除操做，而且使用了較短的方法名。

　　​ 　　4.新的實現應該考慮優先使用Iterator接口而不是Eumeration接口

​ 　　　　elements:這個方法與List中的iterator方法有殊途同歸之妙

1
2
3
4
5
6
7
8
9
10
11
12
13
Vector ve=new Vector();
ve.addElement("a");
ve.addElement("b");
ve.addElement("c");
Enumeration em=ve.elements();
while(em.hasMoreElements()){
System.out.println(em.nextElement());
}
Iterator it=ve.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
//這兩個方法的做用基本同樣，可是前一種基本上是淘汰了
LinkedList:
​ 　　1.內部是鏈表數據結構，是不一樣步的，增刪很快

​　　 2.堆棧：先進後出

​ 　　 隊列：先進先出

​ 　　3.經常使用方法

​ 　　　　增長：

　　　　　　​ boolean add（ Collection<? extends E> c）//在結尾添加一個元素

​ 　　　　　　boolean addAll（int index, Collection<? extends E> c）//在指定位置插入一個集合

​ 　　　　　　void addFirst（E o）//在開頭加入一個元素

　　　　　　​ void addLast（E o）//在結尾加入一個元素

​ 　　　　刪除：

　　　　　　​ void clear()

​　　　　　　 E remove()

​ 　　　　獲取:

　　　　　　​ E getFirst()

​ 　　　　　　E peek();

​ 　　　　修改：

​ 　　　　　　Object set(index,Objcet)

ArrayList:
下面的代碼中的強轉問題，可能會涉及到自動裝箱問題，在這裏也是可使用的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
ArrayList ar=new ArrayList();
Person a=new Person(19,"lao1");
Person b=new Person(16,"lao2");
Person c=new Person(11,"lao3");
ar.add(a);
ar.add(b);
ar.add(c);
for(Iterator it=ar.iterator();it.hasNext();){
//System.out.println(((Person)it.next()).getAge()+((Person)it.next()).getName());
//輸出確定是有問題的一直在next
//因此解決方法以下
Person d=(Person) it.next();//強轉的緣由是，在Aar.add()添加的時候，是使用Object接收的，因此person已經變成了上帝
System.out.println(d.getAge()+d.getName());
}
Set:
​ 　　1.Set接口中的方法和Collection一致

　　​ 2.Set獲取元素的方法只有迭代器

​　　 3.經常使用實現子類HashSet，TreeSet

​ 　　4.元素不可重複，無序（可是能夠作到有限的有序）

HashSet:
　　​ 1.內部數據結構是哈希表，不一樣步

　　​ 2.如何保證該集合的元素惟一性呢？

​ 　　　　a.經過對象的hashCode和equals方法來完成對象的惟一性

​　　　　 b.若是對象的hashCode值不一樣，那麼不用判斷equals方法，直接存儲到嘻哈表中（int hashCode();boolean equals(Object obj)）

​ 　　　　c.若是對象的hashCode值相同，那麼要再次判斷對象的equals方法是否爲true，true則視爲相同元素，不存。

​ 　　　　d.重點：若是元素要存儲到HashSet集合中，必須覆蓋hashCode方法和equals方法；通常狀況下若是定義的類會產生不少對象，好比人，學生，書，一般都須要覆蓋這兩個方法，創建對象判斷是否相同的依據。

​ 　　　　e.擴展：Arraylist（若是要確保元素惟一的話）判斷的依據是equals，而HashSet判斷hashcode和equals

​

LinkedHashSet:
　　1.HashSet的直接已知實現子類

​ 　 2.能夠在惟一的狀況下排序，怎麼進就怎麼出

1
2
3
4
5
6
7
8
HashSet/LinkedHashSet ha=new LinkedHashSet();
ha.add("a");
ha.add("d");
ha.add("s");
for(Iterator it=ha.iterator();it.hasNext();){
System.out.println(it.next());
}
//因此須要有序惟一的話能夠直接使用LinkedHashSet類
TreeSet：
​　　 1.能夠對set集合中的元素排序。是不一樣步的

​ 　　2.判斷元素惟一性的方式：就是根據比較方法返回結果是否爲0，若是爲0，就是相同元素，則不存儲（因此要實現Comparable接口，覆蓋compareTo方法元素和集合實現均可以；通常在作這一步的時候，也一塊兒把排序給作了）

​ 　　3.排序的兩種方法

​ 　　　　a.讓元素自身具有比較功能

​ 　　　　b.讓集合自身具有比較功能（1.若是不按照對象具有的天然順序排序2.對象不具有天然順序；這兩種狀況時使用該功能）

​ 　　4.比較器（即b）

​　　　　 定義一個類實現Comparator接口，覆蓋compare方法，將該類對象最爲參數傳遞給TreeSet集合的構造函數

12345678910111213141516171819202122//比較器，按照名字class ComparatorByName implements Comparator {public int compare(Object o1, Object o2) {Person p1 = (Person)o1;Person p2 = (Person)o2;int temp = p1.getName().compareTo(p2.getName()); return temp==0?p1.getAge()-p2.getAge(): temp;}}​//比較器，按照年齡class ComparatorByLength implements Comparator {public int compare(Object o1, Object o2) {Person s1 = (Person)o1;Person s2 = (Person)o2;int temp = s1.getAge()-s2.getAge();return temp==0? s1.compareTo(s2): temp;}​}TreeSet tr=new TreeSet(new ComparatorByLength());//比較器的使用方法Person a=new Person("lao3",11); 歡迎工做一到五年的Java工程師朋友們加入Java羣： 741514154羣內提供免費的Java架構學習資料（裏面有高可用、高併發、高性能及分佈式、Jvm性能調優、Spring源碼，MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多個知識點的架構資料）合理利用本身每一分每一秒的時間來學習提高本身，不要再用"沒有時間「來掩飾本身思想上的懶惰！趁年輕，使勁拼，給將來的本身一個交代！