Collection c = new ArrayList();

         * boolean add(E e)
         * 將當前集合中添加給定的元素
         * 若成功添加則返回true
         c.add("one");
         c.add("two");

        
         * int size()
         * 獲取當前集合中的元素個數
         c.size();
        
         * boolean isEmpty()
         * 判斷當前集合是否不包含任何元素
         
 
* 當集合中沒有元素時返回true
         boolean isEmpty = c.isEmpty();
        
         * void clear()
         * 清空集合元素
     c.clear();
    
    
         * boolean contains(E e)
         * 判斷當前集合是否包含給定元素，包含則返回true
         * 判斷依據是看給定的元素與集合中現有的元素是否
         * 存在equals比較為true的，有則認為包含!
         boolean contains = c.contains(e);
         
         
         
 
* 集合提供了一個方法可以刪除集合中的現有元素
     * boolean remove(E e)
     * 將給定的元素從集合中刪除，成功刪除返回true
         * 刪除元素的判斷依據是，刪除當前集合中第一個與
         * 給定元素equals比較為true的。
     c.remove(e);
         
              
         * 並集
         * boolean addAll(Collection c)
         * 將給定的集合中的所有元素添加到當前集合中
         * 當執行完畢後，當前集合中的元素發生了改變
         
 
* 就返回true
         c2.addAll(c1);
        

         * 判斷當前集合中是否包含給定集合裏的所有
         * 元素，全部包含則返回true。這裏判斷依據
         * 依然是依靠元素的equals比較的。
         * boolean containsAll(Collection c)
       boolean contains = c1.containsAll(c3);





     * 由於集合的具體實現類各不相同，Set集合大部分實現
     * 又是無序的，所以不能像數組那樣根據下標位置獲取
     * 具體的某一個元素。
     * 集合提供了統一的獲取集合元素方式:遍歷集合，而
     * 遍歷是使用叠代器來完成的。
     * java.util.Iterator是叠代器的接口，定義了用於遍歷
     * 集合的相關方法。不同的集合都實現了一個可以遍歷自身
     * 的叠代器實現類。我們無需記住實現類的名字，只當是
     * 叠代器使用即可。
     * 叠代器叠代元素需要遵循:問，取，刪。這個步驟。
     * 其中刪除不是必須的。
     

         * 若需要遍歷集合，可以調用集合的方法:
         * Iterator iterator()
         * 該方法會返回可以遍歷當前集合的叠代器。
         Iterator it = c.iterator();

         * boolean hasNext()
         * 詢問叠代器，其遍歷的集合是否還有元素沒有
         * 遍歷過，有則返回true
         while(it.hasNext()){
             * E next()
             * 取出集合中下一個元素。
            String str = (String)it.next();
            /*
             * 刪除"#"
             */
            if("#".equals(str)){
                /*
                 * 在使用叠代器遍歷集合的過程中，不能通過
                 * 集合的方法改變集合元素，否則可能拋出異常
                 */
//                c.remove(str); 集合的方法
                /*
                 * 刪除的是剛通過next()方法取出的元素。
                 */
                it.remove();//叠代器方法
            }
        }
        
        
        
        
         * java 5.0以後推出了一個新的特性:增強for循環
     * 又叫做:新循環，增強循環，for each
     * 新循環不能代替傳統循環重復工作的需求。
     * 新循環是用來遍歷集合或數組的。

        String[] array 
            = new String[]{"one","two","three"};
            
        for(String str:array){
            System.out.println(str);
        }

         * 新循環並不是JVM認可的新語法。而是編譯器認可
         * 的。編譯器在編譯源程序時若發現我們使用新循環
         * 來遍歷集合時，會將代碼改變為使用叠代器的方式
         * 遍歷集合。所以新循環遍歷集合本質上就是叠代器
         * 遍歷。
         * 所以新循環在遍歷集合的過程中不允許通過集合的
         * 方法修改元素數量。

        for(Object obj:c){
            if("#".equals(obj)){
                c.remove(obj);//錯誤
                i.remove(obj);//沒有顯示叠代，錯誤
            }
        }


         
         
         
         
         
     * List集合
     * 有序集，可重復集。
     * List的特點是可以像數組一樣，根據下標操作元素。
     * 所以List提供了一些獨有的方法。
     * 常用實現類:
     * ArrayList:內部由數組實現，查詢快。
     * LinkedList:內部由鏈表實現，增刪快。

        List<String> list = new ArrayList<String>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        
        
         *    E get(int index)
         *    獲取指定下標對應的元素。     
         String str = list.get(1);
    
        //通過下標操作遍歷集合
        for(int i=0;i<list.size();i++){
            str = list.get(i);
            System.out.println(str);
        }
        

         * E set(int index,E e)
         * 將給定的元素設置到指定的位置上，返回值為
         * 原位置上的元素。所以該操作時替換元素操作
         String old = list.set(1, "2");
    
    




     * List提供的另一對方法:
     * void add(int index,E e)
     * 向指定位置插入給定元素，原位置及後續元素順序向後
     * 移動
     * 
     * E remove(int index)
     * 刪除並返回給定位置的元素。
 
        List<String> list = new LinkedList<String>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        
        
         * void add(int index,E e)
         list.add(2,"3");
        
            
         * E remove(int index)
     * 刪除並返回給定位置的元素。
         String old = list.remove(3);
        


         
         
         
     * 集合轉換為數組
     * Collection中提供了一個方法toArray
     * 允許我們將現有的集合轉換為數組。

        Collection<String> c = new ArrayList<String>();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        
