java中containskey java中char类型
各位老铁们，大家好，今天由我来为大家分享java中containskey，以及java中char类型的相关问题知识，希望对大家有所帮助。如果可以帮助到大家，还望关注收藏下本站，您的支持是我们最大的动力，谢谢大家了哈，下面我们开始吧！
java高手进
HashMap吧。。。
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
基于哈希表的 Map接口的实现。此实现提供所有可选的映射操作，并允许使用 null值和 null键。（除了不同步和允许使用 null之外，HashMap类与 Hashtable大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
此实现假定哈希函数将元素正确分布在各桶之间，可为基本操作（get和 put）提供稳定的性能。迭代集合视图所需的时间与 HashMap实例的“容量”（桶的数量）及其大小（键-值映射关系数）的和成比例。所以，如果迭代性能很重要，则不要将初始容量设置得太高（或将加载因子设置得太低）。
HashMap的实例有两个参数影响其性能：初始容量和加载因子。容量是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，通过调用 rehash方法将容量翻倍。
通常，默认加载因子(.75)在时间和空间成本上寻求一种折衷。加载因子过高虽然减少了空间开销，但同时也增加了查询成本（在大多数 HashMap类的操作中，包括 get和 put操作，都反映了这一点）。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地降低 rehash操作次数。如果初始容量大于最大条目数除以加载因子，则不会发生 rehash操作。
如果很多映射关系要存储在 HashMap实例中，则相对于按需执行自动的 rehash操作以增大表的容量来说，使用足够大的初始容量创建它将使得映射关系能更有效地存储。
注意，此实现不是同步的。如果多个线程同时访问此映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。（结构上的修改是指添加或删除一个或多个映射关系的操作；仅改变与实例已经包含的键关联的值不是结构上的修改。）这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedMap方法来“包装”该映射。最好在创建时完成这一操作，以防止对映射进行意外的不同步访问，如下所示：
Map m= Collections.synchronizedMap(new HashMap(...));
由所有此类的“集合视图方法”所返回的迭代器都是快速失败的：在迭代器创建之后，如果从结构上对映射进行修改，除非通过迭代器自身的 remove或 add方法，其他任何时间任何方式的修改，迭代器都将抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不冒在将来不确定的时间任意发生不确定行为的风险。
注意，迭代器的快速失败行为不能得到保证，一般来说，存在不同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常程序的方式是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。
此类是 Java Collections Framework的成员。
从以下版本开始：
1.2
另请参见：
Object.hashCode(), Collection, Map, TreeMap, Hashtable,序列化表格
构造方法摘要
HashMap()
构造一个具有默认初始容量(16)和默认加载因子(0.75)的空 HashMap。
HashMap(int initialCapacity)
构造一个带指定初始容量和默认加载因子(0.75)的空 HashMap。
HashMap(int initialCapacity, float loadFactor)
构造一个带指定初始容量和加载因子的空 HashMap。
HashMap(Map<? extends K,? extends V> m)
构造一个映射关系与指定 Map相同的 HashMap。
方法摘要
void clear()
从此映射中移除所有映射关系。
Object clone()
返回此 HashMap实例的浅表复制：并不克隆键和值本身。
boolean containsKey(Object key)
如果此映射包含对于指定的键的映射关系，则返回 true。
boolean containsValue(Object value)
如果此映射将一个或多个键映射到指定值，则返回 true。
Set<Map.Entry<K,V>> entrySet()
返回此映射所包含的映射关系的 collection视图。
V get(Object key)
返回指定键在此标识哈希映射中所映射的值，如果对于此键来说，映射不包含任何映射关系，则返回 null。
boolean isEmpty()
如果此映射不包含键-值映射关系，则返回 true。
Set<K> keySet()
返回此映射中所包含的键的 set视图。
V put(K key, V value)
在此映射中关联指定值与指定键。
void putAll(Map<? extends K,? extends V> m)
将指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前针对指定映射的所有键的所有映射关系。
V remove(Object key)
如果此映射中存在该键的映射关系，则将其删除。
int size()
返回此映射中的键-值映射关系数。
Collection<V> values()
返回此映射所包含的值的 collection视图。
构造方法详细信息
HashMap
public HashMap(int initialCapacity,
float loadFactor)
构造一个带指定初始容量和加载因子的空 HashMap。
参数：
initialCapacity-初始容量。
loadFactor-加载因子。
抛出：
IllegalArgumentException-如果初始容量为负或者加载因子为非正。
HashMap
public HashMap(int initialCapacity)
构造一个带指定初始容量和默认加载因子(0.75)的空 HashMap。
参数：
initialCapacity-初始容量。
抛出：
IllegalArgumentException-如果初始容量为负。
HashMap
public HashMap()
构造一个具有默认初始容量(16)和默认加载因子(0.75)的空 HashMap。
HashMap
public HashMap(Map<? extends K,? extends V> m)
构造一个映射关系与指定 Map相同的 HashMap。所创建的 HashMap具有默认的加载因子(0.75)和足以容纳指定 Map中映射关系的初始容量。
参数：
m-映射，其映射关系将存放在此映射中。
抛出：
NullPointerException-如果指定的映射为 null。
方法详细信息
size
public int size()
返回此映射中的键-值映射关系数。
指定者：
接口 Map<K,V>中的 size
覆盖：
类 AbstractMap<K,V>中的 size
返回：
此映射中的键-值映射关系数。
isEmpty
public boolean isEmpty()
如果此映射不包含键-值映射关系，则返回 true。
指定者：
接口 Map<K,V>中的 isEmpty
覆盖：
类 AbstractMap<K,V>中的 isEmpty
返回：
如果此映射不包含键-值映射关系，则返回 true。
get
public V get(Object key)
返回指定键在此标识哈希映射中所映射的值，如果对于此键来说，映射不包含任何映射关系，则返回 null。返回值为 null并不一定表示对于该键来说，映射不包含任何映射关系，也可能是映射显式地将键映射到 null。使用 containsKey方法可以区分这两种情况。
指定者：
接口 Map<K,V>中的 get
覆盖：
类 AbstractMap<K,V>中的 get
参数：
key-与要返回的值相关联的键。
返回：
此映射对于指定键所映射的值，如果该映射对于此键不包含任何映射关系，则返回 null。
另请参见：
put(Object, Object)
containsKey
public boolean containsKey(Object key)
如果此映射包含对于指定的键的映射关系，则返回 true。
指定者：
接口 Map<K,V>中的 containsKey
覆盖：
类 AbstractMap<K,V>中的 containsKey
参数：
key-要测试其是否在此映射中存在的键
返回：
如果此映射包含对于指定的键的映射关系，则返回 true。
put
public V put(K key,
V value)
在此映射中关联指定值与指定键。如果此映射以前包含了一个该键的映射关系，则旧值被替换。
指定者：
接口 Map<K,V>中的 put
覆盖：
类 AbstractMap<K,V>中的 put
参数：
key-指定值将要关联的键。
value-指定键将要关联的值。
返回：
与指定键相关联的旧值，如果键没有任何映射关系，则返回 null。返回 null还可能表示该 HashMap以前将 null与指定键关联。
putAll
public void putAll(Map<? extends K,? extends V> m)
将指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前针对指定映射的所有键的所有映射关系。
指定者：
接口 Map<K,V>中的 putAll
覆盖：
类 AbstractMap<K,V>中的 putAll
参数：
m-要在此映射中存储的映射关系。
抛出：
NullPointerException-如果指定的映射为 null。
remove
public V remove(Object key)
如果此映射中存在该键的映射关系，则将其删除。
指定者：
接口 Map<K,V>中的 remove
覆盖：
类 AbstractMap<K,V>中的 remove
参数：
key-其映射关系要从映射中移除的键。
返回：
与指定键相关联的旧值，如果键没有任何映射关系，则返回 null。返回 null还可能表示该映射以前将 null与指定键关联。
clear
public void clear()
从此映射中移除所有映射关系。
指定者：
接口 Map<K,V>中的 clear
覆盖：
类 AbstractMap<K,V>中的 clear
containsValue
public boolean containsValue(Object value)
如果此映射将一个或多个键映射到指定值，则返回 true。
指定者：
接口 Map<K,V>中的 containsValue
覆盖：
类 AbstractMap<K,V>中的 containsValue
参数：
value-要测试其是否在此映射中存在的值。
返回：
如果此映射将一个或多个键映射到指定值，则返回 true。
clone
public Object clone()
返回此 HashMap实例的浅表复制：并不克隆键和值本身。
覆盖：
类 AbstractMap<K,V>中的 clone
返回：
此映射的浅表复制。
另请参见：
Cloneable
keySet
public Set<K> keySet()
返回此映射中所包含的键的 set视图。该集合受映射的支持，所以映射的变化也反映在该集合中，反之亦然。该集合支持元素的移除，通过 Iterator.remove、Set.remove、removeAll、retainAll和 clear操作，从该映射中移除相应的映射关系。它不支持 add或 addAll操作。
指定者：
接口 Map<K,V>中的 keySet
覆盖：
类 AbstractMap<K,V>中的 keySet
返回：
此映射所包含的键的 set视图。
values
public Collection<V> values()
返回此映射所包含的值的 collection视图。该集合受映射的支持，所以映射的变化也反映在该集合中，反之亦然。该集合支持元素的移除，通过 Iterator.remove、Collection.remove、removeAll、retainAll和 clear操作，从该映射中移除相应的映射关系。它不支持 add或 addAll操作。
指定者：
接口 Map<K,V>中的 values
覆盖：
类 AbstractMap<K,V>中的 values
返回：
此映射所包含的值的 collection视图。
entrySet
public Set<Map.Entry<K,V>> entrySet()
返回此映射所包含的映射关系的 collection视图。在返回的集合中，每个元素都是一个 Map.Entry。该集合受映射的支持，所以映射的变化也反映在该集合中，反之亦然。该集合支持元素的移除，通过 Iterator.remove、Collection.remove、removeAll、retainAll和 clear操作，从该映射中移除相应的映射关系。它不支持 add或 addAll操作。
指定者：
接口 Map<K,V>中的 entrySet
指定者：
类 AbstractMap<K,V>中的 entrySet
返回：
此映射所包含的映射关系的 collection视图。
另请参见：
Map.Entry
Java中HashMap和TreeMap的区别深入理解
首先介绍一下什么是Map。
在数组中我们是通过数组下标来对其内容索引的，而在Map中我们通过对象来对对象进行索引，用来索引的对象叫做key，其对应的对象叫做value。这就是我们平时说的键值对。
HashMap通过hashcode对其内容进行快速查找，
而 TreeMap中所有的元素都保持着某种固定的顺序，
如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。
HashMap非线程安全 TreeMap非线程安全
线程安全
在Java里，线程安全一般体现在两个方面：
1、多个thread对同一个java实例的访问（read和modify）不会相互干扰，它主要体现在关键字synchronized。如ArrayList和Vector，HashMap和Hashtable
（后者每个方法前都有synchronized关键字）。如果你在interator一个List对象时，其它线程remove一个element，问题就出现了。
2、每个线程都有自己的字段，而不会在多个线程之间共享。它主要体现在java.lang.ThreadLocal类，而没有Java关键字支持，如像static、transient那样。
1.AbstractMap抽象类和SortedMap接口
AbstractMap抽象类：(HashMap继承AbstractMap)覆盖了equals()和hashCode()方法以确保两个相等映射返回相同的哈希码。如果两个映射大小相等、包含同样的键且每个键在这两个映射中对应的值都相同，则这两个映射相等。映射的哈希码是映射元素哈希码的总和，其中每个元素是Map.Entry接口的一个实现。因此，不论映射内部顺序如何，两个相等映射会报告相同的哈希码。
SortedMap接口：（TreeMap继承自SortedMap）它用来保持键的有序顺序。SortedMap接口为映像的视图(子集)，包括两个端点提供了访问方法。除了排序是作用于映射的键以外，处理SortedMap和处理SortedSet一样。添加到SortedMap实现类的元素必须实现Comparable接口，否则您必须给它的构造函数提供一个Comparator接口的实现。TreeMap类是它的唯一一份实现。
2.两种常规Map实现
HashMap：基于哈希表实现。使用HashMap要求添加的键类明确定义了hashCode()和equals()[可以重写hashCode()和equals()]，为了优化HashMap空间的使用，您可以调优初始容量和负载因子。
(1)HashMap():构建一个空的哈希映像
(2)HashMap(Map m):构建一个哈希映像，并且添加映像m的所有映射
(3)HashMap(int initialCapacity):构建一个拥有特定容量的空的哈希映像
(4)HashMap(int initialCapacity, float loadFactor):构建一个拥有特定容量和加载因子的空的哈希映像
TreeMap：基于红黑树实现。TreeMap没有调优选项，因为该树总处于平衡状态。
(1)TreeMap():构建一个空的映像树
(2)TreeMap(Map m):构建一个映像树，并且添加映像m中所有元素
(3)TreeMap(Comparator c):构建一个映像树，并且使用特定的比较器对关键字进行排序
(4)TreeMap(SortedMap s):构建一个映像树，添加映像树s中所有映射，并且使用与有序映像s相同的比较器排序
3.两种常规Map性能
HashMap：适用于在Map中插入、删除和定位元素。
Treemap：适用于按自然顺序或自定义顺序遍历键(key)。
4.总结
HashMap通常比TreeMap快一点(树和哈希表的数据结构使然)，建议多使用HashMap，在需要排序的Map时候才用TreeMap。
importjava.util.HashMap;
importjava.util.Hashtable;
importjava.util.Iterator;
importjava.util.Map;
importjava.util.TreeMap;
publicclassHashMaps{
publicstaticvoidmain(String[]args){
Map<String,String>map=newHashMap<String,String>();
map.put("a","aaa");
map.put("b","bbb");
map.put("c","ccc");
map.put("d","ddd");
Iterator<String>iterator=map.keySet().iterator();
while(iterator.hasNext()){
Objectkey=iterator.next();
System.out.println("map.get(key)is:"+map.get(key));
}
//定义HashTable,用来测试
Hashtable<String,String>tab=newHashtable<String,String>();
tab.put("a","aaa");
tab.put("b","bbb");
tab.put("c","ccc");
tab.put("d","ddd");
Iterator<String>iterator_1=tab.keySet().iterator();
while(iterator_1.hasNext()){
Objectkey=iterator_1.next();
System.out.println("tab.get(key)is:"+tab.get(key));
}
TreeMap<String,String>tmp=newTreeMap<String,String>();
tmp.put("a","aaa");
tmp.put("b","bbb");
tmp.put("c","ccc");
tmp.put("d","cdc");
Iterator<String>iterator_2=tmp.keySet().iterator();
while(iterator_2.hasNext()){
Objectkey=iterator_2.next();
System.out.println("tmp.get(key)is:"+tmp.get(key));
}
}
}运行结果如下：
map.get(key)is:ddd
map.get(key)is:bbb
map.get(key)is:ccc
map.get(key)is:aaa
tab.get(key)is:bbb
tab.get(key)is:aaa
tab.get(key)is:ddd
tab.get(key)is:ccc
tmp.get(key)is:aaa
tmp.get(key)is:bbb
tmp.get(key)is:ccc
tmp.get(key)is:cdcHashMap的结果是没有排序的，而TreeMap输出的结果是排好序的。
下面就要进入本文的主题了。先举个例子说明一下怎样使用HashMap:
importjava.util.*;
publicclassExp1{
publicstaticvoidmain(String[]args){
HashMaph1=newHashMap();
Randomr1=newRandom();
for(inti=0;i<1000;i++){
Integert=newInteger(r1.nextInt(20));
if(h1.containsKey(t))
((Ctime)h1.get(t)).count++;
else
h1.put(t,newCtime());
}
System.out.println(h1);
}
}
classCtime{
intcount=1;
publicStringtoString(){
returnInteger.toString(count);
}
}在HashMap中通过get()来获取value，通过put()来插入value，ContainsKey()则用来检验对象是否已经存在。可以看出，和ArrayList的操作相比，HashMap除了通过key索引其内容之外，别的方面差异并不大。
前面介绍了，HashMap是基于HashCode的，在所有对象的超类Object中有一个HashCode()方法，但是它和equals方法一样，并不能适用于所有的情况，这样我们就需要重写自己的HashCode()方法。下面就举这样一个例子：
importjava.util.*;
publicclassExp2{
publicstaticvoidmain(String[]args){
HashMaph2=newHashMap();
for(inti=0;i<10;i++)
h2.put(newElement(i),newFigureout());
System.out.println("h2:");
System.out.println("GettheresultforElement:");
Elementtest=newElement(5);
if(h2.containsKey(test))
System.out.println((Figureout)h2.get(test));
else
System.out.println("Notfound");
}
}
classElement{
intnumber;
publicElement(intn){
number=n;
}
}
classFigureout{
Randomr=newRandom();
booleanpossible=r.nextDouble()>0.5;
publicStringtoString(){
if(possible)
return"OK!";
else
return"Impossible!";
}
}在这个例子中，Element用来索引对象Figureout,也即Element为key，Figureout为value。在Figureout中随机生成一个浮点数，如果它比0.5大，打印”OK!”，否则打印”Impossible!”。之后查看Element(3)对应的Figureout结果如何。
结果却发现，无论你运行多少次，得到的结果都是”Not found”。也就是说索引Element(3)并不在HashMap中。这怎么可能呢？
原因得慢慢来说：Element的HashCode方法继承自Object，而Object中的HashCode方法返回的HashCode对应于当前的地址，也就是说对于不同的对象，即使它们的内容完全相同，用HashCode（）返回的值也会不同。这样实际上违背了我们的意图。因为我们在使用 HashMap时，希望利用相同内容的对象索引得到相同的目标对象，这就需要HashCode()在此时能够返回相同的值。在上面的例子中，我们期望 new Element(i)(i=5)与 Elementtest=newElement(5)是相同的，而实际上这是两个不同的对象，尽管它们的内容相同，但它们在内存中的地址不同。因此很自然的，上面的程序得不到我们设想的结果。下面对Element类更改如下：
classElement{
intnumber;
publicElement(intn){
number=n;
}
publicinthashCode(){
returnnumber;
}
publicbooleanequals(Objecto){
return(oinstanceofElement)&&(number==((Element)o).number);
}
}在这里Element覆盖了Object中的hashCode()和equals()方法。覆盖hashCode()使其以number的值作为 hashcode返回，这样对于相同内容的对象来说它们的hashcode也就相同了。而覆盖equals()是为了在HashMap判断两个key是否相等时使结果有意义（有关重写equals()的内容可以参考我的另一篇文章《重新编写Object类中的方法》）。修改后的程序运行结果如下：
h2:
GettheresultforElement:
Impossible!请记住：如果你想有效的使用HashMap，你就必须重写在其的HashCode()。
还有两条重写HashCode()的原则：
[list=1]不必对每个不同的对象都产生一个唯一的hashcode，只要你的HashCode方法使get()能够得到put()放进去的内容就可以了。即”不为一原则”。
生成hashcode的算法尽量使hashcode的值分散一些，不要很多hashcode都集中在一个范围内，这样有利于提高HashMap的性能。即”分散原则”。
java中的单例模式的代码怎么写
我从我的博客里把我的文章粘贴过来吧，对于单例模式模式应该有比较清楚的解释：
单例模式在我们日常的项目中十分常见，当我们在项目中需要一个这样的一个对象，这个对象在内存中只能有一个实例，这时我们就需要用到单例。
一般说来，单例模式通常有以下几种：
1.饥汉式单例
public class Singleton{
private Singleton(){};
private static Singleton instance= new Singleton();
public static Singleton getInstance(){
return instance;
}
}
这是最简单的单例，这种单例最常见，也很可靠！它有个唯一的缺点就是无法完成延迟加载——即当系统还没有用到此单例时，单例就会被加载到内存中。
在这里我们可以做个这样的测试：
将上述代码修改为：
public class Singleton{
private Singleton(){
System.out.println("createSingleton");
};
private static Singleton instance= new Singleton();
public static Singleton getInstance(){
return instance;
}
public static void testSingleton(){
System.out.println("CreateString");
}
}
而我们在另外一个测试类中对它进行测试（本例所有测试都通过Junit进行测试）
public class TestSingleton{
@Test
public void test(){
Singleton.testSingleton();
}
}
输出结果：
createSingleton
CreateString
我们可以注意到，在这个单例中，即使我们没有使用单例类，它还是被创建出来了，这当然是我们所不愿意看到的，所以也就有了以下一种单例。
2.懒汉式单例
public class Singleton1{
private Singleton1(){
System.out.println("createSingleton");
}
private static Singleton1 instance= null;
public static synchronized Singleton1 getInstance(){
return instance==null?new Singleton1():instance;
}
public static void testSingleton(){
System.out.println("CreateString");
}
}
上面的单例获取实例时，是需要加上同步的，如果不加上同步，在多线程的环境中，当线程1完成新建单例操作，而在完成赋值操作之前，线程2就可能判
断instance为空，此时，线程2也将启动新建单例的操作，那么多个就出现了多个实例被新建，也就违反了我们使用单例模式的初衷了。
我们在这里也通过一个测试类，对它进行测试，最后面输出是
CreateString
可以看出，在未使用到单例类时，单例类并不会加载到内存中，只有我们需要使用到他的时候，才会进行实例化。
这种单例解决了单例的延迟加载，但是由于引入了同步的关键字，因此在多线程的环境下，所需的消耗的时间要远远大于第一种单例。我们可以通过一段测试代码来说明这个问题。
public class TestSingleton{
@Test
public void test(){
long beginTime1= System.currentTimeMillis();
for(int i=0;i<100000;i++){
Singleton.getInstance();
}
System.out.println("单例1花费时间："+(System.currentTimeMillis()-beginTime1));
long beginTime2= System.currentTimeMillis();
for(int i=0;i<100000;i++){
Singleton1.getInstance();
}
System.out.println("单例2花费时间："+(System.currentTimeMillis()-beginTime2));
}
}
最后输出的是：
单例1花费时间：0
单例2花费时间：10
可以看到，使用第一种单例耗时0ms，第二种单例耗时10ms，性能上存在明显的差异。为了使用延迟加载的功能，而导致单例的性能上存在明显差异，
是不是会得不偿失呢？是否可以找到一种更好的解决的办法呢？既可以解决延迟加载，又不至于性能损耗过多，所以，也就有了第三种单例：
3.内部类托管单例
public class Singleton2{
private Singleton2(){}
private static class SingletonHolder{
private static Singleton2 instance=new Singleton2();
}
private static Singleton2 getInstance(){
return SingletonHolder.instance;
}
}
在这个单例中，我们通过静态内部类来托管单例，当这个单例被加载时，不会初始化单例类，只有当getInstance方法被调用的时候，才会去加载
SingletonHolder，从而才会去初始化instance。并且，单例的加载是在内部类的加载的时候完成的，所以天生对线程友好，而且也不需要
synchnoized关键字，可以说是兼具了以上的两个优点。
4.总结
一般来说，上述的单例已经基本可以保证在一个系统中只会存在一个实例了，但是，仍然可能会有其他的情况，导致系统生成多个单例，请看以下情况：
public class Singleton3 implements Serializable{
private Singleton3(){}
private static class SingletonHolder{
private static Singleton3 instance= new Singleton3();
}
public static Singleton3 getInstance(){
return SingletonHolder.instance;
}
}
通过一段代码来测试：
@Test
public void test() throws Exception{
Singleton3 s1= null;
Singleton3 s2= Singleton3.getInstance();
//1.将实例串行话到文件
FileOutputStream fos= new FileOutputStream("singleton.txt");
ObjectOutputStream oos=new ObjectOutputStream(fos);
oos.writeObject(s2);
oos.flush();
oos.close();
//2.从文件中读取出单例
FileInputStream fis= new FileInputStream("singleton.txt");
ObjectInputStream ois= new ObjectInputStream(fis);
s1=(Singleton3) ois.readObject();
if(s1==s2){
System.out.println("同一个实例");
}else{
System.out.println("不是同一个实例");
}
}
输出：
不是同一个实例
可以看到当我们把单例反序列化后，生成了多个不同的单例类，此时，我们必须在原来的代码中加入readResolve()函数，来阻止它生成新的单例
public class Singleton3 implements Serializable{
private Singleton3(){}
private static class SingletonHolder{
private static Singleton3 instance= new Singleton3();
}
public static Singleton3 getInstance(){
return SingletonHolder.instance;
}
//阻止生成新的实例
public Object readResolve(){
return SingletonHolder.instance;
}
}
再次测试时，就可以发现他们生成的是同一个实例了。
关于java中containskey的内容到此结束，希望对大家有所帮助。