java基礎-集合

java基礎-集合

 以下內容為本人的學習筆記，如需要轉載，請宣告原文鏈接 https://www.cnblogs.com/lyh1024/p/16738857.html

1.集合框架概述

1.1集合框架 的作用

在實際開發中，我們經常會對一組相同型別的資料進行統一管理操作，到目前為止，我們可以使用陣列結構，鏈表結構，二叉樹來實作，

陣列的最大問題在于陣列中的元素個數是固定的，要實作動態陣列，還是比較麻煩，

在JDK1.2版本后，java完整提供了類集合的概念，封裝了一組強大的，非常方便的集合框架API，讓我們在開發中大大的提高了效率，

集合中分為三大介面；

Collection、Map、Iterator

集合框架的介面和類在java.util包中

1.2 集合框架結構圖：

注：虛線表示介面，實作表示實作類，

1.3 Collection介面

Collection 層次結構 中的根介面，Collection 表示一組物件，這些物件也稱為 collection 的元素，一些 collection 允許有重復的元素，而另一些則不允許，一些 collection 是有序的，而另一些則是無序的，JDK 不提供此介面的任何直接 實作：它提供更具體的子介面（如 Set 和 List）實作，此介面通常用來傳遞 collection，并在需要最大普遍性的地方操作這些 collection，

介面的定義：

public interface Collection<E> extends Iterator<E>

2集合框架List介面

2.1 List介面

public interface List<E> extends Collection<E>

有序的 collection（也稱為序列），此介面的用戶可以對串列中每個元素的插入位置進行精確地控制，用戶可以根據元素的整數索引（在串列中的位置）訪問元素，并搜索串列中的元素，

/**
Collection介面：用于存盤單個物件的集合
List介面：
1.有序的,可重復
2.允許多個null元素
3.具體的實作類有常用的：ArrayList，LinkedList，Vector
Set介面
*/
public class ListDemo{
    private static  void arrayList(){
        //使用集合來存盤多個不同型別的元素（物件），在處理時會比較麻煩，在實際開發中，不建議這樣使用
     // List list = new ArrayList();
        //在集合中存盤相同型別的物件,第二個<>里在jdk1.8可以不用寫型別Sting
List<String> list = new ArrayList<>();//加泛型約束String型別
            list.add("小米");
            list.add("調度");
            list.add("狗蛋");
            list.add("二毛");
            list.add("旺財");
        //遍歷集合
        //for(int i = 0;i<list.size() ;i++),區域變數size會進堆疊，呼叫堆疊會比呼叫方法快，性能高得多，區域變數size只求一次，而方法要一直呼叫
        int size = list.size();
        for(int i = 0;i<size ;i++){
            System.out.println(list.get(i))//list.get(int i),獲取下標為i 的值
        }
System.out.println(list.contains("小米"))//contains（）：List是否包含"小米"
        list.remove("小米")//洗掉"小米"
        String[] array = list.toArray(new String[]{});//toArray（），轉換成array陣列，引數：定義陣列型別
        for(String s: array){
            System.out.println(s);
        }
    }
    public static void main(String[] args){
        arrayList();
    }
    
}

?在實際開發中，我們如何選擇list的具體實作？

??1.安全性問題

??2.是否頻繁插入，洗掉操作（LinkedList）

??3.是否是存盤后遍歷

面試題：怎么實作ArrayList，即ArrayList的原理?

2.2ArrayList

public class ArrayList<E> extends AbstractList<E> implements List<E>,RandomAccess,Cloneable,Serializable

List 介面的大小可變陣列的實作，實作了所有可選串列操作，并允許包括 null 在內的所有元素，除了實作 List 介面外，此類還提供一些方法來操作內部用來存盤串列的陣列的大小，（

/**ArrayList
?
        1.實作原理，采用動態物件陣列實作，默認構造方法創建了一個空陣列
?
        2.第一次添加元素，擴展容量為10，之后的擴充演算法：原來陣列大小＋原來陣列的一半
?
        3.不適合進行洗掉或插入操作，否則導致位置會變
?
        4.為了防止陣列動態擴充次數過多，建議創建ArrayList時，給定初始容量
?
        5.多執行緒中使用不安全，適合在單執行緒訪問時使用，在單執行緒下使用效率高
?
        JDK1.2開始
?
*/
?

