第9章 持有你的对象
一. 容器简介
1. 容器的分类
1.1. Collection:一组各自独立的元素,即其内的每个位置仅持有一个元素。
1) List:以元素安插的次序来放置元素,不会重新排列。
2) Set:不接爱重复元素,它会使用自己内部的一个排列机制
1.2. Map:一群成对的key-value对象,即所持有的是key-value pairs。
Map中不能有重复的key,它拥有自己的内部排列机制。
2. 容器中的元素类型都为Object。从容器取得元素时,必须把它转换成原来的类型。
二. 容器的详细介绍
1. Collection
Collection不提供get()方法。如果要遍历Collectin中的元素,就必须用Iterator。
1.1. List
1.1.1 List (interface):List为Collectin加入了一些函数,使它可以在List内进行安插和移除动作。List会产生 ListIterator,通过它可以从两个方向来对List进行走访,也可以在List之内进行元素的安插和移除。
1.1.2 ArrayList:可以快速随机访问;但当元素的安插或移除发生在List中央位置时,效率很差。不宜用ArrayList来进行安插和移除操作。
1.1.3 LinkedList:与ArrayList相反,适合用来进行安插和移除,但随机访问的速度较慢。此外,可以通过LinkedList来实现stack、queue、deque。
1) LinkedList中的addFirst()、addLast()、getFirst()、getLast()、removeFirst()、 removeLast()函数未定义于任何一个interface或base class中,所以只能用于LinkedList中。
1.2. Set
1.2.1 Set (interface):Set具有和Collection一模一样的interface(区别:List加入了自己的函数),所以Set就是一个 Collection,只不过其行为不同罢了。加至Set内的每个元素都必须独一无二,不与其他元素重复;Set不允许持有重复元素,每个元素都必须定义 equals()以判断所谓的独一性。
1.2.2 HashSet:一种把查找时间看得很重要的Sets。所有元素都必须定义hashCode()。
1.2.3 TreeSet:底层结构为tree的一种有序的Set。
2. Map
2.1. Map:维护key-value的关联性,使你可以使用key来查找value。
1) KeySet()函数和values()函数
- import java.util.*;
- public class ExplicitStatic{
- public static void printKeys(Map m){
- System.out.print("Size = " + m.size());
- System.out.println(" , Keys: " + m.keySet());
- }
- public static void printValues(Map m){
- System.out.println("Values: " + m.values());
- }
- public static void test(Map m){
- for( int i=1; i<10; i++)
- m.put("km" + i, "m" + i);
- printKeys(m);
- printValues(m);
- System.out.println("km1 - " + m.get("km1"));
- Set keys = m.keySet(); //(1)
- Collection values = m.values(); //(2)
- keys.remove("km2"); //(3)
- values.remove("m1"); //(4)
- System.out.println("km1 - " + m.get("km1"));
- printKeys(m);
- printValues(m);
- }
- public static void main(String[] args){
- System.out.println("Testing HashMap");
- test(new HashMap());
- }
- }
结果为:
Testing HashMap
Size = 9 , Keys: [km5, km4, km3, km2, km1, km9, km8, km7, km6]
Values: [m5, m4, m3, m2, m1, m9, m8, m7, m6]
km1 - m1 //执行(3)(4)之前
km1 - null
Size = 7 , Keys: [km5, km4, km3, km9, km8, km7, km6] //(5)
Values: [m5, m4, m3, m9, m8, m7, m6] //(6)
在(1)(2)处代码分别得到了Map中的keys和values。从执行(3)(4)前后的代码可知,对通过keySet()和values()函数取得的值进行修改会反映到Map本身。
(3)中删除的是值为“km2”的key,(4)删除的是值为“m1”的value,且它们是同一个key-value pair,但结果(5)(6)表明, Map中删除的是两个key-pair。从而可知,只要删除了Map中的key或value中的一个,那么整个key-value pair就会被删除。
2.2. HashMap:可在常量时间内安插元素,或找出一组key-value pair。通过其构造函数,使用者可以调整效能表现,因为它允许你设定capacity(容量)和loadfactor(负载因子)。
2.3. TreeMap:当你检视其中的key或key-value pairs时,会以排序形式出现,让你得到以排序形式得到结果。TreeMap是惟一具有subMap()的一个Map,这个函数让你得以返回tree中的部分组成。
三. HashMap的工作原理
1. 如何实现一个Map
1.1 与Map相关的知识
1.1.1 Map.Entry接口
一个实现了Map.Entry接口的类代表的是一个Map中的条目(一个key-value pair)。所以一个Map中必须要有一个实现了Map.Entry接口的类,并用这个类来存放Map中的key-value pair。
1.1.2 public abstract Set entrySet()函数
1) entrySet()函数返回一个Set,并且Set中的每一个元素都是一个Map.Entry类型的对象。在entrySet()函数中要把Map中所有的key-value pair以Map.Entry封装后存入Set中的。
2) 当对Map进行修改操作后,entrySet()函数都会被调用。所以对Map的修改也会产生对这个Set的修改。
3) 当用这个Set的iterator进行操作时,不能进行add和addAll的操作。
1.2 实现一个简单的Map的实例
- import java.util.*;
- /**
- * MPair类实现了Map.Entry
- */
- class MPair
- implements Map.Entry, Comparable{
- Object key, value; //key和value分别用来存放Map中的key和value
- MPair(Object k, Object v){
- key = k;
- value = v;
- }
- //下面方法实现了Map.Entry接口中的方法
- public Object getKey() { return key; }
- public Object getValue() { return value; }
- public Object setValue(Object v){
- Object result = value;
- value = v;
- return result;
- }
- //下面方法实现了Comparable接口中的方法
- public boolean equals(Object o){
- return key.equals(((MPair)o).key);
- }
- public int compareTo(Object rv){
- return ((Comparable)key).compareTo(((MPair)rv).key);
- }
- }
- class SlowMap extends AbstractMap{
- private ArrayList
- keys = new ArrayList(),
- values = new ArrayList();
- public Object put(Object key, Object value){
- Object result = get(key);
- if(!keys.contains(key)){ //(1)
- keys.add(key);
- values.add(value);
- }
- else
- values.set(keys.indexOf(key), value);
- return result;
- }
- public Object get(Object key){
- if(!keys.contains(key)){
- return null;
- }
- else
- return values.get(keys.indexOf(key));
- }
- //用Mpair封装Map中的key-value pair并存入Set中
- public Set entrySet(){
- Set entries = new HashSet();
- Iterator
- ki = keys.iterator(),
- vi = values.iterator();
- while(ki.hasNext())
- entries.add(new MPair(ki.next(), vi.next()));
- return entries;
- }
- }
- public class ExplicitStatic{
- public static void main(String[] args){
- SlowMap m = new SlowMap();
- for( int i=1; i<10; i++)
- m.put("km" + i, "m" + i);
- System.out.println(m);
- }
- }
在上面代码的(1)处,我们要从ArrayList中查找出是否具有key值,而这个查找过程线性查找,且key不具任何顺序,所以速度会很慢。
2. 与HashMap相关的几个函数
1) hashCode()函数
Object.hashCode()函数会为对象产生hash code。如果一个类没有实现hashCode()函数,那么在缺省情况下将返回它的对象的内存地址。
2) equals()函数
Object.equals()在比较两个对象时,比较的是两个对象的内存地址。
3. HashMap的工作原理
3.1 用array来表现key的信息。每个key的hashCode()函数会为key产生一个hash code,而key的hash code作为 array的索引。如假设有一个名为bucket的arrsy,姥一个hash code为2的key就被索引到bucket[2],key所对应的值也在bucket[2]中。
3.1 由于array中存放的是value值,而HashMap的元素个数可以是无限的,所以array中的元素指向的不是某个key的value,而是指向具有相同的hash code的key的value值(也就是说指向的是一串values值)。如假设 array被定义为LinkedList []bucket = new LinkedList[10],那么bucket[2]中存放的是所有hash code值为2的key的value。
4. 自己实现一个简单的HashMap及其原理
4.1 在put()方法中:
1) 首先通过key得出要插入的key-value pair的hash code,并这个hash code作为索引在数组bucket中找出key所对应的元素。
2) 把要插入的key-value pair封装成实现了Map.Entry接口的类的一个对象。
3) 在操作1)所找出的数组元素(也是一个LinkedList)中查看是否有与要插入的key- value pair的key相同的元素,如果有,则对之进行更新;如果无,则把要插入的key-value pair数组元素中。
4.2 在get()方法中
1) 首先通过key得出要查找的key-value pair的hash code,并这个hash code作为索引在数组bucket中找出key所对应的元素。
2) 把要查找的key-value pair的key封装成实现了Map.Entry接口的类的一个对象。
3) 在操作1)所找出的数组元素(也是一个LinkedList)中查看是否有与要插入的key-value pair的key相同的元素,如果有,则返回key所对应的value;如果无,则返回一个null。
4.3 一个实例
- import java.util.*;
- /**
- * MPair类实现了Map.Entry
- */
- class MPair
- implements Map.Entry, Comparable{
- Object key, value;
- MPair(Object k, Object v){
- key = k;
- value = v;
- }
- public Object getKey() { return key; }
- public Object getValue() { return value; }
- public Object setValue(Object v){
- Object result = value;
- value = v;
- return result;
- }
- /**
- * 当比较两个MPair对象时,比较的是它们的key值
- */
- public boolean equals(Object o){
- return key.equals(((MPair)o).key);
- }
- public int compareTo(Object rv){
- return (((Comparable)key).compareTo(((MPair)rv).key));
- }
- }
- class SimpleHashMap extends AbstractMap{
- private final static int SZ = 997;
- private LinkedList[] bucket = new LinkedList[SZ];
- /**
- * 把key和value封装成Map.Entry的实现类后插入到array中
- */
- public Object put(Object key, Object value){
- Object result = null;
- //通过key得到要插入的key-value pair的hash code
- int index = key.hashCode() % SZ;
- if(index < 0) index = - index;
- if(bucket[index] == null)
- bucket[index] = new LinkedList();
- //通过hash code找出要插入的key所对应的array中的元素
- LinkedList pairs = bucket[index];
- //把要插入的key-value pair封装成MPair
- MPair pair = new MPair(key, value);
- ListIterator it = pairs.listIterator();
- boolean found = false;
- //检查是否有与要插入的key相同的key存在,如果有,就对之进行更新
- while(it.hasNext()){
- Object iPair = it.next();
- if(iPair.equals(iPair)){
- result = ((MPair)iPair).getValue();
- it.set(pair);
- found = true;
- break;
- }
- }
- //如果无,则把新的key-value pair插入
- if(!found)
- bucket[index].add(pair);
- return result;
- }
- public Object get(Object key){
- int index = key.hashCode() % SZ;
- if(index < 0) index = -index;
- if(bucket[index] == null) return null;
- LinkedList pairs = bucket[index];
- ListIterator it = pairs.listIterator();
- MPair match = new MPair(key, null);
- while(it.hasNext()){
- Object iPair = it.next();
- if(iPair.equals(match))
- return ((MPair)iPair).getValue();
- }
- return null;
- }
- public Set entrySet(){
- Set entries = new HashSet();
- for(int i=0; i<bucket.length; i++){
- if(bucket[i] == null) continue;
- Iterator it = bucket[i].iterator();
- while(it.hasNext())
- entries.add(it.next());
- }
- return entries;
- }
- }
- public class ExplicitStatic{
- public static void main(String[] args){
- SimpleHashMap m = new SimpleHashMap();
- for( int i=1; i<10; i++)
- m.put("km" + i, "m" + i);
- System.out.println(m);
- }
- }
四. HashMap的一些其它讨论
1. 关于HashMap中的key值的使用
1.1. 以Java的库函数做为HashMap的key值时,可以直接使用。
- import java.util.*;
- class Counter{
- int i = 1;
- public String toString(){
- return Integer.toString(i);
- }
- }
- public class ExplicitStatic{
- public static void main(String[] args){
- HashMap hm = new HashMap();
- for(int i = 0; i < 10000; i++)
- {
- //HashMap的key的类型为Integer
- Integer r = new Integer((int) (Math.random() * 20));
- if(hm.containsKey(r))
- ((Counter)hm.get(r)).i++;
- else
- hm.put(r, new Counter());
- }
- System.out.println(hm);
- }
- }
1.2. 如果在HashMap中使用你自己撰写的classes做为key,你一定得同时覆写hashCode()和equals()。
下面代码用自己实现的class做为key,但没有覆写hashCode()和equals()。
- import java.util.*;
- class Groundhog{
- int ghNumber;
- Groundhog(int n) { ghNumber = n; }
- public String toString(){
- return "Groundhog@" + ghNumber;
- }
- }
- class Prediction{
- boolean shadow = Math.random() > 0.5;
- public String toString(){
- if(shadow)
- return "Six more weeks of Winter!/n";
- else
- return "Early Spring!/n";
- }
- }
- public class Test{
- public static void main(String[] args){
- HashMap hm = new HashMap();
- for(int i = 1; i < 10; i++)
- hm.put(new Groundhog(i), new Prediction());
- System.out.println("hm = " + hm);
- System.out.println("Looking up prediction for Groundhog #3:");
- Groundhog gh = new Groundhog(3);
- if(hm.containsKey(gh)) //(1)
- System.out.println((Prediction)hm.get(gh));
- else
- System.out.println("Key not found: " + gh);
- }
- }
运行结果:
hm = {Groundhog@9=Early Spring!
, Groundhog@8=Six more weeks of Winter!
, Groundhog@7=Six more weeks of Winter!
, Groundhog@6=Early Spring!
, Groundhog@5=Early Spring!
, Groundhog@4=Early Spring!
, Groundhog@3=Early Spring!
, Groundhog@2=Early Spring!
, Groundhog@1=Six more weeks of Winter!
}
Looking up prediction for Groundhog #3:
Key not found: Groundhog@3
key 没覆写hashCode()和equals(),那么在通过key取得hash code时,就会取得key的内存地址;同样,当通过equals()函数比较两个key是否相等时,比较的也是两个key的地址。所以(1)处代码比较的结果为false(因为两个对象的内存地址肯定是不相同的)。显然,这不是我们要得到的结果。
为了要得到正确的结果,我们只需在作为key的类中实现hashCode()和equals()。
- java.util.*;
- class Groundhog2{
- int ghNumber;
- Groundhog2(int n) { ghNumber = n; }
- public String toString(){
- return "Groundhog2@" + ghNumber;
- }
- /**
- * 以ghNumber作为hash code
- */
- public int hashCode() { return ghNumber; }
- /**
- *比较的是两个key的ghNumber值
- */
- public boolean equals(Object o)
- {
- return (o instanceof Groundhog2)
- && (ghNumber == ((Groundhog2)o).ghNumber);
- }
- }
- class Prediction{
- boolean shadow = Math.random() > 0.5;
- public String toString(){
- if(shadow)
- return "Six more weeks of Winter!/n";
- else
- return "Early Spring!/n";
- }
- }
- public class Test{
- public static void main(String[] args){
- HashMap hm = new HashMap();
- for(int i = 1; i < 10; i++)
- hm.put(new Groundhog2(i), new Prediction());
- System.out.println("size = " + hm.size() + " , hm = " + hm);
- System.out.println("Looking up prediction for Groundhog #3:");
- Groundhog2 gh = new Groundhog2(2);
- if(hm.containsKey(gh))
- System.out.println((Prediction)hm.get(gh));
- else
- System.out.println("Key not found: " + gh);
- }
- }
运行结果为:
hm = {Groundhog2@9=Early Spring!
, Groundhog2@8=Six more weeks of Winter!
, Groundhog2@7=Six more weeks of Winter!
, Groundhog2@6=Six more weeks of Winter!
, Groundhog2@5=Early Spring!
, Groundhog2@4=Early Spring!
, Groundhog2@3=Six more weeks of Winter!
, Groundhog2@2=Early Spring!
, Groundhog2@1=Early Spring!
}
Looking up prediction for Groundhog #3:
Early Spring!
在新的代码中,我们在作为key的类中实现了hashCode()和equals()函数,得到了想要的结果。
2. HashMap的效能因子
Capacity:容量,表格中的buckets数量
Initial capacity:初始容量,表格建立之初的buckets数量。
HashMap和HashSet:各有构造函数,允许指定初始容量。
Size:大小,表格内目前所有的条目。
Load factor:负载因子,size / capacity(大小/容量)。负载因子为0,表示一个空表格,0.5是一个半满表格,依此类推。一个轻负载表格出现碰撞(collisions)的机会比较低,比较适合安插和查找(但会降低“通过迭代器巡访”的速度)。在HashMap和HashSet各有构造函数中指定了负载因子后,当容器达到这个负载因子,容器的容量(buckets个数)就会自动扩充,并将原有的对象重新导入到新的buckets内(这称为 rechashing)。HashMap缺省的负载因子值是0.75。