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是怎样构造的等等问题，这些之后再专列复习吧，。