深入理解Collections的unmodifiableMap(Map map)方法

深刻理解IdentityHashMap:http://donald-draper.iteye.com/blog/2326264
方法说明:
public static<K,V> Map<K,V> unmodifiableMap(Map<?extendsK,?extendsV>m)
返回指定映射的不可修改视图。此方法允许模块为用户提供对内部映射的“只读”访问。
在返回的映射上执行的查询操作将“读完”指定的映射。试图修改返回的映射
(不管是直接修改还是通过其collection视图进行修改)将导致抛出UnsupportedOperationException。
如果指定映射是可序列化的,则返回的映射也将是可序列化的。
参数:
m-将为其返回一个不可修改视图的映射。
返回:
指定映射的不可修改视图。
测试:

package test;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter;
import org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping;

public class TestMap  {
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public static void main(String[] args) {
		Map mp = new HashMap<String, String>();
		mp.put("1", "s");
		mp.put("2", "t");
		/*Collection ct = mp.values();
		System.out.println(ct.toString());*/
		mp.put("1", "t");
		Set<Map.Entry<String, String>> allSet = mp.entrySet();
		Iterator<Map.Entry<String, String>> iter = allSet.iterator();
		while (iter.hasNext()) {
			Map.Entry<String, String> me = iter.next();
			System.out.println(me.getKey() + " --> " + me.getValue());
		}
		//HashMap
		Map mpx = new HashMap<Cat, String>();
		mpx.put(new Cat("kitty",1), "kitty_1");
		mpx.put(new Cat("jime",2), "jime_2");
		mpx.put(new Cat("kitty",1), "kitty_2");
		Set<Map.Entry<Cat, String>> allSetx = mpx.entrySet();
		Iterator<Map.Entry<Cat, String>> iterx = allSetx.iterator();
		while (iterx.hasNext()) {
			Map.Entry<Cat, String> me = iterx.next();
			System.out.println(me.getKey() + " --> " + me.getValue());
		}
		System.out.println("==============IdentityHashMap:");
		//IdentityHashMap
		Map imp = new IdentityHashMap<Cat, String>();
		Cat cat = new Cat("kitty",1);
		imp.put(cat, "kitty_1");
		imp.put(new Cat("jime",2), "jime_2");
		imp.put(new Cat("kitty",1), "kitty_2");
		Set<Map.Entry<Cat, String>> iSet = imp.entrySet();
		Iterator<Map.Entry<Cat, String>> iterxx = iSet.iterator();
		while (iterxx.hasNext()) {
			Map.Entry<Cat, String> me = iterxx.next();
			System.out.println(me.getKey() + " --> " + me.getValue());
		}
		System.out.println("==============unmodifiableMap:");
		//test Collections.unmodifiableMap();
		Map impx =  Collections.unmodifiableMap(imp);
		cat.setName("baibi");
		Set<Map.Entry<Cat, String>> uSet = impx.entrySet();
		Iterator<Map.Entry<Cat, String>> iterU = uSet.iterator();
		while (iterU.hasNext()) {
			Map.Entry<Cat, String> me = iterU.next();
			System.out.println(me.getKey() + " --> " + me.getValue());
		}
		impx.put(new Cat("Luyies",6), "Luyies_6");
	}
}

控制台输出:
2 --> t
1 --> t
姓名:jime,年龄:2 --> jime_2
姓名:kitty,年龄:1 --> kitty_2
==============IdentityHashMap:
姓名:kitty,年龄:1 --> kitty_2
姓名:jime,年龄:2 --> jime_2
姓名:kitty,年龄:1 --> kitty_1
==============unmodifiableMap:
姓名:kitty,年龄:1 --> kitty_2
姓名:jime,年龄:2 --> jime_2
姓名:baibi,年龄:1 --> kitty_1
Exception in thread "main" java.lang.UnsupportedOperationException
at java.util.Collections$UnmodifiableMap.put(Unknown Source)
at test.TestMap.main(TestMap.java:63)
我们来查看一下Collections的方法:
public class Collections
{
    public static Map unmodifiableMap(Map map)
    {
        return new UnmodifiableMap(map);
    }