//        Object[] array = c.toArray(); 轉換的是Object數組，所以一般不用這種，而用下面的那種
        
        String[] array 
            = c.toArray(new String[c.size()]);



         
         
     * 數組轉換為集合
     * 使用Arrays的靜態方法asList()
     * 需要註意，數組只能轉換為List集合。不能轉換為Set
     * 原因在於:
     * 1:Set大部分是無序實現
     * 2:Set不允許存放重復元素，所以轉換後可能丟失元素。

        String[] array = new String[]{"one","two","three"};
        List<String> list = Arrays.asList(array);
    
         * 修改該集合元素內容，原數組內容也會發生改變

         list.set(0, "1");
        //數組第一個元素也變為了"1"

         * 對於由數組轉換的集合來說，添加新元素是不受支持的!所以下面代碼會拋出異常
          list.add("four");
          
        
         * 所有的集合都支持一個構造方法，參數要求傳入另一個集合。
         * 這個構造方法的作用是:
         * 創建當前集合的同時將給定的集合中的所有元素添加到當前集合中。
        List<String> list1 = new ArrayList<String>(list);
        

         
         
         
         
    * 獲取List集合中的子集

        List<Integer> list = new ArrayList<Integer>();
        for(int i=0;i<10;i++){
            list.add(i);
        }
        //[0,1,2,3,4,5,6,7,8,9]
        
         * List subList(int start,int end)
         * 獲取當前集合中給定範圍內的部分子集。
        List<Integer> subList = list.subList(3, 8);
        
        

         * 對子集的任何操作都會影響原集合
         * 清空子集，原集合中該部分內容也被刪除。
         
         
         
         
         
         
 * 泛型
 * JDK5.0開始支持的新特性
 * 泛型是參數化類型，可以對一個類中的屬性，
 * 方法的參數，方法的返回值類型進行約束，
 * 在使用時指定類型。
 
 
public class Point<T> {
    private T x;
    private T y;
    
    public Point(){
        
    }
    public Point(T x, T y) {
        this.x = x;
        this.y = y;
    }
    public T getX() {
        return x;
    }
    public void setX(T x) {
        this.x = x;
    }
    public T getY() {
        return y;
    }
    public void setY(T y) {
        this.y = y;
    }


