(37)Java学习笔记——集合框架 / Map集合

最新推荐文章于 2017-02-19 21:52:34 发布

xiexiecm

最新推荐文章于 2017-02-19 21:52:34 发布

阅读量302

点赞数 1

分类专栏： Java 文章标签： java Map

本文链接：https://blog.csdn.net/xiexiecm/article/details/55047331

版权

Java 专栏收录该内容

52 篇文章 0 订阅

订阅专栏

Map集合

Map<k , v>

K - 此映射所维护的键的类型

V - 映射值的类型

最大的特点：可以存储键值对的元素。

将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射一个值。

Map集合和Collection集合的区别：

Map集合存储元素是成对出现的，Collection集合存储元素是单独出现。

Map集合的键是唯一的，至是可重复的。Collection的Set是唯一的，List可以是重复的。

Map集合的数据结构只跟键有关，跟值无关。Collection集合的数据结构是针对元素有效。

Map集合的功能：

A / 添加功能

V put(K key, V value) 添加元素

//如果键是第一次存储，就直接存储，返回null

如果键不是第一次存储，就用值替换以前的值，返回以前的值

B / 删除功能

void clear() :移除所有的键值段元素

V remove(Object key) 根据键删除键值段元素并返回值

C / 判断功能

boolean containsKey(Object key): 判断是否包含指定键

boolean containsValue(Object value) : 判断集合是否包含制定的值

boolean isEmpty() 判断集合是否为空

D / 获取功能

set <Map.Entry<E , V> entrySet() :返回的是键值对对象的集合

V get(Object key) 根据键获取值

Set<k> keySet() 获取集合中所有键的集合

Collection<V> values() 获取集合中所有值的集合

E / 长度功能

int size() 返回集合中的键值对的对数

创建集合对象。Map是个接口，要使用实现类：

HashMap

范例01：

package cn.itcast_01;
/*
 * Map集合
 * A / 添加功能
             V put(K  key,  V value)  添加元素
B / 删除功能
             void clear() :移除所有的键值段元素
             V remove(Object key) 根据键删除键值段元素并返回值
C / 判断功能
             boolean containsKey(Object  key): 判断是否包含指定键
             boolean containsValue(Object  value) : 判断集合是否包含制定的值
             boolean isEmpty()  判断集合是否为空
D / 获取功能
             set <Map.Entry<E , V> entrySet() :
             V get(Object  key)  根据键获取值
             Set<k> keySet()  获取集合中所有键的集合
             Collection<V>  values()  获取集合中所有值的集合
E / 长度功能 
             int size()  返回集合中的键值对的对数
 */
import java.util.HashMap;
import java.util.Map;

/*
 * 作为学生来说，是根据学好来区分不同的学生。那么假设已知道学生学好，根据学好获取学生姓名，怎么做？
 * 针对目前的这种需求：仅仅知道学号，就想知道学生姓名，使用Map
 * 
 */
public class MapDemo {
	public static void main(String[] args) {
		//创建集合对象。Map是个接口，要使用实现类
		Map<String ,String> map = new HashMap<String, String>();
		
		//添加元素
		//V put(K  key,  V value) //添加功能
//		System.out.println("put:"+map.put("文章", "马伊琍"));
		map.put("邓超", "孙俪");
		map.put("黄晓明", "杨颖");
		map.put("周杰伦", "蔡依林");
		map.put("刘恺威", "杨幂");
		
		//void clear() :移除所有的键值段元素
//		map.clear();
		
		// V remove(Object key) 根据键删除键值段元素并返回值
//		System.out.println("remove:"+map.remove("黄晓明"));	//返回值：杨颖
//		System.out.println("remove:"+map.remove("黄小波"));	//返回值：null
		
		//boolean containsKey(Object  key): 判断是否包含指定键
		System.out.println("containsKey:"+map.containsKey("周杰伦"));	返回值：ture
		System.out.println("containsKey:"+map.containsKey("黄小波"));  //返回值：false
		
		//int size()  返回集合中的键值对的对数
		System.out.println("size:"+map.size());   //size:4
	
		
		//输出集合名称
		System.out.println("Map:"+map);
	}
}

