javaAPI 集合

Collection接口：

說出ArrayList,Vector, LinkedList的存儲性能和特性
ArrayList和Vector都是使用數組方式存儲數據，此數組元素數大於實際存儲的數據以便增加和插入元素，它們都允許直接按序號索引元素，但是插入元素要涉及數組元素移動等內存操作，所以索引數據快而插入數據慢，Vector由於使用了synchronized方法（線程安全），通常性能上較ArrayList差，而LinkedList使用雙向鏈表實現存儲，按序號索引數據需要進行前向或後向遍歷，但是插入數據時只需要記錄本項的前後項即可，所以插入速度較快。

List, Set, Map是否繼承自Collection接口?
      List，Set是，Map不是

測試addAll與containsAll：

import java.util.ArrayList;
import java.util.Collection;

public class testAddAllandContaintsAll {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Collection c1 = new ArrayList<String>();
		c1.add("java");
		c1.add("C++");
		c1.add("php");
		System.out.println(c1);
		Collection c2 = new ArrayList<String>();
		c2.addAll(c1);
		System.out.println(c2);
		Collection c3 = new ArrayList<String>();
		c3.add("java");
		c3.add("php");
		System.out.println(c1.containsAll(c3));  //true
	}

}

使用Iterator的hasNext方法，next方法遍歷集合，還有remove刪除：

import java.util.ArrayList;  
import java.util.Collection;  
import java.util.Iterator;  
  
/** 
 * iterator用法演示代碼 
 * @author 小宇 
 */  
public class IteratorDemo {  
  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        Collection<String> col = new ArrayList<String>();  
        col.add("令狐沖");  
        col.add("乃是");  
        col.add("豪傑之士");  
        //返回Iterator接口實現  
        Iterator<String> iter = col.iterator();  
        System.out.println("刪除: 乃是");  
        while(iter.hasNext())  
        {  
            String s = iter.next();  
            System.out.print(s);  
            if(s == "乃是")  
                iter.remove();  
        }  
        System.out.println();  
        Object[] ss = col.toArray();  
        System.out.println("刪除之後的內容");  
        for(int i = 0; i <ss.length;i++ )  
            System.out.print(ss[i]);  
    }  
}  

新的循環方法：

import java.util.ArrayList;
import java.util.Collection;

public class XinXunhuan {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Collection<String> c = new ArrayList<String>();
		c.add("sb張磊");
		c.add("2b林卓俊");
		c.add("都是傻逼");
		for(String str:c){
			System.out.println(str);
		}
	}

}

Collection與Collections的區別：
           Collection是集合類的上級接口，繼承與他的接口主要有Set 和List。
           Collections是針對集合類的一個幫助類，他提供一系列靜態方法實現對各種集合的搜索、排序、線程安全化等操作。

List接口：

包括get(),set(),插入，移除，subList(),數組與list的轉換

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class testList {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<String> list = new ArrayList<String>();
		list.add("古德里安");
		list.add("鄧尼茨");
		list.add("曼施坦因");
		list.add("隆美爾");
		
		//get方法遍歷list
		for(int i = 0; i < list.size(); i++){
			System.out.println(list.get(i).toUpperCase());
		}
		
		String value = list.set(1, "元首");
		System.out.println(value);
		System.out.println(list);
		
		//交換一和三上的元素
		list.set(1,list.set(3, list.get(1)));
	    System.out.println(list);	
	    
		//插入和移除數據
	    list.add(2,"阿道夫");
	    System.out.println(list);	
	    
	    list.remove(2);
	    System.out.println(list);
	    
	    //subList
	    List<String> subList = list.subList(2, 4);
	    System.out.println(subList);	
	    
	    //將list轉換爲數組
	    String[] strArr = list.toArray(new String[]{});
	    System.out.println(Arrays.toString(strArr));
	    
	    //將數組轉換爲List
	    String[] strArr0 = {"a","b","c"};
	    List<String> list0 = Arrays.asList(strArr0);
	    System.out.println(list0);
	}

}

Collections.sort()實現排序：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class testSort {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		List<Integer> list = new ArrayList<Integer>();
		Random r = new Random(1);
		for(int i = 0; i < 10; i++){
			list.add(r.nextInt(100));
		}
		System.out.println(list);
		Collections.sort(list);
		System.out.println(list);
	}

}

Comparator設置比較條件可以給對象元素排序

Queue：

import java.util.LinkedList;
import java.util.Queue;

public class testQueue {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Queue<String> queue = new LinkedList<String>();
		queue.offer("a");
		queue.offer("b");
		queue.offer("c");
		System.out.println(queue	);
		
		String str = queue.peek();
		System.out.println(str);
		
		while(queue.size() > 0){
			
			str= queue.poll();
			System.out.println(str +"  ");
		}
	}

}

Deque:

import java.util.Deque;
import java.util.LinkedList;

public class testStack {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Deque<String> stack = new LinkedList<String>();
		stack.push("a");
		stack.push("b");
		stack.push("c");
		System.out.println(stack);
		
		String str = stack.peek();
		System.out.println(str);//c
		
		while(stack.size() > 0){
			str = stack.pop();
			System.out.print(str  + "  ");
		}
	}

}

Map:

put():

get():

containsKey():

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class testHashMap 
{
	public static void main(String[] args)
	{
		String str = "ab=43,de=56,er=8,yu=12,sd=35";
		String[] arr = str.split("[,=]");
		Map<String,Integer> map = new HashMap<String,Integer>();
		for(int i = 0; i < arr.length; i += 2)
		{
			if(!map.containsKey(arr[i]) || 
					Integer.parseInt(arr[i + 1]) > map.get(arr[i]))
			{
				map.put(arr[i], Integer.parseInt(arr[i + 1]));
			}
		}
		System.out.println(map);
		
		//使用迭代key的方式遍歷集合map
		Set<String> keys = map.keySet();
		for(String key:keys)
		{
			System.out.println(key + ":" + map.get(key));
		}
	}
}

Hashtable與HashMap區別：

第一個不同主要是歷史原因。Hashtable是基於陳舊的Dictionary類的，HashMap是Java 1.2引進的Map接口的一個實現。


也許最重要的不同是Hashtable的方法是同步的，而HashMap的方法不是。這就意味着，雖然你可以不用採取任何特殊的行爲就可以在一個多線程的應用程序中用一個Hashtable，但你必須同樣地爲一個HashMap提供外同步。一個方便的方法就是利用Collections類的靜態的synchronizedMap()方法，它創建一個線程安全的Map對象，並把它作爲一個封裝的對象來返回。這個對象的方法可以讓你同步訪問潛在的HashMap。這麼做的結果就是當你不需要同步時，你不能切斷Hashtable中的同步（比如在一個單線程的應用程序中），而且同步增加了很多處理費用。


第三點不同是，只有HashMap可以讓你將空值作爲一個表的條目的key或value。HashMap中只有一條記錄可以是一個空的key，但任意數量的條目可以是空的value。這就是說，如果在表中沒有發現搜索鍵，或者如果發現了搜索鍵，但它是一個空的值，那麼get()將返回null。如果有必要，用containKey()方法來區別這兩種情況。