您现在的位置是:首页 > 正文

Collections.unmodifiableMap 用法解析

2024-02-01 02:27:24阅读 4

返回指定映射的不可修改视图。

通俗的讲就是:产生一个只读的Map,当你调用此map的put方法时会抛错。

public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m)


此方法允许模块为用户提供对内部映射的“只读”访问。

在返回的映射上执行的查询操作将“读完”指定的映射。

试图修改返回的映射(不管是直接修改还是通过其 collection 视图进行修改)将导致抛出 UnsupportedOperationException。
如果指定映射是可序列化的,则返回的映射也将是可序列化的。

参数:
m - 将为其返回一个不可修改视图的映射。
返回:
指定映射的不可修改视图。


// 实现原是是包装了下map 不支持改变大小的操作 
 // 仅仅返回的Map不能put remove 操作, 
 // 但可以对里的对象进行操作


java源码:

Java代码   收藏代码
  1.  private static class UnmodifiableMap  
  2.         implements Map, Serializable  
  3.     {  
  4.         static class UnmodifiableEntrySet extends UnmodifiableSet  
  5.         {  
  6.             private static class UnmodifiableEntry  
  7.                 implements Map.Entry  
  8.             {  
  9.   
  10.                 public Object getKey()  
  11.                 {  
  12.                     return e.getKey();  
  13.                 }  
  14.   
  15.                 public Object getValue()  
  16.                 {  
  17.                     return e.getValue();  
  18.                 }  
  19.   
  20.                 public Object setValue(Object obj)  
  21.                 {  
  22.                     throw new UnsupportedOperationException();  
  23.                 }  
  24.   
  25.                 public int hashCode()  
  26.                 {  
  27.                     return e.hashCode();  
  28.                 }  
  29.   
  30.                 public boolean equals(Object obj)  
  31.                 {  
  32.                     if(!(obj instanceof Map.Entry))  
  33.                     {  
  34.                         return false;  
  35.                     } else  
  36.                     {  
  37.                         Map.Entry entry = (Map.Entry)obj;  
  38.                         return Collections.eq(e.getKey(), entry.getKey()) && Collections.eq(e.getValue(), entry.getValue());  
  39.                     }  
  40.                 }  
  41.   
  42.                 public String toString()  
  43.                 {  
  44.                     return e.toString();  
  45.                 }  
  46.   
  47.                 private Map.Entry e;  
  48.   
  49.                 UnmodifiableEntry(Map.Entry entry)  
  50.                 {  
  51.                     e = entry;  
  52.                 }  
  53.             }  
  54.   
  55.   
  56.             public Iterator iterator()  
  57.             {  
  58.                 return new Iterator() {  
  59.   
  60.                     public boolean hasNext()  
  61.                     {  
  62.                         return i.hasNext();  
  63.                     }  
  64.   
  65.                     public Map.Entry next()  
  66.                     {  
  67.                         return new UnmodifiableEntry((Map.Entry)i.next());  
  68.                     }  
  69.   
  70.                     public void remove()  
  71.                     {  
  72.                         throw new UnsupportedOperationException();  
  73.                     }  
  74.   
  75.                     public volatile Object next()  
  76.                     {  
  77.                         return next();  
  78.                     }  
  79.   
  80.                     private final Iterator i;  
  81.                     final UnmodifiableEntrySet this$0;  
  82.   
  83.                       
  84.                     {  
  85.                         this$0 = UnmodifiableEntrySet.this;  
  86.                         super();  
  87.                         i = c.iterator();  
  88.                     }  
  89.                 }  
  90. ;  
  91.             }  
  92.   
  93.             public Object[] toArray()  
  94.             {  
  95.                 Object aobj[] = c.toArray();  
  96.                 for(int i = 0; i < aobj.length; i++)  
  97.                     aobj[i] = new UnmodifiableEntry((Map.Entry)aobj[i]);  
  98.   
  99.                 return aobj;  
  100.             }  
  101.   
  102.             public Object[] toArray(Object aobj[])  
  103.             {  
  104.                 Object aobj1[] = c.toArray(aobj.length != 0 ? Arrays.copyOf(aobj, 0) : aobj);  
  105.                 for(int i = 0; i < aobj1.length; i++)  
  106.                     aobj1[i] = new UnmodifiableEntry((Map.Entry)aobj1[i]);  
  107.   
  108.                 if(aobj1.length > aobj.length)  
  109.                     return (Object[])aobj1;  
  110.                 System.arraycopy(((Object) (aobj1)), 0, ((Object) (aobj)), 0, aobj1.length);  
  111.                 if(aobj.length > aobj1.length)  
  112.                     aobj[aobj1.length] = null;  
  113.                 return aobj;  
  114.             }  
  115.   
  116.             public boolean contains(Object obj)  
  117.             {  
  118.                 if(!(obj instanceof Map.Entry))  
  119.                     return false;  
  120.                 else  
  121.                     return c.contains(new UnmodifiableEntry((Map.Entry)obj));  
  122.             }  
  123.   
  124.             public boolean containsAll(Collection collection)  
  125.             {  
  126.                 for(Iterator iterator1 = collection.iterator(); iterator1.hasNext();)  
  127.                 {  
  128.                     Object obj = iterator1.next();  
  129.                     if(!contains(obj))  
  130.                         return false;  
  131.                 }  
  132.   
  133.                 return true;  
  134.             }  
  135.   
  136.             public boolean equals(Object obj)  
  137.             {  
  138.                 if(obj == this)  
  139.                     return true;  
  140.                 if(!(obj instanceof Set))  
  141.                     return false;  
  142.                 Set set = (Set)obj;  
  143.                 if(set.size() != c.size())  
  144.                     return false;  
  145.                 else  
  146.                     return containsAll(set);  
  147.             }  
  148.   
  149.             private static final long serialVersionUID = 7854390611657943733L;  
  150.   
  151.             UnmodifiableEntrySet(Set set)  
  152.             {  
  153.                 super(set);  
  154.             }  
  155.         }  
  156.   
  157.   
  158.         public int size()  
  159.         {  
  160.             return m.size();  
  161.         }  
  162.   
  163.         public boolean isEmpty()  
  164.         {  
  165.             return m.isEmpty();  
  166.         }  
  167.   
  168.         public boolean containsKey(Object obj)  
  169.         {  
  170.             return m.containsKey(obj);  
  171.         }  
  172.   
  173.         public boolean containsValue(Object obj)  
  174.         {  
  175.             return m.containsValue(obj);  
  176.         }  
  177.   
  178.         public Object get(Object obj)  
  179.         {  
  180.             return m.get(obj);  
  181.         }  
  182.   
  183.         public Object put(Object obj, Object obj1)  
  184.         {  
  185.             throw new UnsupportedOperationException();  
  186.         }  
  187.   
  188.         public Object remove(Object obj)  
  189.         {  
  190.             throw new UnsupportedOperationException();  
  191.         }  
  192.   
  193.         public void putAll(Map map)  
  194.         {  
  195.             throw new UnsupportedOperationException();  
  196.         }  
  197.   
  198.         public void clear()  
  199.         {  
  200.             throw new UnsupportedOperationException();  
  201.         }  
  202.   
  203.         public Set keySet()  
  204.         {  
  205.             if(keySet == null)  
  206.                 keySet = Collections.unmodifiableSet(m.keySet());  
  207.             return keySet;  
  208.         }  
  209.   
  210.         public Set entrySet()  
  211.         {  
  212.             if(entrySet == null)  
  213.                 entrySet = new UnmodifiableEntrySet(m.entrySet());  
  214.             return entrySet;  
  215.         }  
  216.   
  217.         public Collection values()  
  218.         {  
  219.             if(values == null)  
  220.                 values = Collections.unmodifiableCollection(m.values());  
  221.             return values;  
  222.         }  
  223.   
  224.         public boolean equals(Object obj)  
  225.         {  
  226.             return obj == this || m.equals(obj);  
  227.         }  
  228.   
  229.         public int hashCode()  
  230.         {  
  231.             return m.hashCode();  
  232.         }  
  233.   
  234.         public String toString()  
  235.         {  
  236.             return m.toString();  
  237.         }  
  238.   
  239.         private static final long serialVersionUID = -1034234728574286014L;  
  240.         private final Map m;  
  241.         private transient Set keySet;  
  242.         private transient Set entrySet;  
  243.         private transient Collection values;  
  244.   
  245.         UnmodifiableMap(Map map)  
  246.         {  
  247.             keySet = null;  
  248.             entrySet = null;  
  249.             values = null;  
  250.             if(map == null)  
  251.             {  
  252.                 throw new NullPointerException();  
  253.             } else  
  254.             {  
  255.                 m = map;  
  256.                 return;  
  257.             }  
  258.         }  
  259.     } 