范例02：获取功能

package cn.itcast_01;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/*
 * D / 获取功能
             set <Map.Entry<E , V> entrySet() :
             V get(Object  key)  根据键获取值
             Set<k> keySet()  获取集合中所有键的集合
             Collection<V>  values()  获取集合中所有值的集合
 */
public class MapDemo02 {
	public static void main(String[] args) {
		//创建集合对象
		Map<String ,String> map = new HashMap<String, String>();
		
		//创建添加元素

		map.put("邓超", "孙俪");
		map.put("黄晓明", "杨颖");
		map.put("周杰伦", "蔡依林");
		map.put("刘恺威", "杨幂");
		
		//V get(Object  key)  根据键获取值
		System.out.println("get:"+map.get("周杰伦"));
		System.out.println("---------------------");
		
		//Set<k> keySet()  获取集合中所有键的集合
		Set<String> set = map.keySet();
		for(String key : set){
			System.out.println(key);
		}
		System.out.println("---------------------");
		
		//Collection<V>  values()  获取集合中所有值的集合
		Collection<String> con = map.values();
		for(String value : con){
			System.out.println(value);
		}
		
		
	}
}

范例03：Map集合的遍历方法一

package cn.itcast_01;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/*
 * D / 获取功能
             set <Map.Entry<E , V> entrySet() :
             V get(Object  key)  根据键获取值
             Set<k> keySet()  获取集合中所有键的集合
             Collection<V>  values()  获取集合中所有值的集合
 */
public class MapDemo02 {
	public static void main(String[] args) {
		//创建集合对象
		Map<String ,String> map = new HashMap<String, String>();
		
		//创建添加元素

		map.put("邓超", "孙俪");
		map.put("黄晓明", "杨颖");
		map.put("周杰伦", "蔡依林");
		map.put("刘恺威", "杨幂");
		
		//V get(Object  key)  根据键获取值
		System.out.println("get:"+map.get("周杰伦"));
		System.out.println("---------------------");
		
		//Set<k> keySet()  获取集合中所有键的集合
		Set<String> set = map.keySet();
		for(String key : set){
			System.out.println(key);
		}
		System.out.println("---------------------");
		
		//Collection<V>  values()  获取集合中所有值的集合
		Collection<String> con = map.values();
		for(String value : con){
			System.out.println(value);
		}
		
		
	}
}

范例04：Map集合的遍历方法二

package cn.itcast_01;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/*
 * Map集合的遍历
 * A/ 获取所有键值对对象的集合
 * B /遍历键值对对象的集合，得到每一个键值对对象
 * C/ 根据键值对对象获取键和值
 * 
 * 这里面最麻烦的就是键值对对象如何表示呢
 *       set <Map.Entry<E , V> entrySet() :返回的是键值对对象的集合
 */
public class MapDemo04 {
	public static void main(String[] args) {
		//创建集合对象
		Map<String,String> map = new HashMap<String,String>();
		
		//创建元素并添加
		map.put("杨过","小龙女");
		map.put("郭靖","黄蓉");
		map.put("杨康","穆念慈");
		map.put("陈玄风","梅超风");
		
		//获取所有键值对对象的集合
		Set<Map.Entry<String,String>> set = map.entrySet();
		
		//遍历键值对对象的集合，得到每一个键值对对象
		for(Map.Entry<String,String> me : set){
			//根据键值对对象获取键和值
			String key = me.getKey();
			String value = me.getValue();
			System.out.println(key+"----"+value);
		}
	}
}

————————————————————————————

HashMap集合

键是哈希表结构，可以保证键的唯一性

HashMap<String,String> 范例：

package cn.itcast_02;

import java.util.HashMap;
import java.util.Set;