2.3 Vector

Vector 類可以實作可增長的物件陣列，與陣列一樣，它包含可以使用整數索引進行訪問的組件，但是，Vector 的大小可以根據需要增大或縮小，以適應創建 Vector 后進行添加或移除項的操作，

private static void vector(){
/** 
?
Vector
?
1.實作原理，采用動態物件陣列實作，默認構造方法創建了一個大小為10的物件陣列
?
2.擴充的演算法：當增量為0時，擴充為原來大小的2倍，當增量>0時，擴充為原來大小＋增量
?
3.不適合洗掉或插入操作
?
4.為了防止陣列動態擴充次數過多，建議創建Vector時，給定初始容量
?
5.執行緒安全，適合在多執行緒訪問時使用，在單執行緒下使用效率較低，因為內部方法加了synchronized同步鎖
?
*/
?
Vector<String>  vector = new Vector<>();
    vector .add("小米");
    vector .add("調度");
    vector .add("狗蛋");
    vector .add("二毛");
    vector .add("旺財");
for(int i = 0;i<v.size();i++){
?
System.out.println(v.get(i))
}
     public static void main(String[] args){
        vector();
    }
?
}

面試題：Vector與ArrayLIst的區別？

2.4 LinkedList

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>,Deque<E>,Cloneable,Serializable

List 介面的鏈接串列實作，實作所有可選的串列操作，并且允許所有元素（包括 null），除了實作 List 介面外，LinkedList 類還為在串列的開頭及結尾 get、remove 和 insert 元素提供了統一的命名方法，

/** 
  LinkedList
      1.實作原理，采用雙向鏈表結構實作
      2.適合插入，洗掉操作，性能高

*/
private static void linkedList(){
?
LinkedList<String>  list = new LinkedList<>();
            list.add("小米");
            list.add("調度");
            list.add("狗蛋");
            list.add("二毛");
            list.add("旺財");
            //遍歷集合
            int size = list.size();
            for(int i = 0;i<size ;i++){
                System.out.println(list.get(i));
            }
}

3集合框架Set介面

3.1 set介面

public interface Set<E> extends Collection<E>

一個不包含重復元素的 collection，更確切地講，set 不包含滿足 e1.equals(e2) 的元素對 e1 和 e2，并且最多包含一個 null 元素，正如其名稱所暗示的，此介面模仿了數學上的 set 抽象，

3.2HashSet

• public class **HashSet<E>**extends AbstractSet<E>implements Set<E>, Cloneable, Serializable

此類實作 Set 介面，由哈希表（實際上是一個 HashMap 實體）支持，它不保證 set 的迭代順序；特別是它不保證該順序恒久不變，此類允許使用 null 元素，

/**
?
Set介面
1.無序的（不保證順序）
2.不允許重復元素
實作類：HashSet,TreeSet,LinkedHashSet，三者底層實作與Map關聯
?
選擇使用
如果要排序，選擇treeSet
如果不要排序，也不用保證順序選擇HashSet
不要排序，要保證順序，選擇LinkedHashSet
?
*/ 
?
public class SetDemo{
?
public static void main(Sting[] args){
?
/** 
HashSet
1.實作原理，基于哈希表（HashMap）實作
2.不允許重復，可以有一個NULL元素
3.不保證順序恒久不變（例：添加元素后，輸出順序會變）
4.添加元素時把元素作為HashMap的key存盤，HashMap的value使用一個固定的Object物件
5.排除重復元素是通過equals來檢查物件是否相同
6.判斷兩個物件是否相同，先判斷兩個物件的hashCode是否相同，（如果兩個物件的hashCode相同，不一定是同一個物件，如果不同，那一定不是同一個物件；整數范圍就這么大，有可能重復），如果不同，則兩個物件不是同一個物件，如果相同，還要進行equals判斷，equals相同則是同一個物件，不同則不是同一個物件，
7.自定義物件要認為屬性值都相同時為同一個物件，有這種需求時，那么我們要重寫物件所在物體類的hashCode和equals方法
?
小結
（1）哈希表的存盤結構：陣列+鏈表，陣列里的每個元素以鏈表的形式存盤
（2）如何把物件存盤到哈希表中，先計算物件的hashCode值，再對陣列的長度求余數，來決定物件要存盤在陣列中的哪個位置（不同的值放到陣列里，相同的值按先后順序作為鏈表放在一格陣列里，先放進去的就是根，后進去的作為根的next）
（3）解決hashSet中的重復值使用的方式是：參考第六點
*/
?
private static void hashSet(){
Set<String> set = new HashSet<>();
set.add("張飛");
set.add("關羽");
set.add("劉備");
set.add("諸葛亮");
            set.add("曹操");
            set.add("諸葛亮");//把上面的"諸葛亮"替換掉,添加自定義的不同物件，且相同值的物件時不會被替換
?
            String[] names = set.toArray(new String[]{})
            for(String s : names){
            System.out.println(s);
            }
?
?
}
?
}
?
}
?
?

