您当前的位置： 首页 > 学无止境 > 心得笔记 网站首页心得笔记
javase第三季学习笔记-集合框架Map接口
发布时间：2017-08-10 15:52:08编辑：雪饮阅读（）
Map接口
public interface Map<K,V>
将键映射到值的对象，一个映射不能包含重复的键；每个键最多只能映射到一个值。
|
void clear() |
清空Map集合中的内容 |
|
boolean containsKey(Object key) |
判断集合中是否存在指定的key |
|
boolean containsValue(Object value) |
判断集合中是否存在指定的value |
|
Set<Map.Entry<K,V>> entrySet() |
将Map接口变为Set集合 |
|
V get(Object key) |
根据key找到其对应的value |
|
boolean isEmpty() |
判断是否为空 |
|
Set<K> keySet() |
将全部的key变为Set集合 |
|
Collection<V> values() |
将全部的value变为Collection集合 |
|
V put(K key,V value) |
向集合中增加内容 |
|
void putAll(Map<? extends K,? extends V> m) |
增加一组集合 |
|
V remove(Object key) |
根据key删除内容 |
HashMap
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
代码示例：
package com.vince.map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo {
/*
HashMap实现类
使用哈希表实现
不保证集合中元素的顺序
key和val组成entry对象
存储算法：对key计算hashcode值，然后将此值与数组长度取余，然后来决定其entry存储索引位置
若计算出来的位置有重复，则直接取该位置的next
当集合满了之后扩容后就需要重新计算哈希值，并重新分配每个entry对象的索引，这样很影响性能
哈希表满了后每次重新散列的方式：原数组长度*2
哈希表默认大小16，加载因子0.75
*/
public static void hashmap(){
//创建一个HashMap对象
Map<Integer,String> map=new HashMap<Integer,String>();
map.put(1,"雪饮老师");
map.put(2,"柠檬不萌老师");
map.put(3,"杜敏捷老师");
//通过指定键名来输出键值
System.out.println(map.get(2));
//输出HashMap对象大小
System.out.println(map.size());
//判断一个键是否存在
System.out.println(map.containsKey(3));
//判断一个值是否存在
System.out.println(map.containsValue("杜敏捷老师"));
//计算hashCode值
Integer i3=new Integer(3);
System.out.println(i3.hashCode());
//通过获取map中所有key对象的set
Set<Integer> keyset=map.keySet();
Iterator<Integer> iter=keyset.iterator();
while(iter.hasNext()){
Integer key=iter.next();
String value=map.get(key);
System.out.println(value);
}
}
public static void main(String[] args) {
hashmap();
}
}
Hashtable
public class Hashtable<K,V> extends Dictionary<K,V>
implements Map<K,V>, Cloneable, Serializable
此类实现一个哈希表，该哈希表将键映射到相应的值。任何非 null 对象都可以用作键或值。
为了成功地在哈希表中存储和获取对象，用作键的对象必须实现 hashCode 方法和 equals 方法。
代码示例：
package com.vince.map;
import java.util.Hashtable;
public class MapDemo {
/*
Hashtable实现类
不允许键值为null
用默认的初始容量11，加载因子0.75，构造一个新的空哈希表
线程安全的，同步
*/
public static void hashtable(){
Hashtable<String,String> table=new Hashtable<String,String>();
table.put("1","杜敏捷老师");
table.put("2","雪饮老师");
}
public static void main(String[] args) {
}
}
TreeMap
public class TreeMap<K,V> extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, Serializable
基于红黑树（Red-Black tree）的 NavigableMap 实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。
红黑树就是二叉树，是自平衡（普通二叉树分支有多有少，不平衡）的二叉树，分颜色的二叉树。
代码示例：
主程序：
package com.vince.map;
import java.util.Map;
import java.util.TreeMap;
public class MapDemo {
/*
TreeMap实现类
使用二叉树的红黑树实现
以key对象的自然顺序构造映射树
使用自定义对象作为key值，该对象必须实现比较器Comparable
*/
public static void treemap(){
Map<Integer,String> map=new TreeMap<Integer,String>();
map.put(1,"黑老师");
map.put(2,"白老师");
//输出集合大小
System.out.println(map.size());
Map<Person,String> map2=new TreeMap<Person,String>();
map2.put(new Person("黑老师",20),"黑老师");
map2.put(new Person("白老师",22),"白老师");
System.out.println(map2.size());
}
public static void main(String[] args) {
treemap();
}
}
所用的类：
package com.vince.map;
//TreeMap是有序的，而对于对象来说需要实现比较器Comparable，否则无法排序
public class Person implements Comparable<Person> {
private String name;
private int age;
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person() {
super();
// TODO 自动生成的构造函数存根
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public int compareTo(Person o) {
if(o==null){
throw new NullPointerException();
}
else if(this.age<o.age){
return -1;
}
else if(this.age>o.age){
return 1;
}
else{return 0;}
}
}
LinkedHashMap
public class LinkedHashMap<K,V>
extends HashMap<K,V> implements Map<K,V>
Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。此实现与 HashMap 的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。
示例代码：
package com.vince.map;
import java.util.LinkedHashMap;
import java.util.Map;
public class MapDemo {
/*
LinkedHashMap实现类
map接口的哈希表和链接列表实现，具有可预知的迭代顺序
*/
public static void linkedHashMap(){
Map<Integer,String> map=new LinkedHashMap<Integer,String>();
map.put(1,"黑老师");
map.put(2,"白老师");
//输出集合大小
System.out.println(map.size());
}
public static void main(String[] args) {
linkedHashMap();
}
}
Map集合的输出
在Collection接口中，可以使用iterator()方法为Iterator接口实例化，并进行输出操作，但是在Map接口中并没有此方法的定义，所以Map接口本身是不能直接使用Iterator进行输出的。
Set<Map.Entry<K,V>> entrySet()
返回此映射所包含的映射关系的 Set 视图。
返回此映射中所包含的键的 Set 视图。
Collection<V> values()
返回此映射所包含的值的 Collection 视图。
示例代码：
package com.vince.map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class MapDemo {
/*
Map接口的输出方式：
使用map.keySet()方法把所有的key对象以转换成Set集合，然后迭代set集合取出每个key，再通过key从map中取出value
*/
public static void print(){
Map<Integer,String> map=new HashMap<Integer,String>();
map.put(1,"雪饮老师");
map.put(2,"柠檬不萌老师");
map.put(3,"杜敏捷老师");
//只拿value的迭代方式
//将所有的values转换为Collection集合
Collection<String> c=map.values();
//通过Collection集合构建迭代器
Iterator<String> iter=c.iterator();
while(iter.hasNext()){
System.out.println(iter.next());
}
System.out.println("---entry遍历方式----");
//将所有的entry对象Entry<M, I>t集合进行迭代的方式
Set<Entry<Integer,String>> entrys=map.entrySet();
Iterator<Entry<Integer,String>> iter2=entrys.iterator();
while(iter2.hasNext()){
Entry<Integer,String> entry=iter2.next();
System.out.println(entry.getKey() + " " + entry.getValue());
}
}
public static void main(String[] args) {
print();
}
}
关键字词：javase,集合框架Map接口