/*
 * HashMapDemo
 * 
 */
public class HashMapDemo {
	public static void main(String[] args) {
		//创建集合对象
		HashMap<String,String> hm = new HashMap<String,String>();
		
		//创建元素并添加

		hm.put("it001", "马云");
		hm.put("it002", "马化腾");
		hm.put("it003", "乔布斯");
		hm.put("it004", "张朝阳");
		hm.put("it005", "求伯君");
		
		//遍历
		Set<String> set = hm.keySet();
		for(String key : set){
			String value = hm.get(key);
			System.out.println(key+"-----"+value);
		}
	}
}

HashMap<Integer,String> 范例：

package cn.itcast_02;

import java.util.HashMap;
import java.util.Set;

/*
 * HashMap<Integer,String>
 * 
 */
public class HashMapDemo02 {
	public static void main(String[] args) {
		//创建集合对象
		HashMap<Integer,String> hm = new HashMap<Integer,String>();
		
		//创建元素并添加
		hm.put(27, "林青霞");
		hm.put(30,"风清扬");
		hm.put(28, "林青霞");
		hm.put(29,"李松好");
		
		//遍历
		Set <Integer> set = hm.keySet();
		for(Integer key : set){
			String value = hm.get(key);
			System.out.println(key+"----"+value);
		}
		
		
	}
}

HashMap<String, Student> 范例

package cn.itcast_02;
/*
 * Student类
 */
public class Student {

	private String name;
	private int age;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.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;
	}
	
	
}

package cn.itcast_02;

import java.util.HashMap;
import java.util.Set;

/*
 * HashMap<String,Student>
 * 
 */
public class HashMapDemo03 {
	public static void main(String[] args) {
		//创建集合对象
		HashMap<String,Student> hm = new HashMap<String,Student>();
		
		//创建学生对象
		Student s1 = new Student("周星驰",50);
		Student s2 = new Student("刘德华",55);
		Student s3 = new Student("梁朝伟",54);
	    Student s4 = new Student("刘嘉玲",50);
		
	    //添加元素
		hm.put("9527",s1);
		hm.put("9522",s2);
		hm.put("9529",s3);
		hm.put("9524",s4);
		
		//遍历
		Set<String> set = hm.keySet();
		for(String key : set){
			Student value = hm.get(key);
			System.out.println(key+"---"+value.getName()+"---"+value.getAge());
		}
	}
}

HashMap<Student , String> 范例：

package cn.itcast_02;
/*
 * Student类
 */
public class Student {

	private String name;
	private int age;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.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;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
	
	
}

package cn.itcast_02;

import java.util.HashMap;
import java.util.Set;

/*
 * HashMap<Student,String>
 * 要求：如果两个对象的成员变量值都相同，则为同一个对象
 * 
 */
public class HashMapDemo04 {
	public static void main(String[] args) {
		//创建集合对象
		HashMap<Student,String> hm =new HashMap<Student,String>();
		
		//创建Student对象
		Student s1 = new Student("周星驰",50);
		Student s2 = new Student("刘德华",55);
		Student s3 = new Student("梁朝伟",54);
	    Student s4 = new Student("刘嘉玲",56);
	    Student s5 = new Student("周星驰",50);
	    
	    //添加元素
	    hm.put(s1, "8888");
	    hm.put(s2, "6666");
	    hm.put(s3, "9999");
	    hm.put(s4, "3333");
	    hm.put(s5, "5555");
	    
	    //遍历
	    Set <Student> set = hm.keySet();
	    for(Student key : set){
	    	String value = hm.get(key);
	    	System.out.println(key.getName()+"---"+key.getAge()+"---"+value);
	    	
	    }
	    
	}
}

LinkedHashMap 类

是Map接口的哈希表和链表实现，具有可预知的迭代顺序

由哈希表保证唯一性

由链表保证有序（存储和取出的顺序）

package cn.itcast_03;

import java.util.LinkedHashMap;
import java.util.Set;