hashCode深入分析

hashCode（）方法，在Object類中定義如下：

public native int hashCode();//native本地方法

hashCode是本地方法，它的實作是根據本地機器相關，當然我們可以在自己寫的類中覆寫hashCode()方法，比如 String ,Integer,Double......等等這些類都是覆寫了hashCode()方法的，

• 判斷兩個物件是否相同：先判斷兩個物件的hashCode是否相同，（[重寫hashCode(),根據值來計算hashCode，值相等判定為同一物件，]如果兩個物件的hashCode相同，不一定是同一個物件，如果不同，那一定不是同一個物件；整數范圍就這么大，有可能重復），如果不同，則兩個物件不是同一個物件，如果相同，還要進行equals判斷，equals相同則是同一個物件，不同則不是同一個物件，

• 如何把物件存盤到哈希表中：先計算物件的hashCode值，再對陣列的長度求余數，來決定物件要存盤在陣列中的哪個位置（不同的值放到陣列里，相同的值按先后順序作為鏈表放在一格陣列里，先放進去的就是根，后進去的作為根的next）

3.3 TreeSet（排序）

• public class **TreeSet<E>**extends AbstractSet<E>implements NavigableSet<E>, Cloneable, Serializable

基于 TreeMap的 NavigableSet實作，使用元素的自然順序對元素進行排序，或者根據創建 set 時提供的 Comparator 進行排序，具體取決于使用的構造方法，

/**
有序的，基于TreeMap（二叉樹資料結構），物件需要比較大小，通過物件比較器來實作，
物件比較器還可以用來去除重復元素，
如果自定義的資料類，沒有實作比較器介面，將無法添加到TreeSet集合中，
?
*/
?
private static void treeSet(){
TreeSet<String> tree = new TreeSet<>(new CatComparetor());
    Cat c1 = new Cat("wanwan",2,1) //引數：名字，年齡，編號
    Cat c2 = new Cat("guanguan",3,2)
    Cat c3 = new Cat("wanwan",2,3)
    Cat c4 = new Cat("wanwan",2,1)
    tree.add(c1);
    tree.add(c2);
    tree.add(c3);
    tree.add(c4);
    System.out.println(tree.size() );//如果創建TreeSet實體時沒有傳入new CatComparetor()比較器的話，物件間無法比較排序，報型別轉換例外錯誤

    for(Cat c : tree){
        System.out.println(c);
    }
    
}
?
public class CatComparetor implements Comparator<Cat>{
    public int compare(Cat o1,Cat o2){
       // return o1.getAge()-o2.getAge()//根據年齡來比較,相同年齡會被判定為同一物件，存不進去
        
        
    }
}

3.4LinkedHashSet（順序）

• public class **LinkedHashSet<E>**extends HashSet<E>implements Set<E>, Cloneable, Serializable

