目 錄
Java 集合框架
早在 Java 2 之前,Java 就提供了特設類。比如:Dictionary, Vector, Stack 和 Properties 這些類用來存儲和操作對象組。
雖然這些類都非常有用,但是它們缺少一個核心的、統一的主題。由於這個原因,使用 Vector 類的方式和使用 Properties 類的方式有着很大不同。
集合框架被設計成要滿足以下幾個目標。
-
該框架必須是高性能的。基本集合(動態數組,鏈表,樹,哈希表)的實現也必須是高效的。
-
該框架必須是操作方法上儘量一致。允許不同類型的集合,以類似的方式工作,具有高度的互操作性。
-
對一個集合的擴展和適應必須是簡單的。
爲此,整個集合框架就圍繞一組標準接口而設計。你可以直接使用這些接口的標準實現,諸如: LinkedList, HashSet, 和 TreeSet 等,除此之外你也可以通過這些接口實現自己的集合。
除了集合,該框架也定義了幾個 Map 接口和類。Map 裏存儲的是鍵/值對。儘管 Map 不是集合,但是它們完全整合在集合中。
一、集合框架體系圖
Java 集合框架提供了一套性能優良,使用方便的接口和類,java集合框架位於java.util包中, 所以當使用集合框架的時候需要進行導包。
二、Java中的常用集合接口
集合框架定義了一些接口,下面提供了每個接口的概述:
序號 | 接口描述 |
---|---|
1 | Collection 接口
Collection 是最基本的集合接口,一個 Collection 代表一組 Object,即 Collection 的元素, Java不提供直接繼承自Collection的類,只提供繼承於的子接口(如List和set)。 Collection 接口存儲一組不唯一,無序的對象。 |
2 | List 接口
List接口是一個有序的 Collection,使用此接口能夠精確的控制每個元素插入的位置,能夠通過索引(元素在List中位置,類似於數組的下標)來訪問List中的元素,第一個元素的索引爲 0,而且允許有相同的元素。 List 接口存儲一組不唯一,有序(插入順序)的對象。 |
3 | Set
Set 具有與 Collection 完全一樣的接口,只是行爲上不同,Set 不保存重複的元素。 Set 接口存儲一組唯一,無序的對象。 |
4 | SortedSet 繼承於Set保存有序的集合。 |
5 | Map
Map 接口存儲一組鍵值對象,提供key(鍵)到value(值)的映射。 |
6 | Map.Entry 描述在一個Map中的一個元素(鍵/值對)。是一個Map的內部類。 |
7 | SortedMap 繼承於 Map,使 Key 保持在升序排列。 |
8 | Enumeration 這是一個傳統的接口和定義的方法,通過它可以枚舉(一次獲得一個)對象集合中的元素。這個傳統接口已被迭代器取代。 |
Set和List的區別
-
1. Set 接口實例存儲的是無序的,不重複的數據。List 接口實例存儲的是有序的,可以重複的元素。
-
2. Set檢索效率低下,刪除和插入效率高,插入和刪除不會引起元素位置改變 <實現類有HashSet,TreeSet>。
-
3. List和數組類似,可以動態增長,根據實際存儲的數據的長度自動增長List的長度。查找元素效率高,插入刪除效率低,因爲會引起其他元素位置改變 <實現類有ArrayList,LinkedList,Vector> 。
三、Java中的常用集合實現類(集合類)
Java提供了一套實現了Collection接口的標準集合類。其中一些是具體類,這些類可以直接拿來使用,而另外一些是抽象類,提供了接口的部分實現。
標準集合類彙總於下表:
序號 | 類描述 |
---|---|
1 | AbstractCollection 實現了大部分的集合接口。 |
2 | AbstractList 繼承於AbstractCollection 並且實現了大部分List接口。 |
3 | AbstractSequentialList 繼承於 AbstractList ,提供了對數據元素的鏈式訪問而不是隨機訪問。 |
4 | LinkedList
該類實現了List接口,允許有null(空)元素。主要用於創建鏈表數據結構,該類沒有同步方法,如果多個線程同時訪問一個List,則必須自己實現訪問同步,解決方法就是在創建List時候構造一個同步的List。例如:
LinkedList 查找效率低。 |
5 | ArrayList
該類也是實現了List的接口,實現了可變大小的數組,隨機訪問和遍歷元素時,提供更好的性能。該類也是非同步的,在多線程的情況下不要使用。ArrayList 增長當前長度的50%,插入刪除效率低。 |
6 | AbstractSet 繼承於AbstractCollection 並且實現了大部分Set接口。 |
7 | HashSet
該類實現了Set接口,不允許出現重複元素,不保證集合中元素的順序,允許包含值爲null的元素,但最多隻能一個。 |
8 | LinkedHashSet 具有可預知迭代順序的 Set 接口的哈希表和鏈接列表實現。 |
9 | TreeSet
該類實現了Set接口,可以實現排序等功能。 |
10 | AbstractMap 實現了大部分的Map接口。 |
11 | HashMap HashMap 是一個散列表,它存儲的內容是鍵值對(key-value)映射。 該類實現了Map接口,根據鍵的HashCode值存儲數據,具有很快的訪問速度,最多允許一條記錄的鍵爲null,不支持線程同步。 |
12 | TreeMap 繼承了AbstractMap,並且使用一顆樹。 |
13 | WeakHashMap 繼承AbstractMap類,使用弱密鑰的哈希表。 |
14 | LinkedHashMap 繼承於HashMap,使用元素的自然順序對元素進行排序. |
15 | IdentityHashMap 繼承AbstractMap類,比較文檔時使用引用相等。 |
在前面的教程中已經討論通過java.util包中定義的類,如下所示:
序號 | 類描述 |
---|---|
1 | Vector
該類和ArrayList非常相似,但是該類是同步的,可以用在多線程的情況,該類允許設置默認的增長長度,默認擴容方式爲原來的2倍。 |
2 | Stack 棧是Vector的一個子類,它實現了一個標準的後進先出的棧。 |
3 | Dictionary Dictionary 類是一個抽象類,用來存儲鍵/值對,作用和Map類相似。 |
4 | Hashtable
Hashtable 是 Dictionary(字典) 類的子類,位於 java.util 包中。 |
5 | Properties Properties 繼承於 Hashtable,表示一個持久的屬性集,屬性列表中每個鍵及其對應值都是一個字符串。 |
6 | BitSet 一個Bitset類創建一種特殊類型的數組來保存位值。BitSet中數組大小會隨需要增加。 |
四、集合算法
集合框架定義了幾種算法,可用於集合和映射。這些算法被定義爲集合類的靜態方法。
在嘗試比較不兼容的類型時,一些方法能夠拋出 ClassCastException異常。當試圖修改一個不可修改的集合時,拋出UnsupportedOperationException異常。
集合定義三個靜態的變量(常量):EMPTY_SET,EMPTY_LIST,EMPTY_MAP的。這些變量都不可改變。
序號 | 算法描述 |
---|---|
1 | Collection Algorithms 這裏是一個列表中的所有算法實現。 |
五、如何使用迭代器
通常情況下,你會希望遍歷一個集合中的元素。例如,顯示集合中的每個元素。
一般遍歷數組都是採用for循環或者增強for,這兩個方法也可以用在集合框架,但是還有一種方法是採用迭代器遍歷集合框架,它是一個對象,實現了Iterator 接口或ListIterator接口。
迭代器,使我們能夠通過循環來得到或刪除集合的元素。ListIterator 繼承了Iterator,以允許雙向遍歷列表和修改元素。
序號 | 迭代器方法描述 |
---|---|
1 | 使用 Java Iterator 這裏通過實例列出Iterator和listIterator接口提供的所有方法。 |
1、遍歷 ArrayList
import java.util.*;
/**
* 文件名:ArrayListDemo.java
* 功能描述:迭代器的使用
*/
public class ArrayListDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("蘋果");
list.add("香焦");
list.add("梨");
System.out.println("for ... each 遍歷方式:");
for(String em:list) {
System.out.println(em);
}
System.out.println("使用數組遍歷方式:");
String[] strArray = new String[list.size()];
list.toArray(strArray);
for(int i=0;i<strArray.length;i++) {
System.out.println(strArray[i]);
}
System.out.println("使用Iterator 遍歷方式:");
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
解析:
三種方法都是用來遍歷ArrayList集合,第三種方法是採用迭代器的方法,該方法可以不用擔心在遍歷的過程中會超出集合的長度。
2、遍歷 Map
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
/**
* 文件名:MapDemo.java
* 功能描述:Map類型數據的遍歷Demo
*/
public class MapDemo {
public static void main(String[] args) {
Map<String,String> map = new HashMap<String,String>();
map.put("001","張三");
map.put("002","李四");
map.put("003","王五");
map.put("004","趙六");
map.put("005","錢七");
System.out.println("第1種方法,使用 for ... each 遍歷:");
for(String key: map.keySet()) {
//此方法最常用,但需二次取值,故速度最慢,是第2、3種方法速度的一半
System.out.println("key:"+key+",value:"+map.get(key));
}
System.out.println("\n第2種方法,使用 迭代器 遍歷:");
Iterator<Map.Entry<String,String>> it = map.entrySet().iterator();
System.out.println("使用 for ... each 遍歷方式:");
while(it.hasNext()) {
//速度最快,且可以進行remove()這類的操作,it.remove();
Map.Entry<String,String> entry = it.next();
if(entry.getValue().equals("王五")) {
it.remove();
System.out.println("key:"+entry.getKey()+",value:"+entry.getValue()+" 已被刪除!");
continue;
}
System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
}
System.out.println("\n第3種方法,使用 Map.Entry (Iterator簡化版) 遍歷:");
for(Map.Entry<String,String> entry: map.entrySet()) {
//此方法與第2種方法的速度是一樣的,由於使用 for ... each 方法,簡化了迭代器的使用,
//也正是因爲使用 for ... each 方法,故無法進行remove()之類的操作
System.out.println("key:"+entry.getKey()+",value:"+entry.getValue());
}
System.out.println("\n第4種方法,使用 map.values() 遍歷:");
for(String v : map.values()) {
//速度快,無法取得相應的key值
System.out.println("value:"+v);
}
}
}
六、如何使用比較器
TreeSet和TreeMap的按照排序順序來存儲元素. 然而,這是通過比較器來精確定義按照什麼樣的排序順序。
這個接口可以讓我們以不同的方式來排序一個集合。
序號 | 比較器方法描述 |
---|---|
1 | 使用 Java Comparator 這裏通過實例列出Comparator接口提供的所有方法 |
java的比較器有兩類,分別是Comparable接口和Comparator接口。在爲對象數組進行排序時,比較器的作用非常明顯,首先來講解Comparable接口。
1、Comparable比較器的使用:
讓需要進行排序的對象實現Comparable接口,重寫其中的 compareTo(T o)方法,在其中定義排序規則,那麼就可以直接調用 java.util.Arrays.sort()來排序對象數組,實例如下:
/**
* 文件名:Student.java
* 功能描述:實現了排序接口的Student類
*/
public class Student implements Comparable<Student> {
private String name;
private int age;
private float score;
public Student(String name, int age, float score) {
this.name = name;
this.age = age;
this.score = score;
}
public String toString() {
return String.format("%-10s%5d%15.1f",name,age,score);
}
@Override
//排序需求,成績由高到低排列,如果成績相同,則按年齡由小到大排序
public int compareTo(Student o) {
if (this.score>o.score)
return -1;//成績由高到低
else if (this.score<o.score)
return 1;
else { //如果成績相同,年齡小者靠前
if (this.age>o.age)
return 1;//由小到大
else if (this.age<o.age)
return -1;
else
return 0;
}
}
}
測試文件:
/**
* 文件名:StudentTest.java
* 功能描述:測試Demo
*/
public class StudentTest {
public static void main(String[] args) {
Student[] students = {
new Student("張三",8,78.0f),
new Student("李四",20,100.0f),
new Student("王五",19,78.0f),
new Student("趙六",21,85.0f),
new Student("錢七",23,63)
};
System.out.println("------------排序之前:-------------");
for(Student stu: students) {
System.out.println(stu);
}
java.util.Arrays.sort(students);
System.out.println("------------排序之後:-------------");
for(Student stu: students) {
System.out.println(stu);
}
}
}
在上面的程序中,實現了Comparable接口,並重寫了compareTo方法,實現了學生成績由高到低排列,如果成績相同,則按年齡由小到大排序。
運行結果:
但是,我們在設計類的時候,可能並沒有考慮得很全面,並未讓Student類實現Comparable接口,那麼就需要用到另外的一個比較器接口:Comparator。
2、Comparator比較器的使用:
從上面的實例我們可以發現,Comparable的compareTo(T o)只有一個參數,而Comparator接口中必須要實現的compare(T o1,T o2)就有兩個參數。
代碼實例:
/**
* 文件名:Student.java
* 功能描述:未實現排序接口的Student類
*/
public class Student {
private String name;
private int age;
private float score;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public float getScore() {
return score;
}
public void setScore(float score) {
this.score = score;
}
public Student(String name, int age, float score) {
this.name = name;
this.age = age;
this.score = score;
}
public String toString() {
return String.format("%-10s%5d%15.1f",name,age,score);
}
}
Student的外部排序實現類:
import java.util.Comparator;
/**
* 文件名:StudentComparator.java
* 功能描述:從外部實現對Student類的排序
*/
class StudentComparator implements Comparator<Student> {
@Override
//排序需求:實現成績由高到低排列,如果成績相同,則按年齡由小到大排序
public int compare(Student o1, Student o2) {
if (o1.getScore()>o2.getScore())
return -1; //排序需求:成績由高到低
else if (o1.getScore()<o2.getScore())
return 1;
else {
if (o1.getAge()>o2.getAge())
return 1; //排序需求:成績相同的話,年齡由大到小排序
else if(o1.getAge()<o2.getAge())
return -1;
else
return 0;
}
}
}
測試Demo文件:
/**
* 文件名:StudentTest.java
* 功能描述:測試Demo文件
*/
public class StudentTest {
public static void main(String[] args) {
Student[] students = {
new Student("張三",8,78.0f),
new Student("李四",20,100.0f),
new Student("王五",19,78.0f),
new Student("趙六",21,85.0f),
new Student("錢七",23,63)
};
System.out.println("------------排序之前:-------------");
for(Student stu: students) {
System.out.println(stu);
}
java.util.Arrays.sort(students,new StudentComparator());
System.out.println("------------排序之後:-------------");
for(Student stu: students) {
System.out.println(stu);
}
}
}
運行結果:
上面依然是對student對象數組進行排序,用的都是Arrays.sort方法,不同的是實現comparator接口時,sort方法需要傳進來兩個參數,即students對象數組,以及重寫的實現了comparator比較方法類。
程序運行的結果和上面是一樣的。
3、使用集合框架的方式操縱Student對象
能否改造一下StudentTest.java文件,使用集合框架的方式操縱數據呢?答案當然是可以!!!
import java.util.*;
public class StudentTest {
public static void main(String[] args) {
Student[] students = {
new Student("張三丰",108,65),
new Student("張三丰",108,20),
new Student("李太白",78,75),
new Student("趙 四",108,95),
new Student("刀 哥",18,75),
new Student("張豐子",108,100)
};
list<String> list = Arrays.asList(students);
/*
List<Student> list = new ArrayList<Student>();
list.add(new Student("張三丰",108,65));
list.add(new Student("張三丰",108,20));
list.add(new Student("李太白",78,75));
list.add(new Student("趙 四",108,95));
list.add(new Student("刀 哥",18,75));
list.add(new Student("張豐子",108,100));
*/
System.out.println("=============before of sort:============");
for(Student stu:list) {
System.out.println(stu);
}
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return (int)(o2.getScore()-o1.getScore());
}
});
System.out.println("=============end of sort:===============");
Iterator<Student> it = list.iterator();
while(it.hasNext()) {
Student stu = it.next();
System.out.println(stu);
}
}
}
七、總結
Java集合框架爲程序員提供了預先包裝的數據結構和算法來操縱他們。
集合是一個對象,可容納其他對象的引用。集合接口聲明對每一種類型的集合可以執行的操作。
集合框架的類和接口均在java.util包中。
任何對象加入集合類後,自動轉變爲Object類型,所以在取出的時候,需要進行強制類型轉換。