java集合---hashMap

java集合---hashMap
java集合---hashMap

java集合---hashMap

HashMap概述

HashMap基于哈希表的Map 接口的实现。此实现提供所有可选的映射操作,并允许使用null 值和null 键。(除了不同步和允许使用null 之外,HashMap 类与Hashtable 大致相同。)此类不保证映射的顺序,特别是它不保证该顺序恒久不变.

注:HashMap不是线程安全的,如果想要线程安全的HashMap,可以通过Collections类的静态方法synchronizedMap获得线程安全的HashMap。

Map map = Collections.synchronizedMap(new HashMap());

1

HashMap的数据结构

HashMap的底层主要是基于数组和链表来实现的,它之所以有相当快的查询速度主要是因为它是通过计算散列码来决定存储的位置。

HashMap中主要是通过key的hashCode来计算hash值的,只要hashCode相同,计算出来的hash值就一样。

hashCode 的源码如下:

public int GetHashCode(String str)

{

char[] s = str.toCharArray();

int hash = 0;

for (int i = 0; i < s.length; i++){

hash = s[i] + (31 * hash);

}

return hash;

}

上面的哈希值是Horner计算字符串哈希值的方法,公式为:

h = s[0] · 31^(L–1) + … + s[L – 3] · 31^2 + s[L – 2] · 31^1 + s[L – 1] · 31^0

1

举个例子,比如要获取”call”的哈希值,字符串c对应的unicode为99,a对应的unicode 为97,L对应的unicode为108,所以字符串”call”的哈希值为3045982 = 99·31^3 + 97·31^2 + 108·31^1 + 108·31^0 = 108 + 31·(108 + 31 ·(97 + 31 ·(99)));

HashMap中主要是通过key的hashCode来计算hash值的,只要hashCode相同,计算出来的hash值就一样。(下例有分析)

如果存储的对象对多了,就有可能不同的对象所算出来的hash值是相同的,这就出现了所谓的hash冲突。学过数据结构的同学都知道,解决hash冲突的方法有很多,HashMap 底层是通过链表来解决hash冲突的。

图中,紫色部分即代表哈希表,也称为哈希数组,数组的每个元素都是一个单链表的头节点,链表是用来解决冲突的,如果不同的key映射到了数组的同一位置处,就将其放入单链表中。

我们看看HashMap中Entry类的代码:

/** Entry是单向链表。

* 它是“HashMap链式存储法”对应的链表。

*它实现了Map.Entry 接口,即实现getKey(), getValue(), setValue(V value), equals(Object o), hashCode()这些函数

**/

static class Entry implements Map.Entry {

final K key;

V value;

// 指向下一个节点

Entry next;

final int hash;

// 构造函数。

// 输入参数包括"哈希值(h)", "键(k)", "值(v)", "下一节点(n)"

Entry(int h, K k, V v, Entry n) {

value = v;

next = n;

key = k;

hash = h;

}

public final K getKey() {

return key;

}

public final V getValue() {

return value;

}

public final V setV alue(V newValue) {

V oldValue = value;

value = newV alue;

return oldValue;

}

// 判断两个Entry是否相等

// 若两个Entry的“key”和“value”都相等,则返回true。// 否则,返回false

public final boolean equals(Object o) {

if (!(o instanceof Map.Entry))

return false;

Map.Entry e = (Map.Entry)o;

Object k1 = getKey();

Object k2 = e.getKey();

if (k1 == k2 || (k1 != null && k1.equals(k2))) {

Object v1 = getValue();

Object v2 = e.getValue();

if (v1 == v2 || (v1 != null && v1.equals(v2)))

return true;

}

return false;

}

// 实现hashCode()

public final int hashCode() {

return (key==null ? 0 : key.hashCode()) ^

(value==null ? 0 : value.hashCode());

}

public final String toString() {

return getKey() + "=" + getValue();

}

// 当向HashMap中添加元素时,绘调用recordAccess()。

// 这里不做任何处理

void recordAccess(HashMap m) {

}

// 当从HashMap中删除元素时,绘调用recordRemoval()。

// 这里不做任何处理

void recordRemoval(HashMap m) {

}

}

HashMap其实就是一个Entry数组,Entry对象中包含了键和值,其中next也是一个Entry 对象,它就是用来处理hash冲突的,形成一个链表。

HashMap源码分析

关键属性

先看看HashMap类中的一些关键属性:

transient Entry[] table;//存储元素的实体数组

transient int size;//存放元素的个数

int threshold; //临界值当实际大小超过临界值时,会进行扩容threshold = 加载因子*容量

final float loadFactor; //加载因子

transient int modCount;//被修改的次数

其中loadFactor加载因子是表示Hsah表中元素的填满的程度.

若:加载因子越大,填满的元素越多,好处是,空间利用率高了,但:冲突的机会加大了.链表长度会越来越长,查找效率降低。

反之,加载因子越小,填满的元素越少,好处是:冲突的机会减小了,但:空间浪费多了.表中的数据将过于稀疏(很多空间还没用,就开始扩容了)

冲突的机会越大,则查找的成本越高.

因此,必须在“冲突的机会”与”空间利用率”之间寻找一种平衡与折衷. 这种平衡与折衷本质上是数据结构中有名的”时-空”矛盾的平衡与折衷.

如果机器内存足够,并且想要提高查询速度的话可以将加载因子设置小一点;相反如果机器内存紧张,并且对查询速度没有什么要求的话可以将加载因子设置大一点。不过一般我们都不用去设置它,让它取默认值0.75就好了。

构造方法

下面看看HashMap的几个构造方法:

public HashMap(int initialCapacity, float loadFactor) {

//确保数字合法

if (initialCapacity < 0)

throw new IllegalArgumentException("Illegal initial capacity: " +

initialCapacity);

if (initialCapacity > MAXIMUM_CAPACITY)

initialCapacity = MAXIMUM_CAPACITY;

if (loadFactor <= 0 || Float.isNaN(loadFactor))

throw new IllegalArgumentException("Illegal load factor: " +

loadFactor);

// Find a power of 2 >= initialCapacity

int capacity = 1; //初始容量

while (capacity < initialCapacity) //确保容量为2的n次幂,使capacity为大于initialCapacity的最小的2的n次幂

capacity <<= 1;

this.loadFactor = loadFactor;

threshold = (int)(capacity * loadFactor);

table = new Entry[capacity];

init();

}

