Collection 接口是保存单值最大的父接口,那么 Map接口保存的内容是一对值,所有的内容是以:key->value 的形式保存的。
张三 123456
李四 234567
王五 345678
HashMap、Hastable、TreeMap
Map 接口的常用方法如下所示:
No. | 方法 | 类型 | 描述 |
1 | V put(K key,V value) | 普通 | 增加内容 |
2 | V get(Object key) | 普通 | 取得设置的内容,根据key取得 |
3 | boolean containsKey(Object key) | 普通 | 查找指定的key 是否存在 |
4 | boolean containsValue(Object value) | 普通 | 查找指定的value 是否存在 |
5 | boolean isEmpty() | 普通 | 判断集合是否为空 |
6 | Set<K> keySet() | 普通 | 将全部的key变为Set 集合 |
7 | Collection<V> values() | 普通 | 将全部的value 变为Collection集合 |
8 | V remove(Object key) | 普通 | 根据key 删除内容 |
9 | void putAll(Map<? extends K,? extends V>m) | 普通 | 增加一组数据 |
新的子类:HashMap
HashMap 是一个新的操作类,其本身可以直接为Map 接口进行实例化操作
package org.hashmapdemo;
import java.util.HashMap;
import java.util.Map;
public class HashMapDemo01 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("zhangsan", 1);
map.put("zhangsan", 2);
map.put("lisi", 3);
map.put("wangwu", 5);
System.out.println(map);
}
}
package org.hashmapdemo;
import java.util.HashMap;
import java.util.Map;
public class HashMapDemo01 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("zhangsan", 1);
map.put("zhangsan", 2);
map.put("lisi", 3);
map.put("wangwu", 5);
Integer value = map.get("zhangsan1");
System.out.println(value);
}
}
package org.hashmapdemo;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class HashMapDemo01 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("zhangsan", 1);
map.put("zhangsan", 2);
map.put("lisi", 3);
map.put("wangwu", 5);
Set<String> setall = map.keySet();
Iterator<String> ite = setall.iterator();
while (ite.hasNext()){
System.out.println(ite.next());
}
}
}
还可以在以上的程序上进行扩展,再将全部的值取出
package org.hashmapdemo;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class HashMapDemo01 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("zhangsan", 1);
map.put("zhangsan", 2);
map.put("lisi", 3);
map.put("wangwu", 5);
Set<String> setall = map.keySet();
Iterator<String> ite = setall.iterator();
while (ite.hasNext()){
String str = ite.next();
System.out.println(str + "-->"+map.get(str));
}
}
}
从运行结果可以发现,HashMap 本身也属于无序的一种操作
也可以通过 values()方法,将全部的value 通过一个Collection 接口的形式返回
package org.hashmapdemo;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class HashMapDemo02 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("zhangsan", 1);
map.put("zhangsan", 2);
map.put("lisi", 3);
map.put("wangwu", 5);
Collection<Integer> col = map.values();
Iterator<Integer> ite = col.iterator();
while(ite.hasNext()){
Integer value = ite.next();
System.out.println(value);
}
}
}
所有的操作与Collection 类似,只是多了一个key 而已
旧的子类:Hashtable
Hashtable 实际上与Vector 的产生时代是一样,也属于最早的集合操作类。之后只是扩展了其应用实现了Map 接口而已
package org.hashmapdemo;
import java.util.Hashtable;
import java.util.Map;
public class HashtableDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map<String,Integer> map = new Hashtable<String,Integer>();
map.put("zhangsan", 1);
map.put("zhangsan", 2);
map.put("lisi", 3);
map.put("wangwu", 5);
System.out.println(map);
}
}
HashMap 与Hashtable 的区别
No | 区别点 | HashMap | Hashtable |
1 | 推出时间 | 是在JDK1.2之后推出的,属于新的类 | 是在JDK1.0时推出的,属于旧的操作类 |
2 | 操作 | 采用异步的处理操作 | 采用同步的处理操作 |
3 | 性能 | 性能高 | 性能相对较低 |
4 | 安全 | 非线程安全的操作 | 线程安全 |
按key 排序的子类:TreeMap
TreeMap 使用的时候可以进行按照key 的方式进行排序
package org.hashmapdemo;
import java.util.Map;
import java.util.TreeMap;
public class TreeMapDemo01 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map<String,Integer> map = new TreeMap<String,Integer>();
map.put("A、zhangsan", 1);
map.put("A、zhangsan", 2);
map.put("C、lisi", 3);
map.put("B、wangwu", 5);
System.out.println(map);
}
}
如果现在在给定任意的一个类,那么是否可以直接排序呢?类必须实现Comparable 接口
注意事项一:Map 不能直接使用Iterator输出
在集合的标准操作中所有的集合内容最好都使用Iterator 进行输出,但是在Map接口中并没有明确的定义出这样的操作。如果,没有的话,则就必须深入了解Map存储机制。
在Map 中虽然是以一对值的形式出现的,可是真正的保存的还是一个单独的对象,即:程序将key->value 的放在一个对象之中,之后将此对象加入到集合里
Map.Entry,Map实体,从定义格式上可以发现,此接口属于static 声明的接口,而且是一个内部接口。
对于 Map 和Map.Entry 的关系如图所示,如果要想输出则肯定依靠Map.Entry。
所以,下面就可以给出Map接口使用Iteartor 输出的标准操作
1. 通过Map 接口中的: Set<Map.Entry<K,V>> entrySet() 方法取得 Set集合
2. 通过Set 接口为Iterator 进行初始化的操作
3. 通过Iterator 取出每一个 Map.Entry
4. 通过Map.Entry 进行key 与 value 的分离
package org.hashmapdemo;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class HashMapDemo03 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("zhangsan", 1);
map.put("zhangsan", 2);
map.put("lisi", 3);
map.put("wangwu", 5);
Set <Map.Entry<String,Integer>> setmap = map.entrySet();
Iterator<Map.Entry<String,Integer>> ite = setmap.iterator();
while (ite.hasNext()){
Map.Entry<String,Integer> myent = ite.next();
System.out.println(myent.getKey()+"-->"+myent.getValue());
}
}
}
在JDK 1.5 之后也可以使用 foreach 输出全部的内容
package org.hashmapdemo;
import java.util.HashMap;
import java.util.Map;
public class foreachmap {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map<String,Integer> map = new HashMap<String,Integer>();
map.put("zhangsan", 1);
map.put("zhangsan", 2);
map.put("lisi", 3);
map.put("wangwu", 5);
for (Map.Entry<String, Integer> my:map.entrySet()){
System.out.println(my.getKey()+"-->"+my.getValue());
}
}
}
注意事项二:使用非系统类作为key
现在建立一个Person 类,并在Map中设置多个对象。使用String 作为 key
package org.hashmapdemo;
public class Person {
private String name;
private int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return "姓名:"+this.name+" 年龄:"+this.age;
}
}
在Map 中加入多个内容
package org.hashmapdemo;
import java.util.HashMap;
import java.util.Map;
public class HashMapDemo4 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map<String,Person> map = new HashMap<String,Person>();
map.put("zf", new Person("张三",30));
System.out.println(map);
}
}
在Map 中可以使用匿名对象找到一个key 对应的value
package org.hashmapdemo;
import java.util.HashMap;
import java.util.Map;
public class HashMapDemo4 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map<String,Person> map = new HashMap<String,Person>();
map.put("zf", new Person("张三",30));
System.out.println(map.get("zf"));
System.out.println(map.get(new String("zf")));
}
}
如果现在反过来
package org.hashmapdemo;
import java.util.HashMap;
import java.util.Map;
public class HashMapDemo4 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map<String,Person> map = new HashMap<String,Person>();
map.put("zf", new Person("张三",30));
System.out.println(map.get(new Person("张三",30)));
}
}
现在发现无法通过key 找到 value 了。实现equals()和hashCode()来区分是否是同一个对象
public boolean equals(Object obj){
if (this == obj){
return true;
}
if (!(obj instanceof Person)){
return false;
}
Person per = (Person)obj;
if (this.name.equals(per.name) && this.age == per.age){
return true;
}else{
return false;
}
}
public int hashCode(){
return this.name.hashCode() * this.age;
}
其他子类:使用非系统类作为key
默认情况下,一个Map集合中的key 是不能重复的,那么这种做法是Map 的标准做法,但是在集合中提供了一个非正常的操作子类:IdentityHashMap,通过此类加入的内容,如果对象的地址不相等,则认为不是同一个对象,可以重复加入。
package org.hashmapdemo;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class IdentityHashMapDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Map<Person,String> map = new IdentityHashMap<Person,String>();
map.put(new Person("张三",30),"zf" );
map.put(new Person("张三",30),"zf" );
System.out.println(map);
}
}
只有在两个对象执行 “==” 操作的时候不相等才会认为 不是同一个对象