Java集合中List,Set以及Map等集合體系簡述
概述:
List , Set, Map都是介面，前兩個繼承至collection介面，Map為獨立介面
Set下有HashSet，LinkedHashSet，TreeSet
List下有ArrayList，Vector，LinkedList
Map下有Hashtable，LinkedHashMap，HashMap，TreeMap
collection介面下還有個Queue介面，有PriorityQueue類
注意:
Queue介面與List、Set同一級別，都是繼承了collection介面。
看圖你會發現,LinkedList既可以實現Queue介面,也可以實現List介面.只不過呢, LinkedList實現了Queue介面。Queue介面窄化了對LinkedList的方法的訪問許可權（即在方法中的引數型別如果是Queue時，就完全只能訪問Queue介面所定義的方法 了，而不能直接訪問 LinkedList的非Queue的方法），以使得只有恰當的方法才可以使用。
SortedSet是個介面，它裡面的（只有TreeSet這一個實現可用）中的元素一定是有序的。
總結:
connection介面(注意首字母小寫):
— List 有序,可重複
ArrayList
優點: 底層資料結構是陣列，查詢快，增刪慢。
缺點: 執行緒不安全，效率高
Vector
優點: 底層資料結構是陣列，查詢快，增刪慢。
缺點: 執行緒安全，效率低
LinkedList
優點: 底層資料結構是連結串列，查詢慢，增刪快。
缺點: 執行緒不安全，效率高
—Set 無序,唯一
HashSet
底層資料結構是雜湊表。(無序,唯一)
如何來保證元素唯一性?
1.依賴兩個方法：hashCode()和equals()
LinkedHashSet
底層資料結構是連結串列和雜湊表。(FIFO插入有序,唯一)
1.由連結串列保證元素有序
2.由雜湊表保證元素唯一
TreeSet
底層資料結構是紅黑樹。(唯一，有序)
1. 如何保證元素排序的呢?
自然排序
比較器排序
2.如何保證元素唯一性的呢?
根據比較的返回值是否是0來決定
針對collection集合我們到底使用誰呢?(掌握)
唯一嗎?
是：Set
排序嗎?
是：TreeSet或LinkedHashSet
否：HashSet
如果你知道是Set，但是不知道是哪個Set，就用HashSet。
否：List
要安全嗎?
是：Vector
否：ArrayList或者LinkedList
查詢多：ArrayList
增刪多：LinkedList
如果你知道是List，但是不知道是哪個List，就用ArrayList。
如果你知道是collection集合，但是不知道使用誰，就用ArrayList。
如果你知道用集合，就用ArrayList。
說完了collection,來簡單說一下Map.
Map介面:
上圖:
Map介面有三個比較重要的實現類，分別是HashMap、TreeMap和HashTable。
TreeMap是有序的，HashMap和HashTable是無序的。
Hashtable的方法是同步的，HashMap的方法不是同步的。這是兩者最主要的區別。
這就意味著:
Hashtable是執行緒安全的，HashMap不是執行緒安全的。
HashMap效率較高，Hashtable效率較低。
如果對同步性或與遺留程式碼的相容性沒有任何要求，建議使用HashMap。 檢視Hashtable的原始碼就可以發現，除建構函式外，Hashtable的所有 public 方法宣告中都有 synchronized關鍵字，而HashMap的原始碼中則沒有。
Hashtable不允許null值，HashMap允許null值（key和value都允許）
父類不同：Hashtable的父類是Dictionary，HashMap的父類是AbstractMap
重點問題重點分析:
(一).TreeSet, LinkedHashSet and HashSet 的區別
1. 介紹
TreeSet, LinkedHashSet and HashSet 在java中都是實現Set的資料結構
TreeSet的主要功能用於排序
LinkedHashSet的主要功能用於保證FIFO即有序的集合(先進先出)
HashSet只是通用的儲存資料的集合
2. 相同點
Duplicates elements: 因為三者都實現Set interface，所以三者都不包含duplicate elements
Thread safety: 三者都不是執行緒安全的，如果要使用執行緒安全可以collections.synchronizedSet()
3. 不同點
Performance and Speed: HashSet插入資料最快，其次LinkHashSet，最慢的是TreeSet因為內部實現排序
Ordering: HashSet不保證有序，LinkHashSet保證FIFO即按插入順序排序，TreeSet安裝內部實現排序，也可以自定義排序規則
null:HashSet和LinkHashSet允許存在null資料，但是TreeSet中插入null資料時會報NullPointerException
4. 程式碼比較
public static void main(String args[]) {
HashSet<String> hashSet = new HashSet<>();
LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
TreeSet<String> treeSet = new TreeSet<>();
for (String data : Arrays.asList("B", "E", "D", "C", "A")) {
hashSet.add(data);
linkedHashSet.add(data);
treeSet.add(data);
}
//不保證有序
System.out.println("Ordering in HashSet :" + hashSet);
//FIFO保證安裝插入順序排序
System.out.println("Order of element in LinkedHashSet :" + linkedHashSet);
//內部實現排序
System.out.println("Order of objects in TreeSet :" + treeSet);
}
執行結果:
Ordering in HashSet :[A, B, C, D, E] (無順序)
Order of element in LinkedHashSet :[B, E, D, C, A] (FIFO插入有序)
Order of objects in TreeSet :[A, B, C, D, E] (排序)
(二).TreeSet的兩種排序方式比較
1.排序的引入(以基本資料型別的排序為例)
由於TreeSet可以實現對元素按照某種規則進行排序，例如下面的例子
public class MyClass {
public static void main(String[] args) {
// 建立集合物件
// 自然順序進行排序
TreeSet<Integer> ts = new TreeSet<Integer>();
// 建立元素並新增
// 20,18,23,22,17,24,19,18,24
ts.add(20);
ts.add(18);
ts.add(23);
ts.add(22);
ts.add(17);
ts.add(24);
ts.add(19);
ts.add(18);
ts.add(24);
// 遍歷
for (Integer i : ts) {
System.out.println(i);
}
}
}
執行結果:
17
18
19
20
22
23
24
2.如果是引用資料型別呢,比如自定義物件,又該如何排序呢?
測試類:
public class MyClass {
public static void main(String[] args) {
TreeSet<Student> ts=new TreeSet<Student>();
//建立元素物件
Student s1=new Student("zhangsan",20);
Student s2=new Student("lis",22);
Student s3=new Student("wangwu",24);
Student s4=new Student("chenliu",26);
Student s5=new Student("zhangsan",22);
Student s6=new Student("qianqi",24);
//將元素物件新增到集合物件中
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
ts.add(s5);
ts.add(s6);
//遍歷
for(Student s:ts){
System.out.println(s.getName()+"-----------"+s.getAge());
}
}
}
Student.java:
public class Student {
private String name;
private int age;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
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;
}
}
結果報錯:
原因分析：
由於不知道該安照那一中排序方式排序，所以會報錯。
解決方法：
1.自然排序
2.比較器排序
(1).自然排序
自然排序要進行一下操作：
1.Student類中實現 Comparable介面
2.重寫Comparable介面中的Compareto方法
compareTo(T o) 比較此物件與指定物件的順序。
public class Student implements Comparable<Student>{
private String name;
private int age;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
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;
}
@Override
public int compareTo(Student s) {
//return -1; //-1表示放在紅黑樹的左邊,即逆序輸出
//return 1; //1表示放在紅黑樹的右邊，即順序輸出
//return o; //表示元素相同，僅存放第一個元素
//主要條件 姓名的長度,如果姓名長度小的就放在左子樹，否則放在右子樹
int num=this.name.length()-s.name.length();
//姓名的長度相同，不代表內容相同,如果按字典順序此 String 物件位於引數字串之前，則比較結果為一個負整數。
//如果按字典順序此 String 物件位於引數字串之後，則比較結果為一個正整數。
//如果這兩個字串相等，則結果為 0
int num1=num==0?this.name.compareTo(s.name):num;
//姓名的長度和內容相同，不代表年齡相同，所以還要判斷年齡
int num2=num1==0?this.age-s.age:num1;
return num2;
}
}
執行結果:
lis-----------22
qianqi-----------24
wangwu-----------24
chenliu-----------26
zhangsan-----------20
zhangsan-----------22
(2).比較器排序
比較器排序步驟：
1.單獨建立一個比較類，這裡以MyComparator為例，並且要讓其繼承Comparator介面
2.重寫Comparator介面中的Compare方法
compare(T o1,T o2) 比較用來排序的兩個引數。
3.在主類中使用下面的 構造方法
TreeSet(Comparator<? superE> comparator)
構造一個新的空 TreeSet，它根據指定比較器進行排序。
1
測試類:
public class MyClass {
public static void main(String[] args) {
//建立集合物件
//TreeSet(Comparator<? super E> comparator) 構造一個新的空 TreeSet，它根據指定比較器進行排序。
TreeSet<Student> ts=new TreeSet<Student>(new MyComparator());
//建立元素物件
Student s1=new Student("zhangsan",20);
Student s2=new Student("lis",22);
Student s3=new Student("wangwu",24);
Student s4=new Student("chenliu",26);
Student s5=new Student("zhangsan",22);
Student s6=new Student("qianqi",24);
//將元素物件新增到集合物件中
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
ts.add(s5);
ts.add(s6);
//遍歷
for(Student s:ts){
System.out.println(s.getName()+"-----------"+s.getAge());
}
}
}
Student.java:
public class Student {
private String name;
private int age;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
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;
}
}
MyComparator類：
public class MyComparator implements Comparator<Student> {
@Override
public int compare(Student s1,Student s2) {
// 姓名長度
int num = s1.getName().length() - s2.getName().length();
// 姓名內容
int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
// 年齡
int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
return num3;
}
}
執行結果:
lis-----------22
qianqi-----------24
wangwu-----------24
chenliu-----------26
zhangsan-----------20
zhangsan-----------22
(三). 效能測試
物件類:
class Dog implements Comparable<Dog> {
int size;
public Dog(int s) {
size = s;
}
public String toString() {
return size + "";
}
@Override
public int compareTo(Dog o) {
//數值大小比較
return size - o.size;
}
}
主類:
public class MyClass {
public static void main(String[] args) {
Random r = new Random();
HashSet<Dog> hashSet = new HashSet<Dog>();
TreeSet<Dog> treeSet = new TreeSet<Dog>();
LinkedHashSet<Dog> linkedSet = new LinkedHashSet<Dog>();
// start time
long startTime = System.nanoTime();
for (int i = 0; i < 1000; i++) {
int x = r.nextInt(1000 - 10) + 10;
hashSet.add(new Dog(x));
}
// end time
long endTime = System.nanoTime();
long duration = endTime - startTime;
System.out.println("HashSet: " + duration);
// start time
startTime = System.nanoTime();
for (int i = 0; i < 1000; i++) {
int x = r.nextInt(1000 - 10) + 10;
treeSet.add(new Dog(x));
}
// end time
endTime = System.nanoTime();
duration = endTime - startTime;
System.out.println("TreeSet: " + duration);
// start time
startTime = System.nanoTime();
for (int i = 0; i < 1000; i++) {
int x = r.nextInt(1000 - 10) + 10;
linkedSet.add(new Dog(x));
}
// end time
endTime = System.nanoTime();
duration = endTime - startTime;
System.out.println("LinkedHashSet: " + duration);
}
}
執行結果:
HashSet: 1544313
TreeSet: 2066049