/*
 * LinkedHashMap是Map接口的哈希表和链表实现，具有可预知的迭代顺序
 */
public class LinkedHashMapDemo {
	public static void main(String[] args) {
		//创建集合对象
		LinkedHashMap<String,String> hm = new LinkedHashMap<String,String>();
		
		//创建并添加元素
		hm.put("2345","hello");
		hm.put("1234", "world");
		hm.put("3456", "java");
		hm.put("1234", "javaee");
		hm.put("3456", "android");
		
		//遍历
		Set<String> set = hm.keySet();
		for(String key : set){
			String value = hm.get(key);
			System.out.println(key+"---"+value);
		}
	}
}
/*返回结果：
2345---hello
1234---javaee
3456---android*/

TreeMap 集合
是基于红黑树的Map的集合实现

TreeMap<String, String>

范例：

package cn.itcast_04;

import java.util.Set;
import java.util.TreeMap;

/*
 * TreeMap
 */
public class TreeMapDemo {
	public static void main(String[] args) {
		//创建集合对象
		TreeMap<String,String> tm = new TreeMap<String,String>();
		
		//创建元素并添加
		tm.put("hello", "你好");
		tm.put("world", "世界");
		tm.put("java", "爪洼");
		tm.put("world","世界2");
		tm.put("javaee","爪洼22");
		
		//遍历
		Set<String> set = tm.keySet();
		for(String key : set){
			String value = tm.get(key);
			System.out.println(key+"---"+value);
		}
	}
}

TreeMap<String , Student>

范例：

package cn.itcast_04;
/*
 * Student
 */
public class Student {
	private String name;
	private int age;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.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;
	}

package cn.itcast_04;

import java.util.Set;
import java.util.TreeMap;

/*
 * TreeMap<String,Student>
 */
public class TreeMapDemo_02 {
	public static void main(String[] args) {
		//创建集合对象
		TreeMap<String,Student> tm = new TreeMap<String,Student>();
		
		//创建Student对象
		Student s1 = new Student("刘朝锋",33);
		Student s2 = new Student("张学友",55);
		Student s3 = new Student("刘德华",52);
		Student s4 = new Student("刘家辉",55);
		Student s5 = new Student("张国亮",43);
		
		//添加元素
		tm.put("1111",s1);
		tm.put("2222",s2);
		tm.put("3333",s3);
		tm.put("4444",s4);
		tm.put("5555",s5);
		
		//遍历元素
		Set<String> set = tm.keySet();
		for (String key : set){
			Student value = tm.get(key);
			System.out.println(key+"---"+value.getName()+"---"+value.getAge());
		}
		
	}
}

TreeMap<Student, String>

范例：

package cn.itcast_05;
/*
 * Student
 */
public class Student {
	private String name;
	private int age;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.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;
	}
	
}

package cn.itcast_05;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;

/*
 * TreeMap<Student,String>
 * 
 */
public class TreeMapDemo {
	public static void main(String[] args) {
		//创建集合对象
		TreeMap<Student,String> tm = new TreeMap<Student,String>(
				new Comparator<Student>() {	//采用比较器的方式重写
					@Override
					public int compare(Student s1, Student s2) {
						//主要条件
						int num =  s1.getAge() - s2.getAge();
						//次要条件
						int num2 = num == 0?s1.getName().compareTo(s2.getName()):num;
						return num2;
					}
				}
				);
		
		//创建Student对象
		Student s1 = new Student("刘德华",54);
		Student s2 = new Student("张国荣",51);
		Student s3 = new Student("王力宏",39);
		Student s4 = new Student("栗朝辉",33);
		Student s5 = new Student("张国荣",51);
		
		//添加元素
		tm.put(s1, "1111");
		tm.put(s2, "2222");
		tm.put(s3, "3333");
		tm.put(s4, "4444");
		tm.put(s5, "5555");
		
		//遍历
		Set<Student> set = tm.keySet();
		for (Student key : set){
			String value = tm.get(key);
			System.out.println(key.getName()+"---"+key.getAge()+"---"+value);
		}
				
	}
}