    public static SortedMap unmodifiableSortedMap(SortedMap sortedmap)
    {
        return new UnmodifiableSortedMap(sortedmap);
    }
//UnmodifiableMap为Collections的静态内部类
private static class UnmodifiableMap
        implements Map, Serializable
    {
        static class UnmodifiableEntrySet extends UnmodifiableSet
        {
            private static class UnmodifiableEntry
                implements Map.Entry
            {

                public Object getKey()
                {
                    return e.getKey();
                }

                public Object getValue()
                {
                    return e.getValue();
                }

                public Object setValue(Object obj)
                {
                    throw new UnsupportedOperationException();
                }

                public int hashCode()
                {
                    return e.hashCode();
                }

                public boolean equals(Object obj)
                {
                    if(this == obj)
                        return true;
                    if(!(obj instanceof Map.Entry))
                    {
                        return false;
                    } else
                    {
                        Map.Entry entry = (Map.Entry)obj;
                        return Collections.eq(e.getKey(), entry.getKey()) && Collections.eq(e.getValue(), entry.getValue());
                    }
                }

                public String toString()
                {
                    return e.toString();
                }

                private Map.Entry e;

                UnmodifiableEntry(Map.Entry entry)
                {
                    e = entry;
                }
            }


            public Iterator iterator()
            {
                return new Iterator() {

                    public boolean hasNext()
                    {
                        return i.hasNext();
                    }

                    public Map.Entry next()
                    {
                        return new UnmodifiableEntry((Map.Entry)i.next());
                    }

                    public void remove()
                    {
                        throw new UnsupportedOperationException();
                    }

                    public volatile Object next()
                    {
                        return next();
                    }

                    private final Iterator i;
                    final UnmodifiableEntrySet this$0;

                   
                    {
                        this$0 = UnmodifiableEntrySet.this;
                        super();
                        i = c.iterator();
                    }
                };
            }
            private static final long serialVersionUID = 7854390611657943733L;

            UnmodifiableEntrySet(Set set)
            {
                super(set);
            }
        }

        public Set keySet()
        {
            if(keySet == null)
                keySet = Collections.unmodifiableSet(m.keySet());
            return keySet;
        }

        public Set entrySet()
        {
            if(entrySet == null)
                entrySet = new UnmodifiableEntrySet(m.entrySet());
            return entrySet;
        }
        private static final long serialVersionUID = -1034234728574286014L;
        private final Map m;
        private transient Set keySet;
        private transient Set entrySet;
        private transient Collection values;
        UnmodifiableMap(Map map)
        {
            keySet = null;
            entrySet = null;
            values = null;
            if(map == null)
            {
                throw new NullPointerException();
            } else
            {
                m = map;
                return;
            }
        }
    }
}
从上我们看一看出UnmodifiableMap不知处put,remove操作。
总结:
实现原是是包装了下map不支持改变大小的操作 ,仅仅返回的Map不能putremove操作, 但可以对里的对象进行操

本页内容版权归属为原作者,如有侵犯您的权益,请通知我们删除。

storm部署详细步骤 - 2016-09-24 19:09:04

1.修改主机名: vim /etc/sysconfig/network NETWORKING=yes HOSTNAME=MASTER   2.修改IP: vim /etc/sysconfig/network-scripts/ifcfg-eth0 BOOTPROTO="static" HWADDR="00:0C:29:FC:62:B6" IPV6INIT="yes" NM_CONTROLLED="yes" ONBOOT="yes" TYPE="Ethernet" UUID="d0731a46-36df-4a
①前端接收enum时,将它放入一个容器script type="text/javascript"var App = {};App.module = 'merchantManage';App.mydata = {"data":[#{list items:memberStatus, as:'status'}{'title':'${status?.title}','name':'${status}'},#{/list}#{list items:memberOperationTypes, as:'target'}
多线程使用的主要目的在于: 1、吞吐量:你做WEB,容器帮你做了多线程,但是他只能帮你做请求层面的。简单的说,可能就是一个请求一个线程。或多个请求一个线程。如果是单线程,那同时只能处理一个用户的请求。 2、伸缩性:也就是说,你可以通过增加CPU核数来提升性能。如果是单线程,那程序执行到死也就利用了单核,肯定没办法通过增加CPU核数来提升性能。 鉴于你是做WEB的,第1点可能你几乎不涉及。那这里我就讲第二点吧。 --举个简单的例子: 假设有个请求,这个请求服务端的处理需要执行3个很缓慢的IO操作(比如数据库

博客搬家咯 - 2016-09-24 14:09:07

博客搬家了,最新地址: http://blog.uyiplus.com

关于java的10个谎言 - 2016-09-24 14:09:07

关于java的10个谎言 面试中总遇到各种奇葩的问题,小编在兄弟连网站上找到了下面的这些都算是比较高级的问题了,面试中一般也很少问到,因为它们可能会把面试者拒之门外。不过你可以自己找个时间来实践一下。 1. System.exit(0)会跳过finally块的执行 System.setSecurityManager(new SecurityManager() {         @Override         public void checkExit(int status) {            

Java 之浅复制和深复制 - 2016-09-24 14:09:07

1 浅复制和深复制区别 浅复制:浅复制只是复制本对象的原始数据类型,如int、float、String,对于数组和对象引用等是不会复制的。因此浅复制是有风险的。 深复制:不但对原始数据类型进行复制,对于对象中的数组和对象引用也做复制的行为,从而达到对对象的完全复制。 2 代码示例 package com;import java.util.ArrayList;public class Test implements Cloneable {// 私有属性private ArrayListString name
在java编程中,经常需要用到同步,而用得最多的也许是synchronized关键字了,下面看看这个关键字的用法。 因为synchronized关键字涉及到锁的概念,所以先来了解一些相关的锁知识。 java的内置锁:每个java对象都可以用做一个实现同步的锁,这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁,在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。 java内置锁是一个互斥锁,这就是意味着最多只有一个线程能够获得该锁,当线程A尝试去获得
在eclipse的preferences里,Java-Code style-Code templates,Comments-Type编辑成如下     @author ${name:git_config(user.name)} (${mail:git_config(user.email)})
一 8种基本数据类型和8种包装类的对应关系 基本数据类型 包装类 byte Byte short Short int Interger long Long char Character float Float double Double boolean Boolean   二 自动装箱和自动拆箱 1 概念介绍  自动装箱:把一个基本数据变量直接赋给对应的包装类变量或者赋值给Object变量。  自动拆箱:允许直接把包装类对象直接赋给对应的基本类型变量。 2 代码示例 public class AutoBo

通用查询,保存方法 - 2016-09-24 14:09:04

基于jqgrid页面通用查询、保存方法