public HashMap(int initialCapacity) {

this(initialCapacity, DEFAULT_LOAD_FACTOR);

}

public HashMap() {

this.loadFactor = DEFAULT_LOAD_FACTOR;

threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);

table = new Entry[DEFAULT_INITIAL_CAPACITY];

init();

}

我们可以看到在构造HashMap的时候如果我们指定了加载因子和初始容量的话就调用第一个构造方法,否则的话就是用默认的。默认初始容量为16,默认加载因子为0.75。我们可以看到上面代码中13-15行,这段代码的作用是确保容量为2的n次幂,使capacity为大于initialCapacity的最小的2的n次幂,至于为什么要把容量设置为2的n次幂,我们等下再看。

重点分析下HashMap中用的最多的两个方法put和get:

存储数据

下面看看HashMap存储数据的过程是怎样的,首先看看HashMap的put方法:

public V put(K key, V value) {

// 若“key为null”,则将该键值对添加到table[0]中。

if (key == null)

return putForNullKey(value);

// 若“key不为null”,则计算该key的哈希值,然后将其添加到该哈希值对应的链表中。

int hash = hash(key.hashCode());

//搜索指定hash值在对应table中的索引

int i = indexFor(hash, table.length);

// 循环遍历Entry数组,若“该key”对应的键值对已经存在,则用新的value取代旧的value。然后退出!

for (Entry e = table[i]; e != null; e = e.next) {

Object k;

if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { //如果key相同则覆盖并返回旧值

V oldValue = e.value;

e.value = value;

e.recordAccess(this);

return oldValue;

}

}

//修改次数+1

modCount++;

//将key-value添加到table[i]处

addEntry(hash, key, value, i);

return null;

}

上面程序中用到了一个重要的内部接口:Map.Entry,每个Map.Entry 其实就是一个key-value 对。从上面程序中可以看出:当系统决定存储HashMap 中的key-value 对时,完全没有考虑Entry 中的value,仅仅只是根据key 来计算并决定每个Entry 的存储位置。这也说明了前面的结论:我们完全可以把Map 集合中的value 当成key 的附属,当系统决定了key 的存储位置之后,value 随之保存在那里即可。

我们慢慢的来分析这个函数,第2和3行的作用就是处理key值为null的情况,我们看看putForNullKey(value)方法:

private V putForNullKey(V value) {

for (Entry e = table[0]; e != null; e = e.next) {

if (e.key == null) { //如果有key为null的对象存在,则覆盖掉

V oldValue = e.value;

e.value = value;

e.recordAccess(this);

return oldValue;

}

}

modCount++;

addEntry(0, null, value, 0); //如果键为null的话,则hash值为0

return null;

}

注意:如果key为null的话,hash值为0,对象存储在数组中索引为0的位置。即table[0]

我们再回去看看put方法中第4行,它是通过key的hashCode值计算hash码,下面是计算hash码的函数:

static int hash(int h) {

h ^= (h >>> 20) ^ (h >>> 12);

return h ^ (h >>> 7) ^ (h >>> 4);

}

得到hash码之后就会通过hash码去计算出应该存储在数组中的索引,计算索引的函数如下:

static int indexFor(int h, int length) { //根据hash值和数组长度算出索引值

return h & (length-1); //这里不能随便算取,用hash&(length-1)是有原因的,这样可以确保算出来的索引是在数组大小范围内,不会超出

}

我们一般对哈希表的散列很自然地会想到用hash值对length取模(即除法散列法),Hashtable中也是这样实现的,这种方法基本能保证元素在哈希表中散列的比较均匀,但取模会用到除法运算,效率很低,HashMap中则通过h&(length-1)的方法来代替取模,同样实现了均匀的散列,但效率要高很多,这也是HashMap对Hashtable的一个改进。

我们分析下为什么哈希表的容量一定要是2的整数次幂。首先,length为2的整数次幂的话,h&(length-1)就相当于对length取模,这样便保证了散列的均匀,同时也提升了效率;其次,length为2的整数次幂的话,为偶数,这样length-1为奇数,奇数的最后一位是1,这样便保证了h&(length-1)的最后一位可能为0,也可能为1(这取决于h的值),即与后的结果可能为偶数,也可能为奇数,这样便可以保证散列的均匀性,而如果length为奇数的话,很明显length-1为偶数,它的最后一位是0,这样h&(length-1)的最后一位肯定为0,即只能为偶数,这样任何hash值都只会被散列到数组的偶数下标位置上,这便浪费了近一半的空间,因此,length取2的整数次幂,是为了使不同hash值发生碰撞的概率较小,这样就能使元素在哈希表中均匀地散列。

我们举个例子来说明,假设数组长度分别为15和16,优化后的hash码分别为8和9,那么&运算后的结果如下:

从上面的例子中可以看出:当它们和15-1(1110)“与”的时候,产生了相同的结果,也就是说它们会定位到数组中的同一个位置上去,这就产生了碰撞,8和9会被放到数组中的同一个位置上形成链表,那么查询的时候就需要遍历这个链表,得到8或者9,这样就降低了查询的效率。同时,我们也可以发现,当数组长度为15的时候,hash值会与15-1(1110)进行“与”,那么最后一位永远是0,而0001,0011,0101,1001,1011,0111,1101这几个位置永远都不能存放元素了,空间浪费相当大,更糟的是这种情况中,数组可以使用的位置比数组长度小了很多,这意味着进一步增加了碰撞的几率,减慢了查询的效率!而当数组长度为16时,即为2的n次方时,2n-1得到的二进制数的每个位上的值都为1,这使得在低位上&时,得到的和原hash的低位相同,加之hash(int h)方法对key的hashCode的进一步优化,加入了高位计算,就使得只有相同的hash值的两个值才会被放到数组中的同一个位置上形成链表。

所以说,当数组长度为2的n次幂的时候,不同的key算得得index相同的几率较小,那么数据在数组上分布就比较均匀,也就是说碰撞的几率小,相对的,查询的时候就不用遍历某个位置上的链表,这样查询效率也就较高了。

