JAVA容器學習總結
一: 1圖
ＪＡＶＡ容器API圖
圖
二: 6接口
1/6 : Collection接口
１：Collection接口常用方法
１）boolean add(E o) add(Object o)
<1> 確保此 collection 包含指定的元素（可選操作）。如果此 collection 隨調用的結果而發生改變，則返回true。（如果此 collection 不允許有重複元素，並且已經包含了指定的元素，則返回false。）
<2> 支持此操作的 collection 可以限制哪些元素能添加到此 collection 中來。需要特別指出的是，一些 collection 拒絕添加null元素，其他一些 collection 將對可以添加的元素類型強加限制。Collection 類應該在其文檔中清楚地指定能添加哪些元素方面的所有限制。
<3>如果 collection 由於某些原因（已經包含該元素的原因除外）拒絕添加特定的元素，那麼它必須拋出一個異常（而不是返回false）。這確保了在此調用返回後，collection 總是包含指定的元素。
<4>拋出：
UnsupportedOperationException - 此 collection 不支持 add 操作。
ClassCastException - 指定元素的類不允許它添加到此 collection 中。
NullPointerException - 如果指定的元素爲 null，並且此 collection 不支持 null 元素。
IllegalArgumentException - 此元素的某方面不允許它添加到此 collection 中。
２）boolean addAll(Collection<? extends E> c)
<1> 將指定 collection 中的所有元素都添加到此 collection 中（可選操作）。如果在進行此操作的同時修改指定的 collection，那麼此操作行爲是不明確的。（這意味着如果指定的 collection 是此 collection，並且此 collection 爲非空，那麼此調用的行爲是不明確的。）
<2>參數： c - 要插入到此 collection 的元素。
<3>返回：如果此 collection 隨調用的結果而發生改變，則返回 true
<4>拋出的異常與add(Object)方法相似
３） void clear() 移除此 collection 中的所有元素（可選操作）。此方法返回後，除非拋出一個異常，否則 collection 將爲空。
拋出： UnsupportedOperationException - 如果此 collection 不支持 clear 方法。
4) boolean contains(Object o)
如果此 collection 包含指定的元素，則返回true。更正式地說，當且僅當此 collection 至少包含一個滿足(o==null ? e==null : o.equals(e))的元素e時才返回true。
拋出：
ClassCastException - 如果指定元素的類型與此 collection 不兼容（可選）。
NullPointerException - 如果指定的元素爲 null，並且此 collection 不支持 null 元素（可選）。
5) boolean containsAll(Collection<?> c)
如果此 collection 包含指定 collection 中的所有元素，則返回true。
拋出：
ClassCastException - 如果指定 collection 中有一個或多個元素的類型與此 collection 不兼容（可選）。
NullPointerException - 如果指定 collection 包含一個或多個 null 元素，並且此 collection 不支持 null 元素（可選）。
NullPointerException - 如果指定的 collection 爲 null。
6) boolean isEmpty()
如果此 collection 不包含元素，則返回 true。
7) Iterator<E> iterator()
返回在此 collection 的元素上進行迭代的迭代器。關於元素返回的順序沒有任何保證（除非此 collection 是某個能提供保證順序的類實例）。
8) boolean remove(Object o)
從此 collection 中移除指定元素的單個實例，如果存在的話（可選操作）。更正式地說，如果此 collection 包含一個或多個滿足 (o==null ? e==null : o.equals(e)) 的元素 e，則移除這樣的元素。如果此 collection 包含指定的元素（或者此 collection 隨調用的結果而發生改變），則返回 true。
9) int size()
返回此 collection 中的元素數。如果此 collection 包含多個 Integer.MAX_VALUE 元素，則返回 Integer.MAX_VALUE。
10) Object[] toArray()
返回包含此 collection 中所有元素的數組。如果 collection 對其迭代器返回的元素順序做出了某些保證，那麼此方法必須以相同的順序返回這些元素。
(11) boolean removeAll(Collection<?> c) <相減>
移除此 collection 中那些也包含在指定 collection 中的所有元素（可選操作）。此調用返回後，collection 中將不包含任何與指定 collection 相同的元素。
(12) boolean retainAll(Collection<?> c) <交集>
僅保留此 collection 中那些也包含在指定 collection 的元素（可選操作）。換句話說，移除此 collection 中未包含在指定 collection 中的所有元素。
簡單測試實例:
package zyq.collection;
import java.util.ArrayList;
import java.util.Collection;
/**
*JAVA容器測試
*@authorAdministrator
*
*/
publicclass JavaCollectionTest {
publicstaticvoid main(String[] args) {
Collection<User> c = new ArrayList<User>();
User user = new User("zyq");
User wife = new User("123");
user.setWife(wife);
c.add(user);
User user3 = new User("zyq");
// 因爲User類中hashCode()方法的實現是return name.hashCode();所以當user3的name值爲zzz時不能remove掉該元素
// User user3 = new User("zzz");
user3.setWife(wife);
// user3.serWife(user);
c.remove(user3);
System.out.println(c);
}
}
class User {
String name;
User wife;
public User(String name) {
super();
this.name = name;
}
public User getWife() {
returnwife;
}
publicvoid setWife(User wife) {
this.wife = wife;
}
/*
* 注意在JAVA容器中要判斷兩個容器是否相等必須重寫hashCode()和equals()方法
* (non-Javadoc)
* @see java.lang.Object#hashCode()
*/
publicint hashCode() {
returnname.hashCode();
}
/*
* (non-Javadoc)
* @see java.lang.Object#equals(java.lang.Object)
*/
publicboolean equals(Object obj) {
if (this == obj)
returntrue;
if (obj == null)
returnfalse;
if (getClass() != obj.getClass())
returnfalse;
User other = (User) obj;
if (name == null) {
if (other.name != null)
returnfalse;
} elseif (!name.equals(other.name))
returnfalse;
if (wife == null) {
if (other.wife != null)
returnfalse;
} elseif (!wife.equals(other.wife))
returnfalse;
returntrue;
}
}
注意: 容器類對象調用remove和contains方法時,需要比較兩個對象是否相等,這時會涉及到對象類型的equals方法和hashCode方法,對於自定義的類型,需要重寫equals方法和
hashCode方法以定義自定義的對象的相等規則.
附: 相等的對象應具有相等的hashCode
2/6: Iterator接口 : 對集合進行迭代的迭代器
所有實現了Collection接口的類都有一個iterator()方法用以返回一個實現了Iterator接口的對象 .
Iterator接口的常用方法:
<1>boolean hasNext()
如果仍有元素可以迭代，則返回 true
<2>E next()
返回迭代的下一個元素。重複調用此方法直到 hasNext() 方法返回 false，這將精確地一次性返回迭代器指向的集合中的所有元素。
<3>void remove()
從迭代器指向的集合中移除迭代器返回的最後一個元素（可選操作）。每次調用 next 只能調用一次此方法。如果進行迭代時用調用此方法之外的其他方式修改了該迭代器所指向的集合，則迭代器的行爲是不明確的。
測試實例:
package zyq.collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
*Java中Iterator接口的測試
*@authorAdministrator
*
*/
publicclass JavaIteratorTest {
publicstaticvoid main(String[] args) {
Collection<Person> c = new ArrayList<Person>();
c.add(new Person("p1"));
c.add(new Person("p2"));
c.add(new Person("p3"));
c.add(new Person("p4"));
c.add(new Person("p5"));
//使用Iterator接口遍歷
for(Iterator<Person> iter = c.iterator() ; iter.hasNext();){
System.out.println(iter.next().name);
}
}
}
class Person{
String name;
Person wife;
public Person(String name) {
this.name = name;
}
}
3/6: Set接口 : 一個不包含重複元素的 collection
Set接口是Collection接口的子接口,Set接口沒有提供額外的方法,但實現Set接口的實現類中儲存的元素是沒有順序的,而且不可以重複
Set容器可以與數學中”集合”的概念相對應.
Set接口的已知實現類HashSet和TreeSet等
簡單示例:
package zyq.collection;
import java.util.HashSet;
import java.util.Set;
/**
*JAVA中Set接口簡單測試
*@authorAdministrator
*
*/
publicclass JavaSetTest {
publicstaticvoid main(String[] args) {
Set<String> s1 = new HashSet<String>();
Set<String> s2 = new HashSet<String>();
s1.add("a"); s1.add("d"); s1.add("c"); s1.add("b");
s2.add("a"); s2.add("e"); s2.add("c"); s2.add("f");
Set<String> s3 = new HashSet<String>(s1);
Set<String> s4 = new HashSet<String>(s2);
s3.removeAll(s2); //將s3中出現在s2中的所有元素移除
System.out.println(s3);
s4.retainAll(s1); //將既在s1中存在又在s4中存在的元素作爲s4的元素
System.out.println(s4);
//addAll()方法略(求並集)
}
}
4/6: List接口: 有序的 collection（也稱爲序列）。此接口的用戶可以對列表中每個元素的插入位置進行精確地控制。用戶可以根據元素的整數索引（在列表中的位置）訪問元素，並搜索列表中的元素。
與 set 不同，列表通常允許重複的元素.
List接口常用方法:
<1>E get(int index)
返回列表中指定位置的元素。
<2>E set(int index,
E element)
用指定元素替換列表中指定位置的元素（
拋出：
UnsupportedOperationException - 如果列表不支持 set 方法。
ClassCastException - 如果指定元素的類不允許它添加到此列表。
NullPointerException - 如果指定的元素爲 null，並且此列表不支持 null 元素。
IllegalArgumentException - 如果指定元素的某個方面不允許它添加到此列表。
IndexOutOfBoundsException - 如果索引超出範圍 (index < 0 || index >= size())。
<3>void add(int index,
E element)
在列表的指定位置插入指定元素（可選操作）。將當前處於該位置的元素（如果有的話）和所有後續元素向右移動（在其索引中加 1）。
<4>E remove(int index)
移除列表中指定位置的元素（可選操作）。將所有的後續元素向左移動（將其索引減 1）。返回從列表中移除的元素。
參數：
<5>int indexOf(Object o)
返回列表中首次出現指定元素的索引，如果列表不包含此元素，則返回 -1。更正式地說，返回滿足下面條件的最低索引 i：(o==null ? get(i)==null :o.equals(get(i)))，如果沒有這樣的索引，則返回 -1。
<6>int lastIndexOf(Object o)
返回列表中最後出現指定元素的索引，如果列表不包含此元素，則返回 -1。更正式地說，返回滿足下面條件的最高索引 i：(o==null ? get(i)==null :o.equals(get(i)))，如果沒有這樣的索引，則返回 -1。
<7>List<E> subList(int fromIndex,
int toIndex)
返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之間的部分視圖。（如果 fromIndex 和 toIndex 相等，則返回的列表爲空）。返回的列表由此列表支持，因此返回列表中的非結構性更改將反映在此列表中，反之亦然。返回的列表支持此列表支持的所有可選列表操作。
此方法省去了顯式範圍操作（此操作通常針對數組存在）。通過傳遞 subList 視圖而非整個列表，期望列表的任何操作可用作範圍操作。例如，下面的語句從列表中移除了元素的範圍：
list.subList(from, to).clear();
可以對 indexOf 和 lastIndexOf 構造類似的語句，而且 Collections 類中的所有算法都可以應用於 subList。
如果支持列表（即此列表）通過任何其他方式（而不是通過返回的列表）從結構上修改，則此方法返回的列表語義將變爲未定義（從結構上修改是指更改列表的大小，或者以其他方式打亂列表，使正在進行的迭代產生錯誤的結果）。
List底層是利用鏈表實現的.
簡單示例:
package zyq.collection;
import java.util.ArrayList;
import java.util.List;
/**
*Java中List接口的簡單測試
*@authorZYQ
*
*/
publicclass JavaListTest {
publicstaticvoid main(String[] args) {
List<String> list = new ArrayList<String>();
for(int i=0; i<10; i++){
list.add("zyq" + (i+1));
}
System.out.println(list.get(4));
list.set(4, "zzz4");
System.out.println(list);
list.add(4, "zyq4");
System.out.println(list);
list.remove(5);
System.out.println(list.indexOf("zzz4"));
}
}
//輸出結果
zyq5
[zyq1, zyq2, zyq3, zyq4, zzz4, zyq6, zyq7, zyq8, zyq9, zyq10]
[zyq1, zyq2, zyq3, zyq4, zyq4, zzz4, zyq6, zyq7, zyq8, zyq9, zyq10]
-1
5/6: Comparable接口
此接口強行對實現它的每個類的對象進行整體排序。此排序被稱爲該類的自然排序，類的compareTo方法被稱爲它的自然比較方法。
int compareTo(T o)
比較此對象與指定對象的順序。如果該對象小於、等於或大於指定對象，則分別返回負整數、零或正整數。
6/6: Map接口 : 實現Map接口的類用來存儲鍵-值對
將鍵映射到值的對象。一個映射不能包含重複的鍵；每個鍵最多隻能映射一個值。
常用方法:
<1>void clear()
從此映射中移除所有映射關係（可選操作）。
<2>keySet
Set<K> keySet()
返回此映射中包含的鍵的 set 視圖。該 set 受映射支持，所以對映射的改變可在此 set 中反映出來，反之亦然。如果修改映射的同時正在對該 set 進行迭代（除了通過迭代器自己的remove操作外），則迭代結果是不明確的。set 支持通過Iterator.remove、Set.remove、removeAllretainAll和clear操作實現元素移除，即從映射中移除相應的映射關係。它不支持 add 或addAll操作。
<3>entrySet
Set<Map.Entry<K,V>> entrySet()
返回此映射中包含的映射關係的 set 視圖。返回的 set 中的每個元素都是一個Map.Entry。該 set 受映射支持，所以對映射的改變可在此 set 中反映出來，反之亦然。如果修改映射的同時正在對該 set 進行迭代（除了通過迭代器自己的remove操作，或者通過在迭代器返回的映射項上執行setValue操作外），則迭代結果是不明確的。set 支持通過Iterator.remove、Set.remove、removeAll、retainAll和clear操作實現元素移除，即從映射中移除相應的映射關係。它不支持add或addAll操作。
<4>values
Collection<V> values()
返回此映射中包含的值的 collection 視圖。該 collection 受映射支持，所以對映射的改變可在此 collection 中反映出來，反之亦然。如果修改映射的同時正在對該 collection 進行迭代（除了通過迭代器自己的remove操作外），則迭代結果是不明確的。collection 支持通過Iterator.remove、Collection.remove、removeAll、retainAll和clear操作實現元素移除，即從映射中移除相應的映射關係。它不支持 add 或addAll操作。
<5>remove
V remove(Object key)
如果存在此鍵的映射關係，則將其從映射中移除（可選操作）。更正式地說，如果此映射包含滿足以下從鍵k到值v的映射關係：(key==null ? k==null :key.equals(k))，則移除該映射關係（該映射最多隻能包含一個這樣的映射關係）。
返回此映射中以前映射該鍵的值，如果此映射不包含該鍵的映射關係，則返回 null（如果該實現支持 null 值，則返回 null 也可表明此映射以前將 null 與指定鍵相關聯）。一旦調用返回，則此映射不包含指定鍵的映射關係。
<6>put
V put(K key,
V value)
將指定的值與此映射中的指定鍵相關聯（可選操作）。如果此映射中以前包含一個該鍵的映射關係，則用指定值替換舊值（當且僅當m.containsKey(k)返回true時，才能說映射m包含鍵k的映射關係）。
參數：
key - 與指定值相關聯的鍵。
value - 與指定鍵相關聯的值。
返回：
以前與指定鍵相關聯的值，如果沒有該鍵的映射關係，則返回null。如果該實現支持null值，則返回null也可表明此映射以前將null與指定鍵相關聯。
<7>get
V get(Object key)
返回此映射中映射到指定鍵的值。如果此映射中沒有該鍵的映射關係，則返回null。返回null值並非一定表明此映射不包含該鍵的映射關係；也可能此映射將該鍵顯示地映射到null。可使用containsKey操作來區分這兩種情況。
更正式地說，如果此映射包含滿足以下從鍵 k 到值 v 的映射關係：(key==null ? k==null :key.equals(k))，則此方法返回 v；否則返回 null（最多只能有一個這樣的映射關係）。
參數：
key - 要返回其相關值的鍵。
返回：
此映射中映射到指定值的鍵，如果此映射不包含該鍵的映射關係，則返回null。
<8>isEmpty
boolean isEmpty()
如果此映射未包含鍵-值映射關係，則返回true。
<9> size
int size()
返回此映射中的鍵-值映射關係數。如果該映射包含多個Integer.MAX_VALUE元素，則返回Integer.MAX_VALUE。
三: 2類
1/2: java.util.Collections
常用靜態方法:
<1>public static <T> int binarySearch(List<? extends Comparable<? super T>> list 使用二進制搜索算法來搜索指定列表，以獲得指定對象。在進行此調用之前，必須根據列表元素的自然順序 對列表進行升序排序（通過上面的 sort(List) 方法）。如果沒有對列表進行排序，則結果是不明確的。如果列表包含多個等於指定對象的元素，則無法保證找到的是哪一個。
返回：
如果搜索鍵包含在列表中，則返回搜索鍵的索引；否則返回 (-(插入點) - 1)。插入點 被定義爲將鍵插入列表的那一點：即第一個大於此鍵的元素索引，如果列表中的所有元素都小於指定的鍵，則爲 list.size()。注意，這保證了當且僅當此鍵被找到時，返回的值將 >= 0。
<2>public static void sort(List<T> list)
<3>public static void reverse(List<?> list)
反轉指定列表中元素的順序。
<4>等等………
*如何選擇數據結構:
衡量標準:讀的效率和改的效率
Array讀快改慢
Linked改快讀慢
Hash兩者之間