___________________________________

练习01：“aababcabcdabcde"获取字符串中每一个字母出项的次数，要求结果：a(5)b(4)c(3)d(2)e(1)

package cn.itcast_06;

import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;

/*
 * “aababcabcdabcde"获取字符串中每一个字母出项的次数，要求结果：a(5)b(4)c(3)d(2)e(1)
 * 思路：
 * A / 定义一个字符串 (可以改进为键盘输入）
 * B / 定义一个Map集合——》需要排序，用TreeMap集合
 * 		键：Character
 * 		值：Integer
 * C / 把字符串转成字符数组
 * D / 遍历字符数组得到每一个字符
 * E / 拿这个字符到Map集合中去找，看返回值
 * 		返回值是null:就吧该字符作为键，1作为值存储
 * 			不是null:就把值++ ，然后重新存储该键和值
 * F / 定义一个字符串缓冲区
 * G / 遍历TreeMap集合，获取每一个键值对元素拼接
 * H / 把字符串缓冲区转换成字符串输出
 */
public class TreeMapTest_01 {
	public static void main(String[] args) {
		//键盘录入
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入字符串：");
		String line = sc.nextLine();
		
		//定义个一个Map集合
		TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
		
		//把字符串转成字符数组
		char[] chs = line.toCharArray();
		
		//便利字符数组得到每一个字符
		for(char ch : chs){
			//拿这个字符到Map集合中去找，看返回值
			Integer i = tm.get(ch);
			
			//是null:就吧该字符作为键，1作为值存储
			if(i == null){
				tm.put(ch,1);
			}
			//不是null:就把值++ ，然后重新存储该键和值
			else {
				i++;
				tm.put(ch,i);
			}
		}
		
		// 定义一个字符串缓冲区
		StringBuilder sb = new StringBuilder();
		
		//遍历TreeMap集合，获取每一个键值对元素拼接
		Set<Character> set = tm.keySet();
		for (Character key : set){
			Integer value = tm.get(key);
			
			//拼接
			sb.append(key).append("(").append(value).append(")");
		}
		
		//把字符串缓冲区转换成字符串输出
		String s = sb.toString();
		System.out.println(s);
		
	}
}

——————————————————————————————————————————

Map集合的嵌套遍历

1 / HashMap 嵌套 HashMap

范例：

package cn.itcast_07;

import java.util.HashMap;
import java.util.Set;

/*
 * HashMap嵌套HashMap
 * 场景：
 * 歌舞团
 * 		jc 基础班
 * 			陈玉楼	20
 * 			高越		22
 * 		gy 就业班
 * 			李杰		21
 * 			超市类	23
 * A / 先存储元素，然后遍历元素
 * 
 */
