java 中關於集合類的整理02

四. 具體的集合

2. ArrayList 數組列表

注： ArrayList類 與 Vector類 有什麼區別呢？

答：Vector類的全部方法都是同步的，因此說Vector類是線程安全的，因此兩個線程能夠安全的訪問一個Vector對象。 可是，若是隻有一個線程訪問Vector的話，代碼要在同步上花費大量的時間。因此在不須要同步的時候使用ArrayList，而同步的時候使用Vector。

 

3.散列集   

首先要知道哈希表這個概念，最多見的是使用「拉鍊法」來實現的，

左邊是一個數組，右邊是一個鏈表，這些鏈表能夠爲空。

在Java中，散列表用鏈表數組實現，每一個鏈表能夠看作桶（bucket），要想找到表中對象的位置，就要先計算他的散列碼，而後與桶的總數取餘，所獲得的結果就是保存這個元素的索引。

有時候桶會被佔滿，這也是沒法避免的，這種現象被稱爲散列衝突。（hash collision）

 1 public static void main(String[] args) {
 2         Set<String> words = new HashSet<>();
 3         long totalTime = 0;
 4         
 5         try(Scanner in = new Scanner(System.in)){
 6             while(in.hasNext()){
 7                 String word = in.next();
 8                 long callTime = System.currentTimeMillis();
 9                 words.add(word);
10                 callTime = System.currentTimeMillis() - callTime;
11                 totalTime +=callTime;
12             }
13         }
14         Iterator iter = words.iterator();
15         for(int i=1;i<20 && iter.hasNext();i++){
16             System.out.println(iter.next());
17         }
18         System.out.println("...");
19         System.out.println(words.size()+"distinct words."+totalTime+"millseconds");
20     }

以ctrl + z 結束輸入。

4.數集 

TreeSet類與散列集很類似，可是它比散列集有所改進。數集是一個有序集合。 能夠以任意順序插入到集合中，在對集合進行遍歷時，每一個值將自動地按照排序後的順序呈現。

1     public static void main(String[] args) {
2         SortedSet<String> sorter = new TreeSet<>(); //TreeSet implements SortedSet
3         sorter.add("james");
4         sorter.add("hah");
5         sorter.add("wade");
6         for(String s:sorter){
7             System.out.println(s);    //hah  james wade
8         }
9     }             

 

TreeSet 的實現當前使用的是 紅黑樹。  （關於紅黑樹之後再細說，。。。）

樹的排序必須是全序，也就是說，任意兩個元素必須是可比的。 因此這些元素必須實現了 Comparable 接口，或者構造集時必須提供一個Comparator。  下面是一個簡單的例子：

//自定義數據類型，並在自定義的數據類型中實現CompareTo方法  
class Teacher implements Comparable {  
    int num;  
    String name;  
  
    Teacher(String name, int num) {  
        this.num = num;  
        this.name = name;  
    }  
  
    public String toString() {  
        return "學號:" + num + " 姓名:" + name;  
    }  
  
    public int compareTo(Object o) {  
        Teacher ss = (Teacher) o;  
        int result = num > ss.num ? 1 : (num == ss.num ? 0 : -1);  
        if (result == 0) {  
            result = name.compareTo(ss.name);  
        }  
        return result;  
    }  
}  
  
public class TreeSetTest {  
    public static void main(String[] args) {          
        Set<Teacher> treeSet = new TreeSet<Teacher>();  
        treeSet.add(new Teacher("zhangsan", 2));  
        treeSet.add(new Teacher("lisi", 1));  
        treeSet.add(new Teacher("wangwu", 3));  
        treeSet.add(new Teacher("mazi", 3)); 
        
        System.out.println(treeSet);//直接輸出
        
        Iterator itTSet = treeSet.iterator();//遍歷輸出
        while(itTSet.hasNext())  
            System.out.print(itTSet.next() + "\t");  
        System.out.println();  
    }   
}  

輸出爲：

[學號:1 姓名:lisi, 學號:2 姓名:zhangsan, 學號:3 姓名:mazi, 學號:3 姓名:wangwu]
學號:1 姓名:lisi    學號:2 姓名:zhangsan    學號:3 姓名:mazi    學號:3 姓名:wangwu    

 

5.隊列與雙端隊列 

 隊列，在尾部添加元素，在頭部刪除元素。

有兩個端頭的隊列，即雙端隊列，可讓人們有效地在頭部和尾部同時添加或者刪除元素，不支持在隊列中中間添加元素。

6.優先級隊列   

優先級隊列（priority queue）中的uansu能夠按照任意的順序插入，卻老是按照排序的順序進行檢索。 

即不管什麼時候調用remove（）方法，總會得到優先級隊列中最小的元素。

優先級隊列使用了一個高效的數據結構，堆。

堆： 堆是一個能夠自我調整的二叉樹，對這個樹執行添加(add)和刪除(reomve)操做，可讓最小的元素移動到根，而沒必要花費時間對元素進行排序。

與TreeSet同樣，元素必須實現了 Comparable 接口，或者構造集時必須提供一個Comparator。

 1     public static void main(String[] args) {
 2         PriorityQueue<LocalDate> pq = new PriorityQueue<>();
 3         pq.add(LocalDate.of(1906, 12, 9));
 4         pq.add(LocalDate.of(1856, 10, 8));
 5         pq.add(LocalDate.of(1993, 12, 10));
 6         pq.add(LocalDate.of(2004, 11, 15));
 7         
 8         System.out.println("Iterating over eleents...");
 9         for(LocalDate ld:pq)
10             System.out.println(ld);
11         System.out.println("Remove elements...");
12         while(!pq.isEmpty()){
13             System.out.println(pq.remove());
14         }
15     }

結果爲：

Iterating over eleents...
1856-10-08
1906-12-09
1993-12-10
2004-11-15
Remove elements...
1856-10-08
1906-12-09
1993-12-10
2004-11-15

7.映射

一般，咱們知道某些鍵的信息，並想要查找與之對應的元素。

映射（map）數據結構就是爲此設計的。  映射一般用來存放鍵/值對。

Java類庫中提供了 HashMap 和 TreeMap 的實現。 這兩個類都實現了Map的接口。

7.1 HashMap 

 1     public static void main(String[] args) {
 2         Map<String,Integer> staff = new HashMap<>();
 3         staff.put("12-56", 98);
 4         staff.put("26-34", 96);
 5         staff.put("39-48", 84);
 6         staff.put("45-56", 97);
 7         
 8         // print all entries
 9         System.out.println(staff);
10         //remove an entry
11         staff.remove("26-34");
12         //replace an entry
13         staff.put("12-56", 100);
14         //look up a value
15         System.out.println(staff.get("45-56"));
16         // iterate through all entries
17         staff.forEach((k,v) ->
18            System.out.println("key:"+k+",value:"+v));
19     }

最後的輸出使用了 lamda 表達式，輸出結果爲：

{39-48=84, 26-34=96, 12-56=98, 45-56=97}
97
key:39-48,value:84
key:12-56,value:100
key:45-56,value:97

 

HashMap是面試的重點，面試官可能會問道HashMap是怎樣構造的等等問題，這些之後再專列複習吧，。