具有可預知迭代順序的 Set 介面的哈希表和鏈接串列實作，此實作與 HashSet 的不同之外在于，后者維護著一個運行于所有條目的雙重鏈接串列，此鏈接串列定義了迭代順序，即按照將元素插入到 set 中的順序（插入順序）進行迭代，注意，插入順序不 受在 set 中重新插入的 元素的影響，（如果在 s.contains(e) 回傳 true 后立即呼叫 s.add(e)，則元素 e 會被重新插入到 set s 中，）

/**  
哈希表和鏈接串列實作
維護著一個運行于所有條目的雙重鏈接串列，此鏈接串列定義了迭代順序，即按照將元素插入到 set  中的順序（*插入順序*）進行迭代
*/
private static void linkedHashSet(){
LinkedHashSet<String> set = new LinkedHashSet<>();//鏈表來記錄位置
Cat c1 = new Cat("wanwan",2,1) //引數：名字，年齡，編號
    Cat c2 = new Cat("guanguan",3,2)
    Cat c3 = new Cat("wanwan",2,3)
    Cat c4 = new Cat("wanwan",2,1)
    set.add(c1);
    set.add(c2);
    set.add(c3);
    set.add(c4);
    
    for(Cat c : set){
        System.out.println(c);
    }
?
}

4.集合框架Iterator介面

4.1 集合輸出

前面我們已經學習了集合的基本操作，很多情況下，我們需要把集合的內容進行輸出，也就是遍歷集合

遍歷集合的方式有一下幾種：

1. Iterator

2. ListIterator(一般用得很少)

3. Enumeration（列舉迭代介面）

4. foreach（，最方便，用得也多）

其中Iterator的使用率最高，在JDK1.5后新增了foreach，也被大量使用，有了Iterator迭代器，不同的集合也可以用相同的方式來迭代，而內部隱藏了不同的具體實作

4.2 Iterator

• public interface **Iterator<E>**

對 collection 進行迭代的迭代器，迭代器取代了 Java Collections Framework 中的 Enumeration，

4.3 ListIterator

• public interface **ListIterator<E>**extends Iterator<E>

系串列迭代器，允許程式員按任一方向遍歷串列、迭代期間修改串列，并獲得迭代器在串列中的當前位置，

4.4 Enumeration

• public interface **Enumeration<E>**

實作 Enumeration 介面的物件，它生成一系列元素，一次生成一個，連續呼叫 nextElement 方法將回傳一系列的連續元素，

注：此介面的功能與 Iterator 介面的功能是重復的，此外，Iterator 介面添加了一個可選的移除操作，并使用較短的方法名，新的實作應該優先考慮使用 Iterator 介面而不是 Enumeration 介面，

/**
?
?集合輸出，迭代
?
*/
public class IteratorDemo{
//foreach,JDK1.5后才有
private static void foreach(Collection<Cat>){
for(Cat cat :c ){
System.out.println(cat);
}

}

//iterator，JDK1.5之前統一的迭代集合方式
private static void iterator(Collection<Cat>){
Iterator<Cat> iter = c.iterator();//iterator()以正確的順序回傳該串列中的元素的迭代器
while(iter.hasNext()){
System.out.println(iter.next());
}
        
     //Enumeration,常搭配Vector使用
    private static void enumeration(Collection<Cat>){
   Vector<Stirng> vs = new Vector<>();
        vs.add("tom");
        vs.add("job");
        vs.add("jack");
        vs.add("lily");
        
        Enumeration<String> es = vs.elements();
while(es.hasMoreElements()){
            System.out.println(es.nextElement());
        }

       // ListIterator提供向上遍歷的方法previous()
}
?
public static void main(String[] args){
List<Cat> list = new ArrayList<>();
            Cat c1 = new Cat("wanwan",2,1) //引數：名字，年齡，編號
            Cat c2 = new Cat("guanguan",3,2)
            Cat c3 = new Cat("wanwan",2,3)
            Cat c4 = new Cat("wanwan",2,1)
            list.add(c1);
            list.add(c2);
            list.add(c3);
            list.add(c4);
            foreach(list);
            iterator(list);//輸出遍歷
        enumeration();
}
}

有待補充....

參考資料：

JDK1.6幫助檔案

標籤：Java

上一篇：Jmix 中 REST API 的兩種實作

下一篇：什么是死鎖？如何避免死鎖？