數組與集合的區別：
Java中的數組是存放同一類型數據的集合。數組可以存放基本數據類型的數據，也可以存放引用數據類型的數據，但數組的長度是固定的。
集合只能存放引用數據類型的數據，不能存放基本數據類型的數據，但集合的數目是可變的。
所有的集合類都存放在java.util包中
List接口是元素有序，可重復的集合，添加自定義類時需要重寫equals()方法
ArrayList集合中，插入一個元素時，列表需要將插入點後面的所有元素向後移動，而在刪除(remove())一個元素時，需要將被刪除元素後面的所有元素向前移動
ArrayList集合允許所有的元素，包括null
例1：ArrayList的一些基本方法
public class ArrayListText{
public static void main(String[] args){
Collection<String> collection=new ArrayList<String>();
List<String> list=new ArrayList<String>();
collection.add("1");
collection.add("2");
collection.add("3");
list.add("A");
list.add("B");
list.add("C");
list.addAll(0,collection);//向指定位置添加一個集合的所有元素
System.out.println("list集合："+list);
List<String> subList=list.subList(1,5);
System.out.println("subList集合："+subList);
System.out.println("設置list集合元素前：："+list.get(3));
list.set(3,"Set");
System.out.println("設置list集合元素後：："+list.get(3));
System.out.println("list集合中，元素3的位置："+list.indexOf("3")+",元素D的位置："+list.indexOf("D"));//獲取指定元素在集合中的索引位置，若不存在則返回-1
String arrString[]=list.toArray(new String[]{});//將集合轉為字符串數組
for(String str:arrString){
System.out.print(str+" ");
}
System.out.println("\nlist集合是否為空："+list.isEmpty());
list.clear();
System.out.println("\nlist集合是否為空："+list.isEmpty());
}
}
結果：
list集合：[1,2,3,A,B,C]
subList集合：[2,3,A,B]
設置list集合元素前：：A
設置list集合元素後：：Set
list集合中，元素3的位置：2，元素D的位置：-1
1 2 3 Set B C
list集合是否為空：false
list集合是否為空：true
將數組轉換為ArrayList集合
String[] str={"W","E","C","O","M","E"};
List<String> list=Arrays.asList(str);
ArrayList<String> arrList=new ArrayList<String>();
arrList.addAll(list);
LinkedList是鏈表類，鏈表結構的優點是便於向集合插入和刪除元素。因為在插入或刪除元素時，不需要移動任何元素，LinkedList也可以存在null元素
獲取表頭的方法：
getFirst()：僅僅是獲取表頭 element()：獲取但不移除此鏈表頭 peek()：獲取但不移除此鏈表頭 poll():獲取並移除此鏈表頭 pop()：獲取並移除此鏈表頭
例2：LinkedList獲取鏈表頭
public class LinkedListText{
public static void main(String[] args){
LinkedList<String> link=new LinkedList<String>();
link.add("1");
link.add("2");
link.add("3");
link.addFirst("F");
link.addLast("L");
LinkedList<String> newLink=new LinkedList<String>(link);
System.out.println("添加元素後：\n\t"+link);
System.out.println("get()方法獲取表頭："+link.getFirst());
System.out.println("使用get()方法後：\n\t"+link);
System.out.println("element()方法獲取表頭："+link.element());
System.out.println("使用element()方法後：\n\t"+link);
System.out.println("peek()方法獲取表頭："+link.peek());
System.out.println("使用peek()方法後：\n\t"+link);
System.out.println("poll()方法獲取表頭："+link.poll());
System.out.println("使用poll()方法後：\n\t"+link);
System.out.println("pop()方法獲取表頭："+link.pop());
System.out.println("使用pop()方法後：\n\t"+link);
System.out.println("******使用鏈表的先進先出*******");
int len=newLink.size();
for(int i=0;i<len;i++){
System.out.print(newLink.poll()+" ");
}
}
}
結果：
添加元素後：
[F,1,2,3,L]
get()方法獲取表頭：F
使用get()方法後：
[F,1,2,3,L]
element()方法獲取表頭：F
使用element()方法後：
[F,1,2,3,L]
peek()方法獲取表頭：F
使用peek()方法後：
[F,1,2,3,L]
poll()方法獲取表頭：F
使用poll()方法後：
[1,2,3,L]
pop()方法獲取表頭：1
使用pop()方法後：
[2,3,L]
*****使用鏈表的先進先出*****
F 1 2 3 L
Set集合是元素無序，不可重復的集合，允許包含null元素，添加自定義類一定要重寫equals()和hashcode()方法
HashSet類可以快速地定位一個元素，但放到HashSet集合中的元素需要重寫equals()和hashcode()方法，而TreeSet集合將放進其中的元素按序存放
HashSet是按哈希算法來存放集合中的元素的，使用哈希算法可以提高存取的效率
HashSet集合的特點：1.不能保證元素的排列順序，集合中元素的順序隨時有可能發生改變 2.集合中最多允許存在一個null元素 3.HashSet集合不是線程同步的
LinkedHashSet插入性能略低於HashSet，但在迭代訪問Set裡的全部元素時有很好的性能，LinkedHashSet()使用鏈表維護了一個添加進集合中的順序，導致當我們遍歷LinkedHashSet集合元素時是按添加進去的順序遍歷的，但不能說明它是有序的！
TreeSet類實現了java.util包中的Set接口和SortedSet接口，TreeSet集合中的元素在默認情況下是升序排序
TreeSet集合的特點：1.向TreeSet中添加的元素必須是同一個類的 2.從小到大遍歷 3.自定義類沒有實現Comparable接口時，當向TreeSet中添加此對象時，報錯
例2：自定義類實現Comparable接口
class Person implements Comparable{
private String name;
private String age;
public Person(){
}
public Person(String name,int age){
this.name=name;
this.age=age;
}
public int compareTo(Person per){
if(this.age>per.age){
return 1;
}else if(this.age<per.age){
return -1;
}else{
return this.name.compareTo(per.name);
}
}
public String toString(){
return ("姓名:"+name+",年齡："+age+"\n");
}
}
public class TreeSetDemo{
public static void main(String[] args){
Set<Person> tset=new TreeSet<Person>();
tset.add(new Person("小強",21));
tset.add(new Person("小偉",23));
tset.add(new Person("小強",21));
tset.add(new Person("小強",21));
tset.add(new Person("小琴",20));
tset.add(new Person("小婷",20));
System.out.println(tset);
}
}
結果：
[姓名：小婷，年齡：20
，姓名：小琴，年齡：20
，姓名：小強，年齡：21
，姓名：小偉，年齡：23
]
集合的輸出：1.Iterator：迭代器輸出（提供遍歷各種集合類型的迭代器） 2.foreach:JDK1.5新增的輸出
迭代刪除：
Iterator<String> it=link.iterator();
while(it.hasNext){
it.next();
it.remove();
}
注釋：在調用remove()方法前需要使用next()方法指定要刪除的元素，否則運行時將產生IllegalStateException異常
Map接口提供的是key-value的映射，其中key不允許重復，每一個key只能映射一個value，常用String類作為Map的鍵
一個key-value對是一個Entry，所有的Entry是用Set存放的，不可重復。key是用Set來存放的，不可重復，value是用Collection存放的，可重復
Map.Entry接口是靜態的，所以可以直接使用”外部類.內部類“的形式調用
HashMap類是實現Map集合，對於元素的添加和刪除有著較高的效率。HashMap類提供所有可選的映射操作，並允許使用null值和null鍵，但必須保證鍵是唯一的，HashMap是非同步的，也不保證映射順序
例3：獲取Map集合中的全部key和value
public class HashMapDemo{
public static void main(String[] arg){
Map<Integer,String> map=new HashMap<Integet,String>();
map.put(1,"清華大學");
map.put(2,"北京大學");
map.put(3,"復旦大學");
map.put(4,"武漢大學");
map.put(5,"中國科技大學");
map.put(6,"中國礦業大學");
Set<Integer> set=map.keySet();
Iterator<Integet> itKey=set.iterator();
System.out.println("Map集合中全部的key：");
while(itKey.hasNext()){
System.out.print(itKey.next()+" ");
}
System.out.println();
Collection<String> c=map.values();
Iterator<String> itValue=c.iterator();
System.out.println("Map集合中全部的value：");
while(itValue.hasNext()){
System.out.print(itValue.next()+" ");
}
}
}
結果：
Map集合中全部的key：
1 2 3 4 5 6
Map集合中全部的value:
清華大學 北京大學 復旦大學 武漢大學 中國科技大學 中國礦工大學
例4：使用Iterator輸出Map集合
public class hashMapDemo{
public static void main(String[] args){
Map<Integer,String> map=new HashMap<Integet,String>();
map.put(1,"清華大學");
map.put(2,"北京大學");
map.put(3,"復旦大學");
map.put(4,"武漢大學");
map.put(5,"中國科技大學");
map.put(6,"中國礦業大學");
Set<Map.Entry<Integer,String>> set=map.entrySet();
Iterator<Map.Entry<Integet,String>> it=set.iterator();
System.out.println("Key--------Value");
while(it.hasNext()){
Map.Entry<Integer,String> mapEntry=it.next();
System.out.println(""+mapEntry.getKey()+"-------"+mapEntry.getValue());
}
}
}
結果：
key------value
1-----清華大學
2-----北京大學
3-----復旦大學
4-----武漢大學
5-----中國科技大學
6-----中國礦業大學
使用foreach輸出：
for(Map.Entry<Integet,String> mapEntry:map.entryKey()){
System.out.println(""+mapEntry.getKey()+"-------"+mapEntry.getValue());
}
TreeMap類不但實現了Map接口，還實現了SortedMap接口，因此，TreeMap集合中的映射關系具有一定的順序性。與HashMap相比，TreeMap集合對元素的添加、刪除和定位映射性能較低
Collections類可以對集合的元素進行排序、反序、去極值、循環移位、查詢和修改等功能，還可以將集合對象設置不可變、對集合對象實現同步控制等方法。
Collections類所提供的方法均為靜態方法，可以直接通過“類名.方法()"的形式調用
Collections常用方法:addAll(Collection c,T...elements)--Collections.addAll(list,"1","2","3") binarySearch(List list,T key)-使用此方法前必須先使用sort(List list,Comparator c)方法進行排序 copy(List dest,List src)//將src集合中的所有元素復制到dest集合中 fill(List list,T obj)//使用指定元素替換指定集合中的所有元素 max(Collection coll) max(Collection coll,Comparator c) replaceAll(List list,T oldVal,T newVal)//使用另一個元素替代集合中指定的所有元素 reverse(List list)
Stack-棧是一種特殊的線性表，它僅限於在表尾進行元素的添加與刪除操作。棧的表尾成為棧頂，表頭成為棧底。棧是采用“先進後出”的數據存儲方式，若棧中沒有任何元素，則成為空棧。棧是Vector的子類
empty()//判斷該棧是否為空，若為空返回true peek()//獲取棧頂元素，但不刪除它 pop()//獲取棧頂元素，並刪除它 push()//將元素添加到棧頂中 search()、、查找指定元素在棧中位置，起始位置為1，不是0
Hashtable類是Map的子類，是JDK1.0是出現的，Hashtable類是同步的，線程安全的，不允許存放null鍵和null值，其他功能與HashMap類似
