HashMap封装类CaseInsensitiveHashMap

根据这个方法的注释说明，它根据列名获取值，是大小写无关的，实际上一般的Map不可能做到这一点，因为Java是个区分大小写的语言，所以，它肯定对Map进行了封装。实际上呢，这个类里面有个静态的内部类CaseInsensitiveHashMap，真正的奥秘就在这里！这里我把它移出来了，现对此Map的分析如下：

   

Java代码  

1. /** 
2.  * 为了不区分大小写查找而将所有的key转换为小写字符串的Map. 
3.  * 这个HashMap的实现不允许键值为null,因为我们要将所有的键值变为小写， 
4.  *  即调用key.toString().toLowerCase(). 
5.  */  
6. private static class CaseInsensitiveHashMap extends HashMap<String, Object> {  
7.     /** 
8.      * 以小写字母为键值的内部Map集合 
9.      * 所有的查询操作步骤操作经过以下三步： 
10.      * 1）、将参数Key转换为小写 
11.      * 2）、获取小写Key获取真实Key 
12.          * 3）、通过真实的Key值获取到值 
13.      */  
14.     private final Map<String,String> lowerCaseMap = new HashMap<String,String>();  
15.   
16.     /** 
17.      * Required for serialization support. 
18.      *  
19.      * @see java.io.Serializable 
20.      */   
21.     private static final long serialVersionUID = -2848100435296897392L;  
22.   
23.     @Override  
24.     public boolean containsKey(Object key) {  
25.         Object realKey = lowerCaseMap.get(key.toString().toLowerCase());  
26.         return super.containsKey(realKey);  
27.         // Possible optimisation here:  
28.         // Since the lowerCaseMap contains a mapping for all the keys,  
29.         // we could just do this:  
30.         // return lowerCaseMap.containsKey(key.toString().toLowerCase());  
31.     }  
32.   
33.     @Override  
34.     public Object get(Object key) {  
35.         Object realKey = lowerCaseMap.get(key.toString().toLowerCase());//获取真正的Key值，然后回去值  
36.         return super.get(realKey);  
37.     }  
38.   
39.     @Override  
40.     public Object put(String key, Object value) {  
41.         /* 
42.          * In order to keep the map and lowerCaseMap synchronized, 
43.          * we have to remove the old mapping before putting the  
44.          * new one. Indeed, oldKey and key are not necessaliry equals. 
45.          * (That's why we call super.remove(oldKey) and not just 
46.          * super.put(key, value)) 
47.          */  
48.         Object oldKey = lowerCaseMap.put(key.toLowerCase(), key);//返回之前存在的值，实际上对应的Key  
49.         Object oldValue = super.remove(oldKey);  
50.         super.put(key, value);  
51.         return oldValue;//返回之前的值  
52.     }  
53.   
54.    @Override  
55.     public void putAll(Map<? extends String,?> m) {  
56.         for (Map.Entry<? extends String, ?> entry : m.entrySet()) {  
57.             String key = entry.getKey();  
58.             Object value = entry.getValue();  
59.             this.put(key, value);  
60.         }  
61.     }  
62.   
63.     @Override  
64.     public Object remove(Object key) {  
65.         Object realKey = lowerCaseMap.remove(key.toString().toLowerCase());//返回该键对应的值  
66.         //实际上我们可以理解为拿到真正的Key值，然后删除对应的值  
67.         return super.remove(realKey);  
68.     }  
69. }  

    很一目了然了已经，通过成员变量lowerCaseMap来达到大小写通吃的目的，这个lowerCaseMap，Key值为小写化的列名，Value值才对应真实列名（即未做最小化处理的列名）。所以说，每次在以列名获取值时，先对其进行最小化，再通过lowerCaseMap获取对应的真实列名，然后再获取到值，这样就达到了一个不区分大小写的效果。OK，这个Map转换总算整明白了。这样呢，我们对这个BasicRowProcessor类的解读也算是圆满完成了。