tij读书笔记3

最新推荐文章于 2020-08-10 20:14:16 发布

lannos

最新推荐文章于 2020-08-10 20:14:16 发布

阅读量977

点赞数

文章标签：读书 hashmap object pair equals system

本文链接：https://blog.csdn.net/lannos/article/details/277290

版权

第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。