map接口的继承关系如下图所示
1。Map接口
(1)Map 接口提供三种collection 视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容
(2)某些映射实现可明确保证其顺序，如 TreeMap 类；另一些映射实现则不保证顺序，如 HashMap 类。
(3)将可变对象用作映射键时必须格外小心。如果以影响 equals 比较的方式更改了对象的值，则映射的行为将是不确定的
(4)一个映射不能包含重复的键；每个键最多只能映射到一个值
(5)嵌套接口Map.Entry<K,V>
映射项(键-值对),Map.entrySet方法返回映射的collection视图。获得映射项引用的唯一方法是通过此 collection 视图的迭代器来实现
public static interface Map.Entry<K,V>{
K getKey(); //返回与此项对应的键
V getValue(); //返回与此项对应的值
V setValue(V value); //用指定的值替换与此项对应的值
}
public interface Map<K,V>{
int size(); //返回此映射中的键-值映射关系数
boolean containsKey(Object key); //如果此映射包含指定键的映射关系，则返回 true
boolean containsValue(Obj value); //如果此映射将一个或多个键映射到指定值，则返回 true
V get(Object key); //返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null
V put(K key, V value); //将指定的值与此映射中的指定键关联
V remove(Object key); //如果存在一个键的映射关系，则将其从此映射中移除
Collection<V> values(); //返回此映射中包含的值的 Collection 视图
Set<K> keySet(); //返回此映射中包含的键的 Set 视图
Set<Map.Entry<K,V>> entrySet(); //返回此映射中包含的映射关系的 Set 视图
}</span>
2。HashMap类
(1)基于hash表，允许null值和null键，线程不同步
(2)不保证映射的顺序恒久不变
(3)部分方法
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>,Cloneable,Serializable{
public HashMap(){} //构造一个具有默认初始容量(16)和默认加载因子(0.75)的空HashMap
public HashMap(int initialCapacity){} //构造一个带指定初始容量和默认加载因子(0.75)的空HashMap
public HashMap(int initialCapacity,float loadFactor){} //构造一个带指定初始容量和加载因子的空HashMap
public HashMap(Map<? extends K,? extends V> m){} //构造一个映射关系与指定 Map 相同的新 HashMap
public V put(K key,V value){} //在此映射中关联指定值与指定键。如果该映射以前包含了一个该键的映射关系，则旧值被替换
}
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MyHashMap {
public static void main(String[] args) {
HashMap<Integer , String> hashmap = new HashMap<Integer , String>(); //创建哈希映射对象
String[] str = {"zero" , "one" , "two" , "three" , "four" , "five" , "six" , "seven"}; //初始化对象
for(int i = 0 ; i < 8 ; i++)
hashmap.put(i, str[i]);
Set<Map.Entry<Integer, String>> set = hashmap.entrySet(); //获取键值对对象集合
Iterator< Map.Entry<Integer, String>> iterator = set.iterator(); //获取集合的迭代器
while(iterator.hasNext()){ //遍历集合，取出键值对
Map.Entry<Integer , String> mapentry = iterator.next();
System.out.print( "[ "+mapentry.getKey()+","+mapentry.getValue()+" ]\t" );
}
System.out.println();
Set<Integer> keyset = hashmap.keySet(); //获取键的集合
Iterator<Integer> keyiterator = keyset.iterator(); //获取键集合的迭代器
while(keyiterator.hasNext()){ //遍历键集合，并通过键获取值
Integer key = keyiterator.next();
System.out.print( "[ "+key+","+hashmap.get(key)+" ]\t" );
}
System.out.println();
System.out.println( hashmap.containsKey(2) ); //测试是否包含某个键或值
System.out.println( hashmap.containsValue("two") );
System.out.println( hashmap.size() ); //获取键值对数目
System.out.println( hashmap.remove(2) ); //根据键移除键值对
System.out.println( hashmap.put(null, null) );
System.out.println( hashmap.put(null, "name") );
System.out.println( hashmap.size() ); //获取键值对数目
System.out.println( hashmap.containsKey(2) ); //测试是否包含某个键或值
System.out.println( hashmap.containsValue("two") );
Collection<String> valuecollection = hashmap.values(); //获取值得集合
Iterator<String> valueiterator = valuecollection.iterator(); //获取迭代器
while(valueiterator.hasNext())
System.out.print( valueiterator.next()+"\t" );
System.out.println();
}
}
3。SortedMap接口
(1)进一步提供关于键的总体排序的Map。根据其键的自然顺序进行排序的，或者根据创建有序映射时提供的Comparator进行排序
(2)插入有序映射的所有键都必须实现Comparable接口,所有这些键都必须是可互相比较的
(3)部分方法
public interface SortedMap<K,V> extends Map<K,V>{
Comparator<? super K> comparator(); //返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null
Set<Map.Entry<K,V>> entrySet(); //返回在此映射中包含的映射关系的 Set 视图
SortedMap<K,V> subMap(K fromKey, K toKey); //返回此映射的部分视图，其键值的范围从 fromKey（包括）到 toKey（不包括
}
4。TreeMap类
(1)基于红黑树、键不能null、线程不同步
(2)此实现为 containsKey、get、put 和 remove 操作提供受保证的 log(n) 时间开销
(3)部分方法
public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, Serializable{
TreeMap(){} //使用键的自然顺序构造一个新的、空的树映射
TreeMap(Comparator<? super K> comparator){} //构造一个新的、空的树映射，该映射根据给定比较器进行排序
Collection<V> values(){} //返回此映射包含的值的 Collection 视图
Set<K> keySet(){} //返回此映射包含的键的 Set 视图
Set<Map.Entry<K,V>> entrySet(){} //返回此映射中包含的映射关系的 Set 视图
NavigableMap<K,V> descendingMap(){} //返回此映射中所包含映射关系的逆序视图
Comparator<? super K> comparator(){} //返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 nul
}
import java.util.Comparator;
import java.util.Map;
import java.util.Random;
import java.util.TreeMap;
import java.util.Iterator;
import java.util.Set;
public class TreeMapCom implements Comparator<Person>{
public static void main(String[] args) {
TreeMap<Person,String> treemap = new TreeMap<Person,String>(new TreeMapCom()); //创建树映射对象
String[] str = {"zero","one","two","three","four","five"}; //初始化
Random rnum = new Random();
Random rage = new Random();
int i = 0;
while( i < str.length){
Person person = new Person(rnum.nextInt(30), rage.nextInt(20));
if(!treemap.containsKey(person)){
treemap.put(person, str[i]);
i++;
}
}
Set<Map.Entry<Person, String>> entry = treemap.entrySet(); //获取键值对集合
Iterator<Map.Entry<Person, String>> iterator = entry.iterator(); //获取迭代器
while(iterator.hasNext()){ //遍历
Map.Entry<Person, String> temp = iterator.next();
System.out.print( "[ "+temp.getKey().toString()+","+temp.getValue()+" ]\t" );
}
System.out.println();
}
/* @Override
public int compare(Person arg0, Person arg1) {
return arg0.getAge() - arg1.getAge();
}*/
@Override
public int compare(Person arg0, Person arg1) {
return arg0.getNumber() - arg1.getNumber();
}
}
5。Hashtable类
(1)基于哈希表、键和值均不能null、线程同步
(2)部分方法
public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, Serializable{
Hashtable(){} //用默认的初始容量 (11) 和加载因子 (0.75) 构造一个新的空哈希表
Hashtable(int initialCapacity, float loadFactor){} //用指定初始容量和指定加载因子构造一个新的空哈希表
Set<Map.Entry<K,V>> entrySet(){} //返回此映射中包含的键的 Set 视图
Set<K> keySet(){} //返回此映射中包含的键的 Set 视图
Collection<V> values(){} //返回此映射中包含的键的 Collection视图
V put(K key, V value){} //将指定 key 映射到此哈希表中的指定 value
protected void rehash(){} //增加此哈希表的容量并在内部对其进行重组，以便更有效地容纳和访问其元素
}
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Random;
import java.util.Set;
public class MyHashtable {
public static void main(String[] args) {
Hashtable<Integer , Integer> hashtable = new Hashtable<Integer, Integer>(); //创建hashtable对象
Random rkey = new Random(); //利用随机数进行初始化
Random rvalue = new Random();
int key , value , count = 0 ;
while( count < 8 ){
key = rkey.nextInt(20);
value = rvalue.nextInt(30);
if(!hashtable.containsKey(key)){
hashtable.put(key, value);
count++;
}
}
Set< Map.Entry<Integer, Integer> > set = hashtable.entrySet(); //遍历hashtable
Iterator< Map.Entry<Integer, Integer> > iterator = set.iterator();
while(iterator.hasNext()){
Map.Entry<Integer, Integer> entry = iterator.next();
System.out.print( "[ "+entry.getKey()+","+entry.getValue()+" ]\t" );
}
System.out.println();
System.out.println(hashtable.toString());
System.out.println(hashtable.hashCode());
}
}
2555
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