    public static void main(String[] args) {
        Point<Integer> p1 
            = new Point<Integer>(1,2);
        int x1 = p1.getX();
        
        Point<Double> p2
            = new Point<Double>(1.1,2.2);
        double x2 = p2.getX();
        
        Point<String> p3
            = new Point<String>("1","2");
        String x3 = p3.getX();
    }
}


 * 泛型的註意事項

         * 當使用一個具有泛型的類時，若不指定，則就
         * 按照默認的Object作為實際類型
        


         
         
         
     * 泛型在集合中的應用
     * 集合中的泛型是用來約束集合中元素的類型。
 
         Collection<String> c = new ArrayList<String>();
         c.add("one");
        
         * 叠代器也支持泛型，泛型與該叠代器遍歷的集合
         * 的泛型類型一致即可。
         
        Iterator<String> it = c.iterator();
        while(it.hasNext()){
            String str = it.next();
        }
    







     * Collections: 集合的工具類
     * 該類提供了若幹靜態方法，可以方便操作集合。
     * 其中sort方法是用來排序List集的。進行自然排序
 
         * sort會對給定的List集合中的元素進行自然排序
         * 即:從小到大的順序
         * Collections.sort(list);
         
         * 面試題：
         * Collection與Collections的區別?
         * 或分別說明它們
         
    
    
    
    
         * Collections的sort方法若希望對集合進行
         * 排序，必須保證集合中的元素是可比較大小的。
         * 所以要求元素必須實現Comparable接口，並
         * 重寫其中的比較大小方法，才可以進行排序。
        
         * 雖然sort方法可以對集合中的元素進行自然排序
         * 但是必須要求元素實現Comparable接口，這就出現
         * 了由於想使用排序功能而必須改變我們定義的類的
         * 內容，這中現象稱為"侵入性"。
         

    
    
    
    
 * 當集合中存放的是自定義類型元素時，使用Collections的sort方法排序的註意事項:
 * 
 * 當前元素若希望可以比較大小，需要實現Comparable
 * 接口
 * Comparable支持泛型，而泛型的實際類型就是當前
 * 類。意思是說，哪個類實現Comparable接口，泛型
 * 就是哪個類。


public class Point implements Comparable<Point>{
    private int x;
    private int y;
    public Point(int x, int y) {
        super();
        this.x = x;
        this.y = y;
    }
    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }
    public int getY() {
        return y;
    }
    public void setY(int y) {
        this.y = y;
    }
    
    public String toString(){
        return "(" + x + "," + y + ")";
    }
    /**
     * CompareTo方法的作用是使當前對象與給定的對象o進行比較大小。
     * 返回值不關註具體值，而是關註取值範圍:
     * 當返回值>0:當前對象比參數對象大
     * 當返回值<0:當前對象比參數對象小
     * 當返回值=0:兩個對象相等
     */
    public int compareTo(Point o) {
        int len = this.x*this.x+this.y*this.y;
        int olen = o.x*o.x+o.y*o.y;
        return len-olen;
    }
}


    
    



         * 字符串String實現了Comparable接口
         * 排序規則:按照首字母的編碼比大小。
         
    
         * Collections的重載sort方法要求我們傳入兩個
         * 參數:
         * 1:待排序的集合
         * 2:比較器
         * 通常有兩種情況會使用該方法排序集合:
         * 1:元素已經實現了Comparable接口，但是比較大小
         *   的規則不能滿足我們對於排序的需求時
         * 2:元素沒有實現Comparable接口，並且也不希望為
         *   了這裏排序而強制修改元素，要求其實現接口時  
         *
         
//        MyComparator com = new MyComparator();
      
      Comparator<String> com
        = new Comparator<String>(){
          public int compare(String o1, String o2) {
            return o1.length()-o2.length();
          }
        
      };
      Collections.sort(list,com);
      
        
     class MyComparator implements Comparator<String>{
      /**
       * 字符串比較大小的規則:
       * 字符數量多的大
       */
      public int compare(String o1, String o2) {
        return o1.length()-o2.length();
      }
    }







         

java課堂筆記------集合api