public class HashMap_HashMapDemo {
	public static void main(String[] args) {
		//创建集合对象(集合嵌套）
		HashMap<String,HashMap<String,Integer>> gwtMap = new HashMap<String,HashMap<String,Integer>>();
		
		//创建基础班集合对象
		HashMap<String,Integer> jcMap = new HashMap<String,Integer>();
		
		//创建就业班集合对象
		HashMap<String,Integer> gyMap = new HashMap<String,Integer>();
		
		//创建并添加元素
		jcMap.put("陈玉楼", 20);
		jcMap.put("高越", 22);
		gyMap.put("李杰", 21);
		gyMap.put("超市类", 23);
		
		//把两个班级加入大集合
		gwtMap.put("jc", jcMap);
		gwtMap.put("gy", gyMap);
		
		//遍历
		Set<String> gwtMapSet = gwtMap.keySet();
		for(String gwtKey : gwtMapSet){
			System.out.println(gwtKey);
			
			HashMap<String,Integer> gwtMapValue = gwtMap.get(gwtKey);
			Set<String> gwtMapValueSet = gwtMapValue.keySet();
			
			for(String  gwtMapValueKey :gwtMapValueSet ){
				Integer gwtMapValueValue = gwtMapValue.get(gwtMapValueKey);
				System.out.println("\t"+gwtMapValueKey+"---"+gwtMapValueValue);
			}
		}

输出结果：

gy
超市类---23
李杰---21
jc
高越---22
陈玉楼---20

2 / HashMap嵌套ArrayList

范例：

package cn.itcast_07;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

/*
 * HashMap嵌套ArrayList
 * 假设HashMap集合的元素是ArrayList,有3个
 * 每一个ArrayList集合的值是字符串
 * 依据需求结果定义元素，遍历
 * 需求结果：
 * 		三国演义
 * 			吕布
 * 			周瑜
 * 		笑傲江湖
 * 			令狐冲
 * 			林平之
 * 		神雕侠侣
 * 			郭靖
 * 			杨过
 * 
 * 
 */
public class HashMap_ArrayListDemo {
	public static void main(String[] args) {
		//定义集合对象（大集合）
		HashMap<String, ArrayList<String>> bigMap = new HashMap<String, ArrayList<String>>();
		
		//定义ArrayList集合1
		ArrayList<String> array1 = new ArrayList<String>();
		
		//创建集合1元素并添加
		array1.add("吕布");
		array1.add("周瑜");
		bigMap.put("三国演义", array1);
		
		//定义ArrayList集合1
		ArrayList<String> array2 = new ArrayList<String>();
		
		//创建集合1元素并添加
		array2.add("令狐冲");
		array2.add("林平之");
		bigMap.put("笑傲江湖", array2);
		
		//定义ArrayList集合1
		ArrayList<String> array3 = new ArrayList<String>();
		
		//创建集合1元素并添加
		array3.add("郭靖");
		array3.add("杨过");
		bigMap.put("神雕侠侣", array3);
		
		//遍历
		Set<String> bigMapSet = bigMap.keySet();
		for (String bigMapKey : bigMapSet){
			System.out.println(bigMapKey);
			
			ArrayList<String> bigMapValue = bigMap.get(bigMapKey);
			for (String s : bigMapValue){
				System.out.println("\t"+s);
			}
		}
	}
}

3 / ArrayList嵌套HashMap

范例：

package cn.itcast_07;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

/*
 * ArrayList嵌套HashMap
 * 需求：
 * 		假设ArrayList集合的元素是HashMap，有3个
 * 		每一个HashMap集合的键和值都是字符串
 * 需求结果：
 * 		周瑜---小乔
 * 		吕布---貂蝉
 * 
 * 		郭靖---黄蓉
 * 		杨过---小龙女
 * 
 * 		令狐冲---任盈盈
 * 		林平之---岳林珊
 * 
 */
public class ArrayList_HashMapDemo {
	public static void main(String[] args) {
		//创建集合（大集合）
		ArrayList<HashMap<String,String>> array = new ArrayList<HashMap<String,String>>();
		
		//创建HashMap集合并添加元素
		HashMap<String,String> hm1 = new HashMap<String,String>();
		hm1.put("吕布","貂蝉");
		hm1.put("周瑜","小乔");
		//把元素加入ArrayList
		array.add(hm1);
		
		HashMap<String,String> hm2 = new HashMap<String,String>();
		hm1.put("郭靖","黄蓉");
		hm1.put("杨过","小龙女");
		//把元素加入ArrayList
		array.add(hm2);
		
		HashMap<String,String> hm3 = new HashMap<String,String>();
		hm1.put("令狐冲","任盈盈");
		hm1.put("林平之","岳林珊");
		//把元素加入ArrayList
		array.add(hm3);
		
		//遍历大集合
		for (HashMap<String,String> s : array){
			//变量小集合
			Set<String> set = s.keySet();
			for(String key : set){
				String value = s.get(key);
				System.out.println(key+"---"+value);
				

			}
		}
		
	}
}