集合類
java集合類圖html
java集合類框架圖java
上述類圖中，實線邊框的是實現類，好比ArrayList，LinkedList，HashMap等，折線邊框的是抽象類，好比AbstractCollection，AbstractList，AbstractMap等，而點線邊框的是接口，好比Collection，Iterator，List等。算法
發現一個特色，上述全部的集合類，都實現了Iterator接口，這是一個用於遍歷集合中元素的接口，主要包含hashNext(),next(),remove()三種方法。它的一個子接口LinkedIterator在它的基礎上又添加了三種方法，分別是add(),previous(),hasPrevious()。也就是說若是是先Iterator接口，那麼在遍歷集合中元素的時候，只能日後遍歷，被遍歷後的元素不會在遍歷到，一般無序集合實現的都是這個接口，好比HashSet，HashMap；而那些元素有序的集合，實現的通常都是LinkedIterator接口，實現這個接口的集合能夠雙向遍歷，既能夠經過next()訪問下一個元素，又能夠經過previous()訪問前一個元素，好比ArrayList。數組
還有一個特色就是抽象類的使用。若是要本身實現一個集合類，去實現那些抽象的接口會很是麻煩，工做量很大。這個時候就可使用抽象類，這些抽象類中給咱們提供了許多現成的實現，咱們只須要根據本身的需求重寫一些方法或者添加一些方法就能夠實現本身須要的集合類，工做流昂大大下降。數據結構
2.1HashSet
HashSet是Set接口的一個子類，主要的特色是：裏面不能存放重複元素，並且採用散列的存儲方法，因此沒有順序。這裏所說的沒有順序是指：元素插入的順序與輸出的順序不一致。框架
代碼實例：HashSetDemo
package edu.sjtu.erplab.collection;import java.util.HashSet;import java.util.Iterator;import java.util.Set;public class HashSetDemo { public static void main(String[] args) {
Set<String> set=new HashSet<String>();
set.add("a");
set.add("b");
set.add("c");
set.add("c");
set.add("d");
//使用Iterator輸出集合
Iterator<String> iter=set.iterator(); while(iter.hasNext())
{
System.out.print(iter.next()+" ");
}
System.out.println(); //使用For Each輸出結合
for(String e:set)
{
System.out.print(e+" ");
}
System.out.println();
//使用toString輸出集合 System.out.println(set);
}
}
代碼實例：SetTest
package edu.sjtu.erplab.collection;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.InputStream;import java.util.HashSet;import java.util.Iterator;import java.util.Scanner;import java.util.Set;public class SetTest { public static void main(String[] args) throws FileNotFoundException {
Set<String> words=new HashSet<String>(); //經過輸入流代開文獻 //方法1:這個方法不須要拋出異常
InputStream inStream=SetTest.class.getResourceAsStream("Alice.txt");
//方法2：這個方法須要拋出異常 //InputStream inStream = new FileInputStream("D:\\Documents\\workspace\\JAVAStudy\\src\\edu\\sjtu\\erplab\\collection\\Alice.txt");
Scanner in=new Scanner(inStream); while(in.hasNext())
{
words.add(in.next());
}
Iterator<String> iter=words.iterator();
for(int i=0;i<5;i++)
{ if(iter.hasNext())
System.out.println(iter.next());
}
System.out.println(words.size());
}
}
2.2ArrayList
ArrayList是List的子類，它和HashSet想法，容許存放重複元素，所以有序。集合中元素被訪問的順序取決於集合的類型。若是對ArrayList進行訪問，迭代器將從索引0開始，每迭代一次，索引值加1。然而，若是訪問HashSet中的元素，每一個元素將會按照某種隨機的次序出現。雖然能夠肯定在迭代過程當中可以遍歷到集合中的全部元素，但卻沒法預知元素被訪問的次序。函數
代碼實例：ArrayListDemo
package edu.sjtu.erplab.collection;import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class ArrayListDemo { public static void main(String[] args) {
List<String> arrList=new ArrayList<String>();
arrList.add("a");
arrList.add("b");
arrList.add("c");
arrList.add("c");
arrList.add("d"); //使用Iterator輸出集合
Iterator<String> iter=arrList.iterator(); while(iter.hasNext())
{
System.out.print(iter.next()+" ");
}
System.out.println(); //使用For Each輸出結合
for(String e:arrList)
{
System.out.print(e+" ");
}
System.out.println();
//使用toString輸出集合 System.out.println(arrList);
}
}
2.3LinkedList
LinkedList是一種能夠在任何位置進行高效地插入和刪除操做的有序序列。性能
代碼實例：LinkedListTest
package edu.sjtu.erplab.collection;import java.util.ArrayList;import java.util.Iterator;import java.util.List;import java.util.ListIterator;public class LinkedListTest { public static void main(String[] args) {
List<String> a=new ArrayList<String>();
a.add("a");
a.add("b");
a.add("c");
System.out.println(a);
List<String> b=new ArrayList<String>();
b.add("d");
b.add("e");
b.add("f");
b.add("g");
System.out.println(b);
//ListIterator在Iterator基礎上添加了add(),previous()和hasPrevious()方法
ListIterator<String> aIter=a.listIterator(); //普通的Iterator只有三個方法，hasNext()，next()和remove()
Iterator<String> bIter=b.iterator();
//b歸併入a當中，間隔交叉得插入b中的元素
while(bIter.hasNext())
{ if(aIter.hasNext())
aIter.next();
aIter.add(bIter.next());
}
System.out.println(a);
//在b中每隔兩個元素刪除一個
bIter=b.iterator();
while(bIter.hasNext())
{
bIter.next(); if(bIter.hasNext())
{
bIter.next();//remove跟next是成對出現的，remove老是刪除前序 bIter.remove();
}
}
System.out.println(b);
//刪除a中全部的b中的元素 a.removeAll(b);
System.out.println(a);
}
}
2.4HashMap
HashMap的數據結構
數組的特色是：尋址容易，插入和刪除困難；而鏈表的特色是：尋址困難，插入和刪除容易。那麼咱們能不能綜合二者的特性，作出一種尋址容易，插入刪除也容易的數據結構？答案是確定的，這就是咱們要提起的哈希表，哈希表有多種不一樣的實現方法，我接下來解釋的是最經常使用的一種方法—— 拉鍊法，咱們能夠理解爲「鏈表的數組」 ，如圖：優化
從上圖咱們能夠發現哈希表是由數組+鏈表組成的，一個長度爲16的數組中，每一個元素存儲的是一個鏈表的頭結點。那麼這些元素是按照什麼樣的規則存儲到數組中呢。通常狀況是經過hash(key)%len得到，也就是元素的key的哈希值對數組長度取模獲得。好比上述哈希表中，12%16=12,28%16=12,108%16=12,140%16=12。因此十二、2八、108以及140都存儲在數組下標爲12的位置。this
HashMap其實也是一個線性的數組實現的,因此能夠理解爲其存儲數據的容器就是一個線性數組。這可能讓咱們很不解，一個線性的數組怎麼實現按鍵值對來存取數據呢？這裏HashMap有作一些處理。
1.首先HashMap裏面實現一個靜態內部類Entry，其重要的屬性有 key , value, next，從屬性key,value咱們就能很明顯的看出來Entry就是HashMap鍵值對實現的一個基礎bean，咱們上面說到HashMap的基礎就是一個線性數組，這個數組就是Entry[]，Map裏面的內容都保存在Entry[]裏面。
2.HashMap的存取實現
既然是線性數組，爲何能隨機存取？這裏HashMap用了一個小算法，大體是這樣實現：
//存儲時:int hash = key.hashCode();// 這個hashCode方法這裏不詳述,只要理解每一個key的hash是一個固定的int值int index = hash % Entry[].length; Entry[index] = value;//取值時:int hash = key.hashCode();int index = hash % Entry[].length;return Entry[index];
到這裏咱們輕鬆的理解了HashMap經過鍵值對實現存取的基本原理
3.疑問：若是兩個key經過hash%Entry[].length獲得的index相同，會不會有覆蓋的危險？
這裏HashMap裏面用到鏈式數據結構的一個概念。上面咱們提到過Entry類裏面有一個next屬性，做用是指向下一個Entry。打個比方， 第一個鍵值對A進來，經過計算其key的hash獲得的index=0，記作:Entry[0] = A。一會後又進來一個鍵值對B，經過計算其index也等於0，如今怎麼辦？HashMap會這樣作:B.next = A,Entry[0] = B,若是又進來C,index也等於0,那麼C.next = B,Entry[0] = C；這樣咱們發現index=0的地方其實存取了A,B,C三個鍵值對,他們經過next這個屬性連接在一塊兒。因此疑問不用擔憂。也就是說數組中存儲的是最後插入的元素。到這裏爲止，HashMap的大體實現，咱們應該已經清楚了。
固然HashMap裏面也包含一些優化方面的實現，這裏也說一下。好比：Entry[]的長度必定後，隨着map裏面數據的愈來愈長，這樣同一個index的鏈就會很長，會不會影響性能？HashMap裏面設置一個因素（也稱爲因子），隨着map的size愈來愈大，Entry[]會以必定的規則加長長度。
3.解決hash衝突的辦法
開放定址法（線性探測再散列，二次探測再散列，僞隨機探測再散列）
再哈希法
鏈地址法
創建一個公共溢出區
Java中hashmap的解決辦法就是採用的鏈地址法。
4.實現本身的HashMap
Entry.java
package edu.sjtu.erplab.hash;public class Entry<K,V>{ final K key;
V value;
Entry<K,V> next;//下一個結點
//構造函數
public Entry(K k, V v, Entry<K,V> n) {
key = k;
value = v;
next = n;
} public final K getKey() { return key;
} public final V getValue() { return value;
} public final V setValue(V newValue) {
V oldValue = value;
value = newValue; return oldValue;
} public final boolean equals(Object o) { if (!(o instanceof Entry)) return false;
Entry e = (Entry)o;
Object k1 = getKey();
Object k2 = e.getKey(); if (k1 == k2 || (k1 != null && k1.equals(k2))) {
Object v1 = getValue();
Object v2 = e.getValue(); if (v1 == v2 || (v1 != null && v1.equals(v2))) return true;
} return false;
} public final int hashCode() { return (key==null ? 0 : key.hashCode()) ^ (value==null ? 0 : value.hashCode());
} public final String toString() { return getKey() + "=" + getValue();
}
}
MyHashMap.java
package edu.sjtu.erplab.hash;//保證key與value不爲空public class MyHashMap<K, V> { private Entry[] table;//Entry數組表
static final int DEFAULT_INITIAL_CAPACITY = 16;//默認數組長度
private int size; // 構造函數
public MyHashMap() {
table = new Entry[DEFAULT_INITIAL_CAPACITY];
size = DEFAULT_INITIAL_CAPACITY;
} //獲取數組長度
public int getSize() { return size;
}
// 求index
static int indexFor(int h, int length) { return h % (length - 1);
} //獲取元素
public V get(Object key) { if (key == null) return null; int hash = key.hashCode();// key的哈希值
int index = indexFor(hash, table.length);// 求key在數組中的下標
for (Entry<K, V> e = table[index]; e != null; e = e.next) {
Object k = e.key; if (e.key.hashCode() == hash && (k == key || key.equals(k))) return e.value;
} return null;
} // 添加元素
public V put(K key, V value) { if (key == null) return null; int hash = key.hashCode(); int index = indexFor(hash, table.length); // 若是添加的key已經存在，那麼只須要修改value值便可
for (Entry<K, V> e = table[index]; e != null; e = e.next) {
Object k = e.key; if (e.key.hashCode() == hash && (k == key || key.equals(k))) {
V oldValue = e.value;
e.value = value; return oldValue;// 原來的value值 }
} // 若是key值不存在，那麼須要添加
Entry<K, V> e = table[index];// 獲取當前數組中的e
table[index] = new Entry<K, V>(key, value, e);// 新建一個Entry，並將其指向原先的e
return null;
}
}
MyHashMapTest.java
package edu.sjtu.erplab.hash;public class MyHashMapTest { public static void main(String[] args) {
MyHashMap<Integer, Integer> map = new MyHashMap<Integer, Integer>();
map.put(1, 90);
map.put(2, 95);
map.put(17, 85);
System.out.println(map.get(1));
System.out.println(map.get(2));
System.out.println(map.get(17));
System.out.println(map.get(null));
}
}
2.5WeekHashMapDemo
package edu.sjtu.erplab.collection;import java.util.WeakHashMap;public class WeekHashMapDemo { public static void main(String[] args) { int size = 100; if (args.length > 0) {
size = Integer.parseInt(args[0]);
}
Key[] keys = new Key[size];
WeakHashMap<Key, Value> whm = new WeakHashMap<Key, Value>(); for (int i = 0; i < size; i++) {
Key k = new Key(Integer.toString(i));
Value v = new Value(Integer.toString(i)); if (i % 3 == 0) {
keys[i] = k;//強引用 }
whm.put(k, v);//全部鍵值放入WeakHashMap中 }
System.out.println(whm);
System.out.println(whm.size());
System.gc();
try { // 把處理器的時間讓給垃圾回收器進行垃圾回收
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(whm);
System.out.println(whm.size());
}
}class Key {
String id; public Key(String id) { this.id = id;
} public String toString() { return id;
} public int hashCode() { return id.hashCode();
} public boolean equals(Object r) { return (r instanceof Key) && id.equals(((Key) r).id);
} public void finalize() {
System.out.println("Finalizing Key " + id);
}
}class Value {
String id; public Value(String id) { this.id = id;
} public String toString() { return id;
} public void finalize() {
System.out.println("Finalizing Value " + id);
}
}
輸出結果
{50=50, 54=54, 53=53, 52=52, 51=51, 46=46, 47=47, 44=44, 45=45, 48=48, 49=49, 61=61, 60=60, 63=63, 62=62, 65=65, 64=64, 55=55, 56=56, 57=57, 58=58, 59=59, 76=76, 75=75, 74=74, 73=73, 72=72, 71=71, 70=70, 68=68, 69=69, 66=66, 67=67, 85=85, 84=84, 87=87, 86=86, 81=81, 80=80, 83=83, 82=82, 77=77, 78=78, 79=79, 89=89, 88=88, 10=10, 90=90, 91=91, 92=92, 93=93, 94=94, 95=95, 96=96, 97=97, 98=98, 99=99, 20=20, 21=21, 12=12, 11=11, 14=14, 13=13, 16=16, 15=15, 18=18, 17=17, 19=19, 8=8, 9=9, 31=31, 4=4, 32=32, 5=5, 6=6, 30=30, 7=7, 0=0, 1=1, 2=2, 3=3, 29=29, 28=28, 27=27, 26=26, 25=25, 24=24, 23=23, 22=22, 40=40, 41=41, 42=42, 43=43, 38=38, 37=37, 39=39, 34=34, 33=33, 36=36, 35=35}
100
Finalizing Key 98
Finalizing Key 97
Finalizing Key 95
Finalizing Key 94
Finalizing Key 92
Finalizing Key 91
Finalizing Key 89
Finalizing Key 88
Finalizing Key 86
Finalizing Key 85
Finalizing Key 83
Finalizing Key 82
Finalizing Key 80
Finalizing Key 79
Finalizing Key 77
Finalizing Key 76
Finalizing Key 74
Finalizing Key 73
Finalizing Key 71
Finalizing Key 70
Finalizing Key 68
Finalizing Key 67
Finalizing Key 65
Finalizing Key 64
Finalizing Key 62
Finalizing Key 61
Finalizing Key 59
Finalizing Key 58
Finalizing Key 56
Finalizing Key 55
Finalizing Key 53
Finalizing Key 52
Finalizing Key 50
Finalizing Key 49
Finalizing Key 47
Finalizing Key 46
Finalizing Key 44
Finalizing Key 43
Finalizing Key 41
Finalizing Key 40
Finalizing Key 38
Finalizing Key 37
Finalizing Key 35
Finalizing Key 34
Finalizing Key 32
Finalizing Key 31
Finalizing Key 29
Finalizing Key 28
Finalizing Key 26
Finalizing Key 25
Finalizing Key 23
Finalizing Key 22
Finalizing Key 20
Finalizing Key 19
Finalizing Key 17
Finalizing Key 16
Finalizing Key 14
Finalizing Key 13
Finalizing Key 11
Finalizing Key 10
Finalizing Key 8
Finalizing Key 7
Finalizing Key 5
Finalizing Key 4
Finalizing Key 2
Finalizing Key 1
{54=54, 51=51, 45=45, 48=48, 60=60, 63=63, 57=57, 75=75, 72=72, 69=69, 66=66, 84=84, 87=87, 81=81, 78=78, 90=90, 93=93, 96=96, 99=99, 21=21, 12=12, 15=15, 18=18, 9=9, 6=6, 30=30, 0=0, 3=3, 27=27, 24=24, 42=42, 39=39, 33=33, 36=36}
34
3.比較
相關文章
- 1. 集合類——Set集合
- 2. 006-guava 集合-集合工具類-集合擴展工具類
- 3. Java集合類
- 4. 集合類MixedCollection
- 5. 集合類型
- 6. java集合類
- 7. 集合類
- 8. Collection集合類
- 9. C#集合類
- 10. 集合類（一）
- 更多相關文章...
- • Scala Set(集合) - Scala教程
- • C# 集合（Collection） - C#教程
- • Kotlin學習（二）基本類型
- • ☆技術問答集錦（13）Java Instrument原理
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. No provider available from registry 127.0.0.1:2181 for service com.ddbuy.ser 解決方法
- 2. Qt5.7以上調用虛擬鍵盤(支持中文)，以及源碼修改(可拖動，水平縮放)
- 3. 軟件測試面試- 購物車功能測試用例設計
- 4. ElasticSearch（概念篇）：你知道的, 爲了搜索…
- 5. redux理解
- 6. gitee創建第一個項目
- 7. 支持向量機之硬間隔（一步步推導，通俗易懂）
- 8. Mysql 異步複製延遲的原因及解決方案
- 9. 如何在運行SEPM配置嚮導時將不可認的複雜數據庫密碼改爲簡單密碼
- 10. windows系統下tftp服務器使用
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 集合類——Set集合
- 2. 006-guava 集合-集合工具類-集合擴展工具類
- 3. Java集合類
- 4. 集合類MixedCollection
- 5. 集合類型
- 6. java集合類
- 7. 集合類
- 8. Collection集合類
- 9. C#集合類
- 10. 集合類（一）