--------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ --------------------
1. Map
Map也是一个集合，只是是以键值对存储的，常见的子类有Hashtable,HashMap,TreeMap。
Hashtable：是1.0版本，底层的数据结构是哈希表，键和值和不能是null值，线程安全，和HashMap比较，效率低。
HashMap：是1.2版本的，底层也是哈希表数据结构，键和值可以为空(null),线程不安全，效率比较高。更确切的说，HashMap是Hashtable的升级版。
TreeMap：可以排序，底层是二叉树。
下面以HashMap为例，介绍一下Map集合。
2. HashMap
1. 添加元素
import java.util.HashMap;
import java.util.Map;
public class MapDemo {
public static void main(String[] args) {
/* 定义了一个Map集合，键和值的类型都是String */
Map<String, String> map = new HashMap<String, String>();
map.put("110", "张三");
map.put("111", "李四");
map.put("112", "王五");
System.out.println("Map集合中的键和值：" + map);
System.out.println("----------------");
/* 利用put方法来添加元素，返回值是当前键以前对应的值，如果没有则返回null
*当添加了相同的键，那么新的键和值会替换原来的键和值
* */
System.out.println(map.put("111", "赵六"));//这里返回的是李四，因为此集合中前面有111键对应的值
System.out.println(map.put("113", "王刚"));//此时返回的是null，因为此集合中前面没有与113键对应的值
System.out.println("Map集合中的键和值：" + map);
}
}
结果：
Map集合中的键和值：{112=王五, 110=张三, 111=李四}
----------------
李四
null
Map集合中的键和值：{112=王五, 113=王刚, 110=张三, 111=赵六}
2.判断元素
import java.util.HashMap;
import java.util.Map;
public class MapDemo {
public static void main(String[] args) {
/* 定义了一个Map集合，键和值的类型都是String */
Map<String, String> map = new HashMap<String, String>();
map.put("110", "张三");
map.put("111", "李四");
map.put("112", "王五");
System.out.println("Map集合中的键和值：" + map);
/*
* 利用booleancontainsKey(Object key)判断集合中是否有此键利用boolean
* containsValue(Objectvalue)判断此集合中是否有此值
*/
System.out.println("集合中是否包含110键：" + map.containsKey("110"));
System.out.println("集合中是否包含000键：" + map.containsKey("000"));
System.out.println("集合中是否包含 张三 值：" +map.containsValue("张三"));
System.out.println("集合中是否包含 王梅 值：" +map.containsValue("王梅"));
}
}
结果：
Map集合中的键和值：{112=王五, 110=张三, 111=李四}
集合中是否包含110键：true
集合中是否包含000键：false
集合中是否包含 张三 值：true
集合中是否包含 王梅 值：false
3.删除元素
import java.util.HashMap;
import java.util.Map;
public class MapDemo {
public static void main(String[] args) {
/* 定义了一个Map集合，键和值的类型都是String */
Map<String, String> map = new HashMap<String, String>();
map.put("110", "张三");
map.put("111", "李四");
map.put("112", "王五");
map.put("113", "赵六");
System.out.println("Map集合中的键和值：" + map);
/*
* 利用remove(Objectkey)通过键来删除元素，返回值是此键以前对应的值，如果不存在返回null 利用void
* clear()清空集合中的元素
*/
System.out.println("删除 110键对应的元素：" + map.remove("110"));// 这里返回是张三
System.out.println("删除 120键对应的元素：" + map.remove("120"));// 这里返回null，因为此集合中没有120对应的值
System.out.println("删除指定元素的集合：" + map);
map.clear();// 清空集合
System.out.println("清空集合后的集合：" + map);
}
}
结果：
Map集合中的键和值：{112=王五, 113=赵六, 110=张三, 111=李四}
删除 110键对应的元素：张三
删除 120键对应的元素：null
删除 指定元素的集合：{112=王五, 113=赵六, 111=李四}
清空集合后的集合：{}
3. 获取元素
1.单个获取
import java.util.HashMap;
import java.util.Map;
public class MapDemo {
public static void main(String[] args) {
/* 定义了一个Map集合，键和值的类型都是String */
Map<String, String> map = new HashMap<String, String>();
map.put("110", "张三");
System.out.println("Map集合中的键和值：" + map);
/*
* 利用get(Objectkey)获取键对应的单个值，如果不存在，然会null
*/
System.out.println("获取110对应的值：" + map.get("110"));// 这里返回是张三
System.out.println("获取111对应的值：" + map.get("111"));// 这里返回是null
}
}
结果：
Map集合中的键和值：{110=张三}
获取110对应的值：张三
获取111对应的值：null
2. 获取键的集合
package www.fuxi.jihe;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo {
public static void main(String[] args) {
/* 定义了一个Map集合，键和值的类型都是String */
Map<String, String> map = new HashMap<String, String>();
map.put("110", "张三");
map.put("111", "李四");
map.put("112", "王五");
System.out.println("Map集合中的键和值：" + map);
/*
* 利用Set<K>keySet()获取集合中键的集合返回值是Set集合
* 我们可以通过Set集合中的迭代器读取出键，然后再通过get(key)获取元素
*/
Set<String> set = map.keySet();// 获得键的集合
Iterator<String> it = set.iterator();// 获得键集合的迭代器
while (it.hasNext()) {
String key = it.next();
System.out.println(key + ":" + map.get(key));
}
/*
* 利用Set<K>keySet()获取集合中键的集合返回值是Set集合然后把集合装换成数组，然后读取也可以
*/
System.out.println("----------\n");
Object[] keys = set.toArray();
for (int i = 0; i < keys.length; i++) {
System.out.println((String) keys[i] + "："
+ map.get((String) keys[i]));
}
}
}
结果：
Map集合中的键和值：{112=王五, 110=张三, 111=李四}
112:王五
110:张三
111:李四
----------
112：王五
110：张三
111：李四
3.获取值的集合
packagewww.fuxi.jihe;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo {
publicstatic void main(String[] args) {
/* 定义了一个Map集合，键和值的类型都是String */
Map<String,String> map = new HashMap<String, String>();
map.put("110","张三");
map.put("111","李四");
map.put("112","王五");
System.out.println("Map集合中的键和值：" + map);
/**
* 通过方法Collection<V>values()获得集合中的所有值
*/
System.out.println("集合中的值：");
Collection<String>values=map.values();
Iteratorit=values.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}结果：
Map集合中的键和值：{112=王五, 110=张三, 111=李四}
集合中的值：
王五
张三
李四
4. 通过映射关系
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo {
public static void main(String[] args) {
/* 定义了一个Map集合，键和值的类型都是String */
Map<String, String> map = new HashMap<String, String>();
map.put("110", "张三");
map.put("111", "李四");
map.put("112", "王五");
System.out.println("Map集合中的键和值：" + map);
/*
* 利用Set<Map.Entry<K,V>>entrySet()获取集合中的映射关系
* 然后通过迭代器读取Set集合
* 然后利用Map.Entry中的K getKey()获得键，V getValue()获取值
*/
Set<Map.Entry<String,String>> set=map.entrySet();//获得映射的集合
Iterator<Map.Entry<String,String>> it=set.iterator();//获得迭代器
while(it.hasNext()){
Map.Entry<String, String> en=it.next();//获取集合中的元素
String key=en.getKey();
String value=en.getValue();
System.out.println("键-值："+key+"-"+value);
}
}
}
结果：
Map集合中的键和值：{112=王五, 110=张三, 111=李四}
键-值：112-王五
键-值：110-张三
键-值：111-李四
Map.Entry是Map中的静态接口，此表示的把Map中的元素表示为映射关系
|
static interface |
4. HashMap和TreeMap的比较使用
HashMap比较的时候依赖于hashCode()和equals(Object ob)方法
TreeMap可以添加比较器或者是自然排序，对象实现接口comparable。
1. 利用HashMap
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class HashMapDemo {
public static void main(String[] args) {
/* 定义HashMap，里面存储的是Student和地址 */
HashMap<Student, String> map = new HashMap<Student, String>();
map.put(new Student("张三", 23), "北京");
map.put(new Student("李四", 24), "上海");
map.put(new Student("王五", 23), "南京");
map.put(new Student("张三", 23), "广州");// 存了一个重复的值
// 第一种读取方式
Set<Student> set = map.keySet();
Iterator<Student> it = set.iterator();
while (it.hasNext()) {
Student stu = it.next();
String name = stu.getName();
int age = stu.getAge();
String address = map.get(stu);
System.out.println(name + ":" + age + ":" + address);
}
System.out.println("---------");
System.out.println("下面利用的是映射关系读取");
Set<Map.Entry<Student, String>> ens = map.entrySet();
Iterator<Map.Entry<Student, String>> its =ens.iterator();
while (its.hasNext()) {
Map.Entry<Student, String> me = its.next();
Student stu = me.getKey();
String address = me.getValue();
System.out.println(stu.getName()+ ":" + stu.getAge() + ":"
+ address);
}
}
}
结果：
张三:23:广州
王五:23:南京
李四:24:上海
---------
下面利用的是映射关系读取
张三:23:广州
王五:23:南京
李四:24:上海
2. 利用TreeMap排序
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapDemo {
public static void main(String[] args) {
/* 定义HashMap，里面存储的是Student和地址 */
TreeMap<Student, String> map = new TreeMap<Student, String>();
map.put(new Student("张三", 23), "北京");
map.put(new Student("李四", 21), "上海");
map.put(new Student("王五", 24), "南京");
map.put(new Student("赵六", 26), "广州");
Set<Student> set = map.keySet();
Iterator<Student> it = set.iterator();
while (it.hasNext()) {
Student stu = it.next();
String name = stu.getName();
int age = stu.getAge();
String address = map.get(stu);
System.out.println(name + ":" + age + ":" + address);
}
}
}
结果：
李四:21:上海
张三:23:北京
王五:24:南京
赵六:26:广州
从结果可以看出，是按照年龄排序的，所以说TreeSet是具有排序的功能。
那么现在我们自定义比较器，是按照姓名排序。
import java.util.Comparator;
public class StuNameComparatorimplements Comparator<Student> {
/*按照姓名排序，如果姓名相同，那么按照年龄排序*/
public int compare(Student o1, Student o2) {
int num = o1.getName().compareTo(o2.getName());
if (num == 0) {
return o1.getAge() - o2.getAge();
}
return num;
}
}
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapDemo {
public static void main(String[] args) {
/* 定义HashMap，里面存储的是Student和地址 */
TreeMap<Student, String> map = new TreeMap<Student, String>(newStuNameComparator());
map.put(new Student("java03", 23), "北京");
map.put(new Student("net02", 21), "上海");
map.put(new Student("java01", 24), "南京");
map.put(new Student("net03", 26), "广州");
Set<Student> set = map.keySet();
Iterator<Student> it = set.iterator();
while (it.hasNext()) {
Student stu = it.next();
String name = stu.getName();
int age = stu.getAge();
String address = map.get(stu);
System.out.println(name + ":" + age + ":" + address);
}
}
}
结果:
java01:24:南京
java03:23:北京
net02:21:上海
net03:26:广州
从结果可以看出，是按照姓名排序的，如果姓名相同，就按照年龄排序。
5. 练习
计算字符串中字符的个数，并且输出格式：a(1)b(3)c(4)….
思路：
1.把字符串转化成字符数组后，然后开始遍历数组
2.在遍历的时候，没读取一个字符，然后在集合中查看，如果存在则读取出来，然后数量加1，然后在存入里面如果没有，则添加里面，数量是1.
3.输出格式，读取集合然后拼接字符串，利用StringBuffer。
packagewww.fuxi.jihe;
importjava.util.HashMap;
importjava.util.Iterator;
importjava.util.Map;
importjava.util.Set;
public classMapDemo {
public static void main(String[] args) {
String str ="ahjdkdmkamkmixkxmcsnlasickdj";
char[] cs = str.toCharArray();
HashMap<Character, Integer> map= new HashMap<Character, Integer>();
for (char c : cs) {
if (map.containsKey(c)) {
Integer count =map.get(c);// 取出此字符对应的数量
count++;// 数量++
map.put(c, count);// 然后重新添加里面，覆盖原来的
} else {
map.put(c, newInteger(1));// 开始数量为1
}
}
StringBuffer bu = new StringBuffer();
Set<Character> set =map.keySet();
Iterator<Character> it =set.iterator();
while (it.hasNext()) {
Character c = it.next();
Integer count = map.get(c);
bu.append(c).append("(").append(count).append(")");
}
System.out.println(bu);
}
}
结果：
d(3)s(2)c(2)a(3)n(1)l(1)m(4)j(2)k(5)h(1)x(2)i(2)
要是使用的是TreeMap，那么就会按照字符排序。
6. 模拟学校
模拟学校，然后读取学校中班级—学生信息
利用的是集合中嵌套集合
package www.fuxi.jihe;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
class CollegeStudent {
private Stringnum;
private Stringname;
CollegeStudent(Stringnum, String name) {
super();
this.num =num;
this.name =name;
}
public StringgetNum() {
return num;
}
public StringgetName() {
returnname;
}
}
public class Demo {
public staticvoid main(String[] agrs) {
/* 学校 */
HashMap<String,List<CollegeStudent>> bdxy = new HashMap<String,List<CollegeStudent>>();
List<CollegeStudent>ruanjian = new ArrayList<CollegeStudent>();// 软件班
List<CollegeStudent>jiying = new ArrayList<CollegeStudent>();// 计应班
/* 把班级添加到学校中 */
bdxy.put("ruanjian",ruanjian);
bdxy.put("jiying",jiying);
/*向班级中添加学生*/
ruanjian.add(newCollegeStudent("110","zhansgan") );
ruanjian.add(newCollegeStudent("111","lisi") );
ruanjian.add(newCollegeStudent("112","王五"));
jiying.add(newCollegeStudent("210","wangang") );
jiying.add(newCollegeStudent("211","wangemi") );
jiying.add(newCollegeStudent("212","xiaoqiang") );
/* 遍历学校中的班级，然后读取班级中的学生信息 */
Set<String>set = bdxy.keySet();// 获取班级名称集合
Iterator<String>it = set.iterator();
while(it.hasNext()) {
StringClassName = it.next();
List<CollegeStudent>ClassInfo = bdxy.get(ClassName);// 获得班级
System.out.println(ClassName);
show(ClassInfo);
}
}
/* 输出班级的学生 */
public staticvoid show(List<CollegeStudent> list) {
Iterator<CollegeStudent>it = list.iterator();
while(it.hasNext()) {
CollegeStudentstu = it.next();
System.out.println(" |-"+stu.getNum() + ":" +stu.getName());
}
}
}
结果：
jiying
|-210:wangang
|-211:wangemi
|-212:xiaoqiang
ruanjian
|-110:zhansgan
|-111:lisi
|-112:王五
7.补充知识点
package www.fuxi.jihe;
import java.util.HashMap;
import java.util.Map;
public class Text {
public static void main(String[] args) {
Map<String,String> map=new HashMap<String,String>();
map.put("110", "zhangsan");
map.put("111", "lisi");
map.put("112", "wangwu");
System.out.println("集合："+map);
/*boolean isEmpty()判断是否为空*/
System.out.println(map.isEmpty());
/*int size()判断集合中映射关系的个数*/
System.out.println("大小："+map.size());
}
}
结果：
集合：{112=wangwu, 110=zhangsan, 111=lisi}
false
大小：3
--------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！
--------------------