原博客地址:http://www.iteye.com/problems/85843

网站文章

  • 短暂的“歧途”——写在短暂的第二份工作结束之时

    距离上一份工作结束总结才过去3个月,现在又要写第二份工作总结了。不用说,这份工作绝对是不太如意的。其中有不少需要总结的地方,希望读者也能从中吸取经验和教训。记事去年9月,还在第一份工作期间,跳槽的心就...

    2024-02-01 02:27:17
  • Jenkins部署新项目

    Jenkins部署新项目

    1、安装 Jenkins 下载jenkins-1.656.zip文件,进行安装 2、部署一个项目 2.1登录Jenkins http://127.0.0.1:xxxx/ 2.2新建 2.2.1构建一个maven项目 2.2.2输入SVN地址 2.2.4构建触发器 构建方式

    2024-02-01 02:27:10
  • Java读取输入流和文件内容——BufferedReader

    BufferedReader读取控制台输入从控制台读取数据readline() 方法关于 `try-catch` 语句的拓展 Java不像C那样直接用 scanf 即可从控制台读入数据,读取数据很麻烦...

    2024-02-01 02:26:41
  • Python使用定时任务

    Python使用定时任务

    【代码】Python使用定时任务。

    2024-02-01 02:26:33
  • 计算机卸载目录不让它显示,电脑删除文件时提示“无法删除文件夹 目录不是空的”怎么办?...

    计算机卸载目录不让它显示,电脑删除文件时提示“无法删除文件夹 目录不是空的”怎么办?...

    电脑使用久了之后会发现系统中存在很多没用的文件夹,此时最简单的方法就是直接删除,但是有时会在删除文件夹的时候出现“无法删除文件夹 目录不是空的”的提示,这是什么问题呢?现在本文就给大家分析该问题的原因...

    2024-02-01 02:26:27
  • 正向代理与反向代理通俗理解

    关于正向代理以及反向代理的理解。特别通俗,一看就懂。

    2024-02-01 02:26:00
  • MySQL if else的格式_mysql if--else

    MySQL if else的格式_mysql if--else

    case具有两种格式。简单case函数和case搜索函数。--简单case函数case sexwhen &#39;1&#39; then &#39;男&#39;when &#39;2&#39; the...

    2024-02-01 02:25:55
  • Js - 模板字面量

    背景 参考资料 JavaScript高级程序设计(第4版) ES6指北【7】——从回调地狱到Promise和async/await JS异步编程之Promise详解和使用总结

    2024-02-01 02:25:51
  • Git和Bitbucket入门之代码上传

    作为一名代码渣,虽然代码写得很烂,但多多少少也写了些了。听说大牛们都在用Bitbucket,瞻仰代码时却连git clone都不会也有点说不过去了,因此,我要入门!参考:http://blog.jobbole.com/53573/ (中文) https://confluence.atlassian.com/bitbucket/bitbucket-cloud-documen

    2024-02-01 02:25:21
  • MySQL在Mybatis新增后返回主键

    通过Mybatis将数据新增到MySQL时,有时需要获取到当前新增的数据的主键。尤其是主子表的数据在新增时,字表需要保存主表的主键作为外键。

    2024-02-01 02:25:16