void addEntry(int hash, K key, V value, int bucketIndex) {

Entry e = table[https://www.360docs.net/doc/e8707507.html,tIndex]; //如果要加入的位置有值,将该位置原先的值设置为新entry的next,也就是新entry链表的下一个节点

table[bucketIndex] = new Entry<>(hash, key, value, e);

if (size++ >= threshold) //如果大于临界值就扩容

resize(2 * table.length); //以2的倍数扩容

}

参数bucketIndex就是indexFor函数计算出来的索引值,第2行代码是取得数组中索引为bucketIndex的Entry对象,第3行就是用hash、key、value构建一个新的Entry对象放到索引为bucketIndex的位置,并且将该位置原先的对象设置为新对象的next构成链表。

第4行和第5行就是判断put后size是否达到了临界值threshold,如果达到了临界值就要进行扩容,HashMap扩容是扩为原来的两倍。

调整大小

resize()方法如下:

重新调整HashMap的大小,newCapacity是调整后的单位

void resize(int newCapacity) {

Entry[] oldTable = table;

int oldCapacity = oldTable.length;

if (oldCapacity == MAXIMUM_CAPACITY) {

threshold = Integer.MAX_V ALUE;

return;

}

Entry[] newTable = new Entry[newCapacity];

transfer(newTable);//用来将原先table的元素全部移到newTable里面

table = newTable; //再将newTable赋值给table

threshold = (int)(newCapacity * loadFactor);//重新计算临界值

}

新建了一个HashMap的底层数组,上面代码中第10行为调用transfer方法,将HashMap的全部元素添加到新的HashMap中,并重新计算元素在新的数组中的索引位置当HashMap中的元素越来越多的时候,hash冲突的几率也就越来越高,因为数组的长度是固定的。所以为了提高查询的效率,就要对HashMap的数组进行扩容,数组扩容这个操作也会出现在ArrayList中,这是一个常用的操作,而在HashMap数组扩容之后,最消耗性能的点就出现了:原数组中的数据必须重新计算其在新数组中的位置,并放进去,这就是resize。

那么HashMap什么时候进行扩容呢?当HashMap中的元素个数超过数组大小*loadFactor时,就会进行数组扩容,loadFactor的默认值为0.75,这是一个折中的取值。也就是说,默认情况下,数组大小为16,那么当HashMap中元素个数超过16*0.75=12的时候,就把数组的大小扩展为2*16=32,即扩大一倍,然后重新计算每个元素在数组中的位置,扩容是需要进行数组复制的,复制数组是非常消耗性能的操作,所以如果我们已经预知HashMap中元素的个数,那么预设元素的个数能够有效的提高HashMap的性能。

数据读取

public V get(Object key) {

if (key == null)

return getForNullKey();

int hash = hash(key.hashCode());

for (Entry e = table[indexFor(hash, table.length)];

e != null;

e = e.next) {

Object k;

if (e.hash == hash && ((k = e.key) == key || key.equals(k)))

return e.value;

}

return null;

}

有了上面存储时的hash算法作为基础,理解起来这段代码就很容易了。从上面的源代码中可以看出:从HashMap中get元素时,首先计算key的hashCode,找到数组中对应位置的某一元素,然后通过key的equals方法在对应位置的链表中找到需要的元素。

HashMap的性能参数:

HashMap 包含如下几个构造器:

HashMap():构建一个初始容量为16,负载因子为0.75 的HashMap。

HashMap(int initialCapacity):构建一个初始容量为initialCapacity,负载因子为0.75 的HashMap。

HashMap(int initialCapacity, float loadFactor):以指定初始容量、指定的负载因子创建一个HashMap。

HashMap的基础构造器HashMap(int initialCapacity, float loadFactor)带有两个参数,它们是初始容量initialCapacity和加载因子loadFactor。

initialCapacity:HashMap的最大容量,即为底层数组的长度。

loadFactor:负载因子loadFactor定义为:散列表的实际元素数目(n)/ 散列表的容量(m)。

负载因子衡量的是一个散列表的空间的使用程度,负载因子越大表示散列表的装填程度越高,反之愈小。对于使用链表法的散列表来说,查找一个元素的平均时间是O(1+a),因此如果负载因子越大,对空间的利用更充分,然而后果是查找效率的降低;如果负载因子太小,那么散列表的数据将过于稀疏,对空间造成严重浪费。

HashMap的实现中,通过threshold字段来判断HashMap的最大容量:

threshold = (int)(capacity * loadFactor);

1

结合负载因子的定义公式可知,threshold就是在此loadFactor和capacity对应下允许的最大元素数目,超过这个数目就重新resize,以降低实际的负载因子。默认的的负载因子0.75是对空间和时间效率的一个平衡选择。当容量超出此最大容量时,resize后的HashMap容量是容量的两倍。

java中Map类

java中Map类 Map以按键/数值对的形式存储数据,和数组非常相似,在数组中存在的索引,它们本身也是对象。 Map的接口 Map---实现Map Map.Entry--Map的内部类,描述Map中的按键/数值对。 SortedMap---扩展Map,使按键保持升序排列 关于怎么使用,一般是选择Map的子类,而不直接用Map类。 下面以HashMap为例。 public static void main(String args[]) { HashMap hashmap = new HashMap(); hashmap.put("Item0", "Value0"); hashmap.put("Item1", "Value1"); hashmap.put("Item2", "Value2"); hashmap.put("Item3", "Value3"); Set set = hashmap.entrySet(); Iterator iterator = set.iterator(); while (iterator.hasNext() { Map.Entry mapentry = (Map.Entry) iterator.next(); System.out.println(mapentry.getkey() + "/" + mapentry.getValue()); } } 注意,这里Map的按键必须是唯一的,比如说不能有两个按键都为null。 如果用过它,就会知道它的用处了。 又比如: Map map = new HashMap(); map.put("Order", (Order) obj); 资料: Collection容器中包含Set和List接口,Set中又包含HashSet,List中包含LinkedList和ArrayList;单独的Map接口中只有HashMap。 java.util 中的集合类包含Java 中某些最常用的类。最常用的集合类是List 和Map。List 的具体实现包括ArrayList 和Vector,它们是可变大小的列表,比较适合构建、存储和操作任何类型对象的元素列表。List 适用于按数值索引访问元素的情形,其中的数据有顺序且可以重复。而Set中数据无顺序且不可以重复。

集合里Map,Set,List的区别

Java中的Set,List,Map的区别 (转) 对JAVA的集合的理解是相对于数组 相对于数组的是大小固定的,并且同一个数组只能存放类型一样的数据(基本类型/引用类型) JAVA集合可以存储和操作数目不固定的一组数据。 所有的JAVA集合都位于 java.util包中! JAVA集合只能存放引用类型的的数据,不能存放基本数据类型. JAVA集合主要分为三种类型: Set(集) List(列表) Map(映射) Collection 接口 Collection是最基本的集合接口,声明了适用于JAVA集合(只包括Set和List)的通用方法。 Set 和List 都继承了Conllection,Map没有 Collection接口的方法: boolean add(Object o) :向集合中加入一个对象的引用 void clear() :删除集合中所有的对象,即不再持有这些对象的引用 boolean isEmpty() :判断集合是否为空 boolean contains(Object o): 判断集合中是否持有特定对象的引用 Iterartor iterator() : 返回一个Iterator对象,可以用来遍历集合中的元素 boolean remove(Object o):从集合中删除一个对象的引用 int size() :返回集合中元素的数目 Object[] toArray() :返回一个数组,该数组中包括集合中的所有元素 关于:Iterator() 和toArray() 方法都用于集合的所有的元素,前者返回一个Iterator对象,后者返回一个包含集合中所有元素的数组。 Iterator接口声明了如下方法: hasNext(): 判断集合中元素是否遍历完毕,如果没有,就返回true next() :返回下一个元素 remove():从集合中删除上一个有next()方法返回的元素。 Set(集合): Set是最简单的一种集合。集合中的对象不按特定的方式排序,并且没有重复对象。 Set接口主要实现了两个实现类: HashSet : HashSet类按照哈希算法来存取集合中的对象,存取速度比较快

java_Set,List,Map,Vector,ArrayList的区别

JAVA的容器---List,Map,Set Collection ├List │├LinkedList │├ArrayList │└Vector │└Stack └Set Map ├Hashtable ├HashMap └WeakHashMap Collection接口 Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素(Elements)。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类,Java SDK提供的类都是继承自Collection的“子接口”如List和Set。 所有实现Collection接口的类都必须提供两个标准的构造函数:无参数的构造函数用于创建一个空的Collection,有一个Collection参数的构造函数用于创建一个新的Collection,这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。 如何遍历Collection中的每一个元素?不论Collection的实际类型如何,它都支持一个iterator()的方法,该方法返回一个迭代子,使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下: Iterator it = collection.iterator(); // 获得一个迭代子 while(it.hasNext()) { Object obj = it.next(); // 得到下一个元素 } 由Collection接口派生的两个接口是List和Set。

java中List的用法

java中List的用法和实例详解 List的用法 List包括List接口以及List接口的所有实现类。因为List接口实现了Collection接口,所以List接口拥有Collection接口提供的所有常用方法,又因为List是列表类型,所以List接口还提供了一些适合于自身的常用方法,如表1所示。 表1 List接口定义的常用方法及功能 从表1可以看出,List接口提供的适合于自身的常用方法均与索引有关,这是因为List集合为列表类型,以线性方式存储对象,可以通过对象的索引操作对象。 List接口的常用实现类有ArrayList和LinkedList,在使用List集合时,通常情况下声明为List类型,实例化时根据实际情况的需要,实例化为ArrayList或LinkedList,例如: List l = new ArrayList();// 利用ArrayList类实例化List集合 List l2 = new LinkedList();// 利用LinkedList类实例化List集合 1.add(int index, Object obj)方法和set(int index, Object obj)方法的区别 在使用List集合时需要注意区分add(int index, Object obj)方法和 set(int index, Object obj)方法,前者是向指定索引位置添加对象,而后者是修改指定索引位置的对象,例如执行下面的代码: src\com\mwq\TestCollection.java关键代码: public static void main(String[] args) { String a = "A", b = "B", c = "C", d = "D", e = "E"; List list = new LinkedList(); list.add(a);

Java Map集合

java.util 中的集合类包含Java 中某些最常用的类。最常用的集合类是List 和Map。List 的具体实现包括ArrayList 和V ector,它们是可变大小的列表,比较适合构建、存储和操作任何类型对象的元素列表。List 适用于按数值索引访问元素的情形。 Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对(称作“键”和“值”),其中每个键映射到一个值。从概念上而言,您可以将List 看作是具有数值键的Map。而实际上,除了List 和Map 都在定义java.util 中外,两者并没有直接的联系。本文将着重介绍核心Java 发行套件中附带的Map,同时还将介绍如何采用或实现更适用于您应用程序特定数据的专用Map。 了解Map 接口和方法 Java 核心类中有很多预定义的Map 类。在介绍具体实现之前,我们先介绍一下Map 接口本身,以便了解所有实现的共同点。Map 接口定义了四种类型的方法,每个Map 都包含这些方法。下面,我们从两个普通的方法(表1)开始对这些方法加以介绍。 表1:覆盖的方法。我们将这Object 的这两个方法覆盖,以正确比较Map 对象的等价性。 Map 构建 Map 定义了几个用于插入和删除元素的变换方法(表2)。 表2:Map 更新方法:可以更改Map 内容。 尽管您可能注意到,纵然假设忽略构建一个需要传递给putAll() 的Map 的开销,使用putAll() 通常也并不比使用大量的put() 调用更有效率,但putAll() 的存在一点也不稀奇。这是因为,putAll() 除了迭代put() 所执行的将每个键值对添加到Map 的算法以外,还需要迭代所传递的Map 的元素。但应注意,putAll() 在添加所有元素之前可以正确调整Map 的大小,因此如果您未亲自调整Map 的大小(我们将对此进行简单介绍),则putAll() 可能比预期的更有效。 查看Map 迭代Map 中的元素不存在直接了当的方法。如果要查询某个Map 以了解其哪些元素满足特定查询,或如果要迭代其所有元素(无论原因如何),则您首先需要获取该Map 的“视图”。有三种可能的视图(参见表3) 所有键值对—参见entrySet() 所有键—参见keySet() 所有值—参见values() 前两个视图均返回Set 对象,第三个视图返回Collection 对象。就这两种情况而言,问题到这里并没有结束,这是因为您无法直接迭代Collection 对象或Set 对象。要进行迭代,

java中HashMap详解

java中HashMap详解 HashMap 和HashSet 是Java Collection Framework 的两个重要成员,其中HashMap 是Map 接口的常用实现类,HashSet 是Set 接口的常用实现类。虽然HashMap 和HashSet 实现的接口规范不同,但它们底层的Hash 存储机制完全一样,甚至HashSet 本身就采用HashMap 来实现的。 通过HashMap、HashSet 的源代码分析其Hash 存储机制 实际上,HashSet 和HashMap 之间有很多相似之处,对于HashSet 而言,系统采用Hash 算法决定集合元素的存储位置,这样可以保证能快速存、取集合元素;对于HashMap 而言,系统key-value 当成一个整体进行处理,系统总是根据Hash 算法来计算key-value 的存储位置,这样可以保证能快速存、取Map 的key-value 对。 在介绍集合存储之前需要指出一点:虽然集合号称存储的是Java 对象,但实际上并不会真正将Java 对象放入Set 集合中,只是在Set 集合中保留这些对象的引用而言。也就是说:Java 集合实际上是多个引用变量所组成的集合,这些引用变量指向实际的Java 对象。 集合和引用 就像引用类型的数组一样,当我们把Java 对象放入数组之时,并不是真正的把Java 对象放入数组中,只是把对象的引用放入数组中,每个数组元素都是一个引用变量。

HashMap 的存储实现 当程序试图将多个key-value 放入HashMap 中时,以如下代码片段为例: Java代码 1. HashMap map = new HashMap(); 2. map.put("语文" , 80.0); 3. map.put("数学" , 89.0); 4. map.put("英语" , 78.2); HashMap 采用一种所谓的“Hash 算法”来决定每个元素的存储位置。 当程序执行map.put("语文" , 80.0); 时,系统将调用"语文"的hashCode() 方法得到其hashCode 值——每个Java 对象都有hashCode() 方法,都可通过该方法获得它的hashCode 值。得到这个对象的hashCode 值之后,系统会根据该hashCode 值来决定该元素的存储位置。 我们可以看HashMap 类的put(K key , V value) 方法的源代码: Java代码 public V put(K key, V value) { // 如果key 为null,调用putForNullKey 方法进行处理

Java中集合类用法总结

帮助 | 留言交? | 登录 首页我的图书馆主题阅读精彩目录精品文苑Tags 会员浏览好书推荐 以文找文 如何对文章标记,添加批注? Java 中集合?用法总结(转载) wade0564 收录于2010-07-08 阅读数:查看 收藏数:7 公众公开 原文来源 tags : java 集合类 欢迎浏览 wade0564 个人图书馆中收藏的文章,想收藏这篇好文章吗,赶快 吧,1分钟拥有自己的个人图书馆! 我也要收藏 举报 Java 中集合?用法总结 收藏 Collection ├List │├LinkedList │├ArrayList (异步,线程不安全,空间用完时自动增长原容量一半)│└Vector (同 步,线程安全,空间用完时自动增长原容量一倍)│ └Stack └Set ├HashSet └TreeSet Map ├Hashtable ├HashMap ├WeakHashMap └TreeMap Map 接口: | + -- WeakHashMap: 以弱键 实现的基于哈希表的 Map 。在 WeakHashMap 中,当某个键不再正常使用时,将自动移除其条 | 目。更精确地说,对于一个给定的键,其映射的存在并不阻止垃圾回收器对该键的丢弃,这就使该键成为 可终止的,被终 | 止,然后被回收。丢弃某个键时, 其条目从映射中有效地移除,因此,该类的行为与其他的 Map 实现有所不同。此实现 | 不是同步的。 | + -- TreeMap:该映射根据其键的自然顺序进行 排序,或?根据创建映射时提供的 Comparator 进行 排序,具体取决于使用的 | 构造方法。此实现不是同步的。 | + -- HashMap:基于哈希表的 Map 接?的实现。此实现提供所有可选的映射操作,并允许使用 null 值和 null 键。(除了 | 非同步和允许 使用 null 之外,HashMap 类与 Hashtable ?致相同。)此类不保证映射的顺序,特别是它不保证该顺 | 序恒久不变。此实现不是同步的。 | +-- SortedMap: 进一步提供关于键的总体排序 的 Map 。该映射是根据其键的自然顺序进 行排序的,或?根据通常在创建有 序映射时提供的 Comparator 进行排序。对有序映射的 collection 视图(由 entrySet 、keySet 和 values 方法返回 )进行迭代时,此顺序就会反映 出来。要采用此排序方式,还需要提供一些其他操作(此接?是 SortedSet 的对应映 射)。 Collection 接口: | 热点推荐 中国经典汤品——广东汤常用多音字汇总 如果你失恋。。。这些话...影响世界的100个管理定律汽车发动机?作过程和原理分析温家宝总理答中外记?问女人味,有多少男人可以读懂?珍稀的白头叶猴(组图)三鹿门事件之——中国,...国家公务员职务与级别当代古筝四美 付娜《渔...生活?秘方 真的很实用...哲理?品:守护梦想聚会时可以玩的?游戏依赖型人格障碍的表现和治疗经典妙语,十分精彩江边施救[贴图]李一男2003年在港湾...电脑速度慢的解决方法 ...重装系统后必须做的10件?事

java中map集合的用法

1.声明一个map: Map map = new HashMap(); 2.向map中放值,注意:map是key-value的形式存放的.如: map.put("sa","dd"); 3.从map中取值:String str = map.get("sa").toString();结果是:str = "dd"; 4.遍历一个map,从中取得key 和value JDK1.5 Map m = new HashMap(); for (Object o : map.keySet()) { map.get(o); } JDK1.4 Map map = new HashMap() ; Iterator it = map.entrySet().iterator() ; while (it.hasNext()) { Map.Entry entry = (Map.Entry) it.next() ; Object key = entry.getKey() ; Object value = entry.getValue() ; } 了解最常用的集合类型之一Map 的基础知识以及如何针对您应用程序特有的数据优化Map。 本文相关下载: ·Jack 的HashMap 测试 ·Oracle JDeveloper 10g java.util 中的集合类包含Java 中某些最常用的类。最常用的集合类是List 和Map。List 的具体实现包括ArrayList 和Vector,它们是可变大小的列表,比较适合构建、存储和操作任何类型对象元素列表。List 适用于按数值索引访问元素的情形。 Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对(称作“键”和“值”),其中每个键映射到一个值。从概念上而言,您可以将List 看作是具有数值键的Map。而实际上,除了List 和Map 都在定义java.util 中

map集合遍历的五种方法

package nc.util.TestClientTools; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; /** * map集合遍历的五种方法 * @FileName: CircleMap.java * @ClassName: nc.util.TestClientTools.CircleMap * @Description: TODO(这里用一句话描述这个类的作用) * @author chenfang * @email ichenfang163@https://www.360docs.net/doc/e8707507.html, * @date 2017-12-11 下午3:54:24 * @version V1.0 * */ //循环遍历map的五种方法 publicclass CircleMap { publicstaticvoid main(String[] args) { Map tempMap = new HashMap(); tempMap.put("a", 1); tempMap.put("b", 2); tempMap.put("c", 3); // JDK1.4中 // 遍历方法一hashmap entrySet() 遍历 System.out.println("方法一"); Iterator it = tempMap.entrySet().iterator(); while (it.hasNext()) { Map.Entry entry = (Map.Entry) it.next(); Object key = entry.getKey(); Object value = entry.getValue(); System.out.println("key=" + key + " value=" + value); } System.out.println(""); // JDK1.5中,应用新特性For-Each循环 // 遍历方法二 System.out.println("方法二"); for (Map.Entry entry : tempMap.entrySet()) { String key = entry.getKey().toString(); String value = entry.getValue().toString(); System.out.println("key=" + key + " value=" + value);

java Map及MapEntry详解

Map是java中的接口,Map.Entry是Map的一个内部接口。 Map提供了一些常用方法,如keySet()、entrySet()等方法。 keySet()方法返回值是Map中key值的集合;entrySet()的返回值也是返回一个Set集合,此集合的类型为Map.Entry。 Map.Entry是Map声明的一个内部接口,此接口为泛型,定义为Entry。它表示Map中的一个实体(一个key-value对)。接口中有getKey(),getValue方法。 由以上可以得出,遍历Map的常用方法: 1. Map map = new HashMap(); Irerator iterator = map.entrySet().iterator(); while(iterator.hasNext()) { Map.Entry entry = iterator.next(); Object key = entry.getKey(); // } 2.Map map = new HashMap(); Set keySet= map.keySet(); Irerator iterator = keySet.iterator; while(iterator.hasNext()) { Object key = iterator.next(); Object value = map.get(key); // } 另外,还有一种遍历方法是,单纯的遍历value值,Map有一个values方法,返回的是value的Collection集合。通过遍历collection也可以遍历value,如 Map map = new HashMap(); Collection c = map.values(); Iterator iterator = c.iterator(); while(iterator.hasNext()) { Object value = iterator.next();

Java集合框架之Map详解

Java集合框架之Map详解 Map(映射)是一个接口,是一个键值对来进行存储的。一对一对往里内存,而且要保证键的唯一性。 Map |--Hashtable:底层是哈希表数据结构,不可以存入null键null值。该集合是线程同步的。jdk1.0效率低 |--HashMap:底层是哈希表数据结构,允许使用null值和null键,该集合是不同步的。 jdk1.2效率高 |--TreeMap:底层是而查实数据结构。线程不同步。可以用于给Map集合中的键进行排序,和Set很像,其实,Set底层就是使用了Map集合。 Map HashMap是最常用的一个类,那么HashMap的最常用的方法有哪些呢? a)放置:public V put(K key, V value):在此映射中关联指定值与指定键 b)获取:public V get(Object key):返回指定键所映射的值键的集合:public Set keySet():Map的keySet()方法会返回key的集合,因为Map 的键是不能重复的,因此ksySet()方法的返回类型是set。 c)值的集合:public Collection values():Map的值是可以重复的。因此value()方法的返回类型是Collection,可以容纳重复的元素. 我们来看看以下,这些常用方法的使用: import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.Set; public class HashMapTest { public static void main(String[] args) { HashMap map=new HashMap(); map.put("name1", "zhangsan"); map.put("name2", "lisi"); map.put("name3", "wangwu"); map.put("name1", "zhaoliu"); System.out.println(map); System.out.println("--------------------"); String value1=(String) map.get("name2"); System.out.println(value1);

Java中Map的用法详解

Java中Map的用法详解 Map简介 将键映射到值的对象。一个映射不能包含重复的键;每个键最多只能映射到一个值。 此接口取代Dictionary 类,后者完全是一个抽象类,而不是一个接口。 Map 接口提供三种collection 视图,允许以键集、值集或键-值映射关系集的形式查看某个映射的内容。映射顺序定义为迭代器在映射的collection 视图上返回其元素的顺序。某些映射实现可明确保证其顺序,如TreeMap类;另一些映射实现则不保证顺序,如HashMap类。 注:将可变对象用作映射键时必须格外小心。当对象是映射中某个键时,如果以影响equals 比较的方式更改了对象的值,则映射的行为将是不确定的。此项禁止的一种特殊情况是不允许某个映射将自身作为一个键包含。虽然允许某个映射将自身作为值包含,但请格外小心:在这样的映射上equals 和hashCode方法的定义将不再是明确的。 所有通用的映射实现类应该提供两个“标准的”构造方法:一个void (无参数)构造 方法,用于创建空映射;一个是带有单个Map 类型参数的构造方法,用于创建一个与其 参数具有相同键-值映射关系的新映射。实际上,后一个构造方法允许用户复制任意映射,生成所需类的一个等价映射。尽管无法强制执行此建议(因为接口不能包含构造方法),但是JDK 中所有通用的映射实现都遵从它。 此接口中包含的“破坏”方法可修改其操作的映射,如果此映射不支持该操作,这些方 法将抛出UnsupportedOperationException。如果是这样,那么在调用对映射无效时,这些方法可以(但不要求)抛出UnsupportedOperationException。例如,如果某个不可修改的映射(其映射关系是“重叠”的)为空,则对该映射调用putAll(Map) 方法时,可以(但不要求)抛出异常。 某些映射实现对可能包含的键和值有所限制。例如,某些实现禁止null 键和值,另 一些则对其键的类型有限制。尝试插入不合格的键或值将抛出一个未经检查的异常,通常是NullPointerException或ClassCastException。试图查询是否存在不合格的键或值可能抛出异常,或者返回false;某些实现将表现出前一种行为,而另一些则表现后一种。一般来说,试图对不合格的键或值执行操作且该操作的完成不会导致不合格的元素被插入映射中时,将可能抛出一个异常,也可能操作成功,这取决于实现本身。这样的异常在此接口的规范中标记为“可选”。 此接口是Java Collections Framework 的成员。 Collections Framework 接口中的很多方法是根据equals 方法定义的。例如,containsKey(Object key) 方法的规范中写道:“当且仅当此映射包含针对满足 (key==null ? k==null : key.equals(k)) 的键k 的映射关系时,返回true”。不应将此规范解释为:调用具有非空参数key 的Map.containsKey将导致对任意的键k 调用key.equals(k)。实现可随意进行优化,以避免调用equals,例如,可首先比较两个键的哈希码(Object.hashCode() 规范保证哈希码不相等的两个对象不会相等)。一般来说,只要实现者认为合适,各种Collections Framework 接口的实现可随意利用底层Object 方法的指定行为。 常用操作说明 void clear() 从此映射中移除所有映射关系(可选操作)。 booleancontainsKey(Object key) 如果此映射包含指定键的映射关系,则返回true。

JAVA中的集合类讲课讲稿

J A V A中的集合类

为什么要使用集合类 当你事先不知道要存放数据的个数,或者你需要一种比数组下标存取机制更灵活的方法时,你就需要用到集合类。 理解集合类 集合类存放于java.util包中。 集合类存放的都是对象的引用,而非对象本身,出于表达上的便利,我们称集合中的对象就是指集合中对象的引用(reference)。 集合类型主要有3种:set(集)、list(列表)和map(映射)。 (1)集 集(set)是最简单的一种集合,它的对象不按特定方式排序,只是简单的把对象加入集合中,就像往口袋里放东西。 对集中成员的访问和操作是通过集中对象的引用进行的,所以集中不能有重复对象。 集也有多种变体,可以实现排序等功能,如TreeSet,它把对象添加到集中的操作将变为按照某种比较规则将其插入到有序的对象序列中。它实现的是SortedSet接口,也就是加入了对象比较的方法。通过对集中的对象迭代,我们可以得到一个升序的对象集合。 (2)列表 列表的主要特征是其对象以线性方式存储,没有特定顺序,只有一个开头和一个结尾,当然,它与根本没有顺序的集是不同的。 列表在数据结构中分别表现为:数组和向量、链表、堆栈、队列。

关于实现列表的集合类,是我们日常工作中经常用到的,将在后边的笔记详细介绍。 (3)映射 映射与集或列表有明显区别,映射中每个项都是成对的。映射中存储的每个对象都有一个相关的关键字(Key)对象,关键字决定了对象在映射中的存储位置,检索对象时必须提供相应的关键字,就像在字典中查单词一样。关键字应该是唯一的。 关键字本身并不能决定对象的存储位置,它需要对过一种散列(hashing)技术来处理,产生一个被称作散列码(hash code)的整数值,散列码通常用作一个偏置量,该偏置量是相对于分配给映射的内存区域起始位置的,由此确定关键字/对象对的存储位置。理想情况下,散列处理应该产生给定范围内均匀分布的值,而且每个关键字应得到不同的散列码。 集合类简介 java.util中共有13个类可用于管理集合对象,它们支持集、列表或映射等集合,以下是这些类的简单介绍 集: HashSet:使用HashMap的一个集的实现。虽然集定义成无序,但必须存在某种方法能相当高效地找到一个对象。使用一个HashMap 对象实现集的存储和检索操作是在固定时间内实现的.

Java集合Collection、List、Set、Map使用详解

Java集合排序及java集合类详解(Collection, List, Set, Map) 摘要内容 集合是Java里面最常用的,也是最重要的一部分。能够用好集合和理解好集合对于做Java程序的开发拥有无比的好处。本文详细解释了关于Java中的集合是如何实现的,以及他们的实现原理。 目录 1 集合框架 (1) 1.1 集合框架概述 (2) 1.1.1 容器简介 (2) 1.1.2 容器的分类 (4) 1.2 Collection (6) 1.2.1 常用方法 (6) 1.2.2 迭代器 (8) 1.3 List (10) 1.3.1 概述 (10) 1.3.2 常用方法 (11) 1.3.3 实现原理 (15) 1.4 Map (18) 1.4.1 概述 (18) 1.4.2 常用方法 (18) 1.4.3 Comparable 接口 (23) 1.4.4 实现原理 (24) 1.4.5 覆写hashCode() (29) 1.5 Set (33) 1.5.1 概述 (33) 1.5.2 常用方法 (33) 1.5.3 实现原理 (38) 1.6 总结:集合框架中常用类比较 (39) 2 练习 (40) 3 附录:排序 (41) 1集合框架

1.1集合框架概述 1.1.1容器简介 到目前为止,我们已经学习了如何创建多个不同的对象,定义了这些对象以后,我们就可以利用它们来做一些有意义的事情。 举例来说,假设要存储许多雇员,不同的雇员的区别仅在于雇员的身份证号。我们可以通过身份证号来顺序存储每个雇员,但是在内存中实现呢?是不是要准备足够的内存来存储1000个雇员,然后再将这些雇员逐一插入?如果已经插入了500条记录,这时需要插入一个身份证号较低的新雇员,该怎么办呢?是在内存中将500条记录全部下移后,再从开头插入新的记录? 还是创建一个映射来记住每个对象的位置? 当决定如何存储对象的集合时,必须考虑如下问题。 对于对象集合,必须执行的操作主要以下三种: ◆添加新的对象 ◆删除对象 ◆查找对象 我们必须确定如何将新的对象添加到集合中。可以将对象添加到集合的末尾、开头或者中间的某个逻辑位置。 从集合中删除一个对象后,对象集合中现有对象会有什么影响呢?可能必须将内存移来移去,或者就在现有对象所驻留的内存位置下一个“洞”。 在内存中建立对象集合后,必须确定如何定位特定对象。可建立一种机制,利用该机制可根据某些搜索条件(例如身份证号)直接定位到目标对象;否则,便需要遍历集合中的每个对象,直到找到要查找的对象为止。 前面大家已经学习过了数组。数组的作用是可以存取一组数据。但是它却存在一些缺点,使得无法使用它来比较方便快捷的完成上述应用场景的要求。 1.首先,在很多数情况下面,我们需要能够存储一组数据的容 器,这一点虽然数组可以实现,但是如果我们需要存储的数据 的个数多少并不确定。比如说:我们需要在容器里面存储某个

JAVA集合之Map映射深刻总结案例附上解释跟总结

Java集合系列之Map映射学习总结一.HashMap实例 案例1:HashMapDemo1 package Map映射; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; /** * 顺序结构 * 基于哈希表的Map 接口的实现。 * 键和值都允许是null,值可以重复。 * 无序的 * 线程不安全的。(不同步) * 遍历无序输出. * 和Set集一样,没有for循环遍历的方法。 * 遍历Map方法有两种: * ①调用keySet方法: * Set keys = map.keySet(); * Iterator it = keys.iterator(); * ②调用entrySet方法: * Set keys = map.entrySet(); * Iterator it = keys.iterator(); * 本例子遍历的是基本类型 * */ public class HashMapDemo1 { public static void main(String[] args) { HashMap map = new HashMap(); map.put(1, 111); map.put("1", "上海"); map.put(5, "广州"); map.put(3, "西安"); map.put(null,"武汉"); //键允许是null map.put(2, null);//值允许是null map.put(null,null);//键和值都允许是null,会替换前面的null:武汉. System.out.println("**********迭代器遍历调用keySet方法*********"); Set keys = map.keySet();//获取所有的键,放入一个集合中 Iterator it = keys.iterator();//取得迭代器才可以遍历 //遍历出来的结果是无序的。

hashmap的用法

HashMap的用法 - 对HashMap不是很熟悉。特整理一些记录。 HashMap类实现了Map接口,由HashMap类实现的Map集合,允许以null作为键对象,但是因为键对象不可以重复,重复之后就覆盖,在HashMap中的对象是无序的。HashMap的映射关系 就像表中的字段跟值一样,可以把表的查询结果完全转换成HashMap散列表。Object put(K key,V value) 向集合中添加指定值与指定键映射关系。 putAll(Map m) 将指定映射M的所有映射关系复制到此映射中,这些映射关系将替换此映射目前针对指定映射中所有键的所有映射关系。 Object get(Object K) 返回指定键在此标识哈希映射中所映射的值,如果存在指定的键对象则返回与该键对应的值对象;否则返null。 void clear() 移除集合中所有的映射关系。 int size() 返回集合中的键-值映射关系个数。 int hashCode() 返回调用映射的散列码。 Object clone() 返回此 HashMap 实例的浅表复制:并不克隆键和值本身。 boolean equals(Object obj) 如果obj是一个map并包含相同的映射,则返回true. boolean containsKey(Object K) 如果映射中包含了作为键的K,则返回true。 boolean containsValue(Object value) 如果映射中包含了作为值的V,则返回true。 Set > entrySet() 返回此映射所包含的映射关系的 collection视图。 boolean isEmpty() 如果此映射不包含键-值映射关系,也就是说映射是空的,则返回true。 Set keySet() 返回此映射中所包含的键的set视图。 remove(Object K) 删除关键字等于K的映射关系。

java中Map List与Set的区别

java中Map,List与Set的区别 Set,List,Map的区别 java集合的主要分为三种类型: Set(集) List(列表) Map(映射) 要深入理解集合首先要了解下我们熟悉的数组: 数组是大小固定的,并且同一个数组只能存放类型一样的数据(基本类型/引用类型),而JAVA 集合可以存储和操作数目不固定的一组数据。所有的JAVA集合都位于java.util包中!JAVA 集合只能存放引用类型的的数据,不能存放基本数据类型。 简单说下集合和数组的区别:(参考文章:《Thinking In Algorithm》03.数据结构之数组) [html] view plain copy print?在CODE上查看代码片派生到我的代码片 世间上本来没有集合,(只有数组参考C语言)但有人想要,所以有了集合 有人想有可以自动扩展的数组,所以有了List 有的人想有没有重复的数组,所以有了set 有人想有自动排序的组数,所以有了TreeSet,TreeList,Tree** 而几乎有有的集合都是基于数组来实现的. 因为集合是对数组做的封装,所以,数组永远比任何一个集合要快 但任何一个集合,比数组提供的功能要多 一:数组声明了它容纳的元素的类型,而集合不声明。这是由于集合以object形式来存储它们的元素。 二:一个数组实例具有固定的大小,不能伸缩。集合则可根据需要动态改变大小。 三:数组是一种可读/可写数据结构---没有办法创建一个只读数组。然而可以使用集合提供的ReadOnly方法,以只读方式来使用集合。该方法将返回一个集合的只读版本。 Java所有“存储及随机访问一连串对象”的做法,array是最有效率的一种。 1、 效率高,但容量固定且无法动态改变。 array还有一个缺点是,无法判断其中实际存有多少元素,length只是告诉我们array的容量。 2、Java中有一个Arrays类,专门用来操作array。 arrays中拥有一组static函数, equals():比较两个array是否相等。array拥有相同元素个数,且所有对应元素两两相等。fill():将值填入array中。 sort():用来对array进行排序。 binarySearch():在排好序的array中寻找元素。

Java集合Map遍历(三种方式)

package decorator; import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import org.junit.Before; import org.junit.Test; /** * 对于Map的三种方式遍历1.keySet() 2.values() 3.entrySet() * 三种方式得到Set之后,都可以使用foreach或者iterator,不能使用for,因为数据结构决定的 * *@author Administrator * */ public class MapCycle { Mapmap; // 准备好数据 @Before public void testData() { map=new HashMap<>(); map.put(1,"王德海"); map.put(2,"李正成");

map.put(3,"张青"); map.put(4,"王亮"); map.put(5,"刘康"); } /** 测试三种方式,这三种方式最后都是遍历Set,于是都可以使用foreach或者Iterator **/ // 方式1:keySet()方法获取到Set(key) @Test public void testFirst() { Set set =map.keySet(); for(Integer integer : set) { System.out.println(map.get(integer)); } } // 方式2:values()方法获取到Collection(value) @Test public void testSecond() { Collection collection =map.values(); for(String string : collection) { System.out.println(string); } } // 方式3:entrySet()方法获取到Set> @Test

相关文档
最新文档