Map集合
一. 概述
将键映射到值的对象。一个映射不能包含重复的键;每个键最多只能映射一个值,该集合存储键值对。一对一对往里存。而且要保证键的唯一性。
二. 特点
1. 该集合存储键值对。一对一对往里存。
2. 而且要保证键的唯一性。
三. Map集合的共性方法
1. 添加
V
put
(K key, V value)
将指定的值与此映射中的指定键相关联,如果出现添加相同的键,那么后添加的值会覆盖原有键对应的值,并且该方法返回被覆盖的值即原值。
void putAll
(Map<? extends K,? extends V> t)
从指定集合中
将所有映射关系复制到此映射中。
2. 删除
V
remove
(Object key)
如果存在此键的映射关系,则将其从映射中移除。
void clear
()
从此映射中移除所有映射关系。
3.
判断
boolean
containsKey
(Object key)
如果此集合中
包含指定键的映射关系,则返回true。
boolean
containsValue
(Object value)
如果此集合
为指定值映射一个或多个键,则返回true。
boolean
isEmpty
()
如果此映射未包含键-值映射关系,则返回 true。
4. 获取
V get
(Object key)
返回此集合中
映射到指定键的值,也可以通过此方法的返回值来判断一个键是否存在,不存在返回null。
int size
()
返回此映射中的键-值映射关系数。
Collection<V> values()
获取
map
集合中所有的值,
而Map的值是可以重复的,因此values()方法的返回类型是Collection,可以容纳重复的元素。
Set<K> keySet()
返回key的集合,因为Map的键是不能重复的,因此keySet()方法的返回类型是Set。
Set<Map.Entry<K,V>>entrySet()
返回此集合中
包含的映射关系的 set 视图。
Map集合中的子类
1. Hashtable: 底层是哈希表数据结构,不可存入null键和null值。该集合是线程同步的,JDK1.0,效率较低。
2. HashMap: 底层是哈希表数据结构,允许使用 null 值和 null 键,该集合是不同步的。将hashtable替代,jdk1.2.效率高,它是通过键值对中的键(key)的两个方法,hashCode()和equals(Object obj)来完成键值对的唯一性。如果元素的hashcode值相同,才会去判断equals是否为true,如果元素的hashcode值不同,不会调用equals。。
3. TreeMap: 底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序,假如存入的键值对中的键(key)具备比较性,TreeMap内部会自动将这些元素按照自然升序进行排序存放,假如存入的元素自身不具有比较性,程序在运行时会发生Exceptionin thread "main"java.lang.ClassCastException:com.Test1.Car cannot be cast to java.lang.Comparable。
四. 两种获取或遍历集合的方法
1. keySet()方法获取元素:
将map中所有的键存入到Set集合。因为set具备迭代器, 所以可以迭代方式取出所有的键,在根据get方法。获取每一个键对应的值。
import java.util.*;
class KeySetDemo
{
public static void main(String[] args)
{
//创建Map集合,并添加元素
Map<Integer,String> map = new HashMap<Integer,String>();
map.put(2,"zhangsan");
map.put(6,"lisi");
map.put(3,"wangwu");
map.put(4,"heihei");
map.put(5,"xixi");
//获取map集合中的所有键的Set集合
Set<Integer> keySet = map.keySet();
//有了Set集合就可以获取其迭代器,取值
Iterator<Integer> it = keySet.iterator();
while (it.hasNext())
{
Integer i = it.next();
String s = map.get(i);
System.out.println(i + " = " + s);
}
}
}
2. Set<Map.Entry<k,v>>entrySet()方法获取元素:
将map集合中的映射关系存入到了set集合中,而这个关系的数据类型就是Map.Entry,将这个键值对映射关系关系存入到Set集合中之后,再使用迭代器的方法去遍历没一个键值对映射关系,并通过Map.Entry中的getKey()和getValue()放取出键值 。
entrySet取出方式:
*/
import java.util.*;
class EntrySetDemo
{
public static void main(String[] args)
{
//创建集合,存入元素
Map<String,String> map = new HashMap<String,String>();
map.put("01","lisi1");
map.put("02","lisi2");
map.put("03","lisi3");
map.put("04","lisi4");
//获取map集合中的所有键,存入到Set集合中,
Set<Map.Entry<String,String>> entry = map.entrySet();
//通过迭代器取出map中的键值关系,迭代器接收的泛型参数应和Set接收的一致
Iterator<Map.Entry<String,String>> it = entry.iterator();
while (it.hasNext())
{
//将键值关系取出存入Map.Entry这个映射关系集合接口中
Map.Entry<String,String> me = it.next();
//使用Map.Entry中的方法获取键和值
String key = me.getKey();
String value = me.getValue();
System.out.println(key + " : " + value);
}
}
}
五. 补充:关于Map.Entry
Map是一个接口,其实,Entry也是一个接口,它是Map的子接口中的一个内部接口,就相当于是类中有内部类一样。为何要定义在其内部呢?
原因:
a. Map集合中存储的是映射关系这样的两个数据,是先有Map这个集合,因为只有有了Map集合,有了键值对,才会有键值的映射关系。
b. 关系属于Map集合中的一个内部事物。 而且该事物在直接访问Map集合中的元素。
练习及应用
示例1:
在很多项目中,应用比较多的是一对多的映射关系,这就可以通过嵌套的形式将多个映射定义到一个大的集合中,并将大的集合分级处理,形成一个体系。
package com.map;
import java.util.*;
public class HashMapDemo
{
/*
* 一个Map集合(公司)存放了key(部门)
* 与key对应的 value又是一个嵌套的Map集合(key(员工工号),与key对应的是员工的姓名)
*/
public static void main(String[] args)
{
//创建一个公司集合,才能在公司里面成立各司其政的部门(key=部门名称,value=部门集合)。
HashMap<String,HashMap<String,String>>Corp = new HashMap<String,HashMap<String,String>>();
//创建一个部门集合,才能招募人才,员工为部门出谋划策(key=员工号称,value=员工姓名)
HashMap<String,String> EE = newHashMap<String,String>();
HashMap<String,String> ME = newHashMap<String,String>();
List<Student> Soft3 = newArrayList<Student>();
List<Student> Soft1 = newArrayList<Student>();
//将部门放在公司里面,正式成立
Corp.put("电子工程部",EE);
Corp.put("机构工程部",ME);
school.put("软件3班",Soft3);
school.put("软件1班",Soft1);
//招募员工在部门工作
EE.put("S13006540","Ansen");
EE.put("S13006530","Kaka");
EE.put("S13006480","Hahn");
ME.put("S13006240","Kevil");
ME.put("S13006960","Hank");
ME.put("S13006550","Rudy");
getDepinfo(Corp);
System.out.println(getDepEmpInfo(ME));
System.out.println(getAllEmpInfo(Corp));
}
public static voidgetDepinfo(HashMap<String,HashMap<String,String>> corp)
{
Iterator<Map.Entry<String,HashMap<String,String>>>depIter = corp.entrySet().iterator();
StringBuilder sb = new StringBuilder();
while(depIter.hasNext())
{
Map.Entry<String,HashMap<String,String>>depMap = depIter.next();
String DepName=depMap.getKey();
System.out.println("部门名称: "+DepName+"\n");
}
}
public static StringgetDepEmpInfo(HashMap<String,String> dep)
{
StringBuilder sb = new StringBuilder();
Iterator<Map.Entry<String,String>>Empiter = dep.entrySet().iterator();
while(Empiter.hasNext())
{
Map.Entry<String,String> depMe =Empiter.next();
String workid = depMe.getKey();
String name = depMe.getValue();
sb.append("员工工号:"+workid+" 员工姓名:"+name+"\n");
}
return sb.toString();
}
public static StringgetAllEmpInfo(HashMap<String,HashMap<String,String>> c)
{
StringBuilder strb = new StringBuilder();
Iterator<Map.Entry<String,HashMap<String,String>>>allMap = c.entrySet().iterator();
while(allMap.hasNext())
{
Map.Entry<String,HashMap<String,String>>map = allMap.next();
String DepName=map.getKey();
strb.append("部门名称:"+DepName+"\n");
strb.append(getDepEmpInfo(map.getValue()));
}
return strb.toString();
}
示例2
获取没一个字母出现的次数
package com.map;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapDemo
{
public staticvoid main(String[] args)
{
//System.out.println(getCount("AAC-A+=BBB/CEDD"));
}
public staticString getCount() throws Exception
{
BufferedReader br = new BufferedReader(newInputStreamReader(System.in));
String s = null;
while((s =br.readLine())!= null)
{
break;
}
//将传入的字符串利用String类的toCharArray()转变为字符数组并赋值给chs
char[]chs = s.toCharArray();
TreeMap<Character,Integer> tp = new TreeMap<Character,Integer>();
for(int i= 0; i<chs.length; i++)
{
if(!(chs[i] >= 'a' && chs[i] <= 'z' || chs[i] >= 'A' &&chs[i] <= 'Z'))
{
continue;
}
Integervalue = tp.get(chs[i]);
int count= 0;
if(!(value == null))
{
count=value;
}
count++;
tp.put(chs[i],count);
}
Set<Map.Entry<Character,Integer>> set = tp.entrySet();
Iterator<Map.Entry<Character,Integer>> mapit = set.iterator();
StringBuilder sb = new StringBuilder();
while(mapit.hasNext())
{
Map.Entry<Character,Integer> map = mapit.next();
Characterkey = map.getKey();
Integervalue = map.getValue();
sb.append(key+" 出现 "+value+"次。"+"\n");
}
returnsb.toString();
}
}