listdamo4（2）

package listdamo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import java.util.Vector;

public class listdamo4 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// listArrays();
		// studentList();
		// listSet();
		// vectorList();
		// SetList();
		// hashSet();
		//linkedHashSet();
		treeSet();
	}

	public static void listArrays() {
		// 创建 ArrayList
		ArrayList<String> array = new ArrayList<String>();
		// 添加元素
		array.add("hello");
		array.add("world");
		array.add("java");
		System.out.println("----------利用迭代器遍历集合----------------");
		// 利用迭代器遍历集合
		Iterator<String> it = array.iterator();
		while (it.hasNext()) {
			String s = it.next();
			System.out.println(s);
		}

		System.out.println("----------利用for遍历集合 ----------------");
		// 利用for遍历集合
		for (int x = 0; x < array.size(); x++) {
			String S = array.get(x);
			System.out.println(S);
		}
	}

	public static void studentList() {
		// 创建集合对象
		ArrayList<Student> arrayStudent = new ArrayList<Student>();
		// 创建元素对象
		Student s1 = new Student("xiaming", 21);
		Student s2 = new Student("xiaozhang", 22);
		Student s3 = new Student("xiaowan", 23);
		// 添加元素到集合
		arrayStudent.add(s1);
		arrayStudent.add(s2);
		arrayStudent.add(s3);

		System.out.println("----------利用迭代器遍历集合-Student--------------");
		// 利用迭代器遍历集合
		Iterator<Student> it = arrayStudent.iterator();
		while (it.hasNext()) {
			Student s = it.next();
			System.out.println(s.getName() + "------" + s.getAge());
		}
		System.out.println("----------利用for遍历集合 -Student--------------");
		// 利用for遍历集合
		for (int x = 0; x < arrayStudent.size(); x++) {
			Student s21 = arrayStudent.get(x);
			System.out.println(s21.getName() + "=====" + s21.getAge());

		}
		System.out.println("----------增强for遍历集合 -Student--------------");
		// 利用增强for遍历集合
		for (Student s : arrayStudent) {
			System.out.println(s.getName() + "++++++++" + s.getAge());

		}
	}

	// 元素替换
	public static void listSet() {
		List<String> list = Arrays.asList("hello", "world", "java");
		list.set(1, "javaee");// 替换

		for (String s : list) {
			System.out.println(s);

		}
	}

	// Vector集合
	/*
	 * Vector的特有功能：
	 *  1：添加功能 public void addElement(Object obj) -- add()
	 *  2：获取功能
	 * public Object elementAt(int index) -- get() 
	 * public Enumeration
	 * elements()-- Iterator iterator()
	 *  boolean hasMoreElements() hasNext()
	 * Object nextElement() next()
	 * 
	 * JDK升级的原因： A:安全 B:效率 C:简化书写
	 */
	public static void vectorList() {
		// 创建 vector
		Vector<String> v = new Vector<String>();
		// 增加元素
		v.addElement("hello");
		v.addElement("world");
		v.addElement("java");
		// 遍历一
		for (int x = 0; x < v.size(); x++) {
			String s = (String) v.elementAt(x);
			System.out.println(s);

		}
		// 遍历二
		System.out.println("------------------------------");
		Enumeration<String> en = v.elements();// 返回的是实现类的对象
		while (en.hasMoreElements()) {
			String s = (String) en.nextElement();
			System.out.println(s);

		}

	}

	/*
	 * Collection 
	 * |--List 有序(存储顺序和取出顺序一致),可重复 
	 * |--Set 无序(存储顺序和取出顺序不一致),唯一
	 * 
	 * HashSet：它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。
	 * 注意：虽然Set集合的元素无序，但是，作为集合来说，它肯定有它自己的存储顺序，
	 * 而你的顺序恰好和它的存储顺序一致，这代表不了有序，你可以多存储一些数据，就能看到效果。
	 */
	public static void SetList() {
		// 创建Set集合
		Set<String> set = new HashSet<String>();
		// 创建并添加元素
		set.add("hello");
		set.add("world");
		set.add("java");
		// 增强for遍历
		for (String s : set) {
			System.out.println(s);

		}
	}

	/*
	 * HashSet:存储字符串并遍历 问题：为什么存储字符串的时候，字符串内容相同的只存储了一个呢?
	 * 通过查看add方法的源码，我们知道这个方法底层依赖 两个方法：hashCode()和equals()。
	 *  步骤： 首先比较哈希值
	 * 如果相同，继续走，比较地址值或者走equals() 
	 * 如果不同,就直接添加到集合中
	 *  按照方法的步骤来说： 先看hashCode()值是否相同
	 * 相同:继续走equals()方法 返回true： 说明元素重复，就不添加 返回false：说明元素不重复，就添加到集合
	 * 不同：就直接把元素添加到集合 如果类没有重写这两个方法，默认使用的Object()。一般来说不同相同。
	 * 而String类重写了hashCode()和equals()方法，所以，它就可以把内容相同的字符串去掉。只留下一个。
	 */
	public static void hashSet() {
		// 创建hashset 集合
		HashSet<String> hs = new HashSet<String>();
		// 创建元素
		hs.add("hello");
		hs.add("world");
		hs.add("java");
		// 遍历元素
		for (String s : hs) {
			System.out.println(s);
		}

		System.out.println("---------------------------------");
		// 创建hashset 集合
		HashSet<Student> hs1 = new HashSet<Student>();
		// 创建学生对象
		Student s1 = new Student("xiaowang", 22);
		Student s2 = new Student("xiaowang1", 24);
		Student s3 = new Student("xiaowang2", 25);
		Student s4 = new Student("xiaowang3", 26);
		// 添加元素
		hs1.add(s1);
		hs1.add(s2);
		hs1.add(s3);
		hs1.add(s4);
		// 遍历集合
		for (Student s : hs1) {
			System.out.println(s.getName() + ":" + s.getAge());
		}
	}

	/*
	 * LinkedHashSet:底层数据结构由哈希表和链表组成。 哈希表保证元素的唯一性。 链表保证元素有素。(存储和取出是一致)
	 */
	public static void linkedHashSet() {
		// 创建集合对象
		LinkedHashSet<String> lhs = new LinkedHashSet<String>();
		// 创建并添加元素
		lhs.add("hello");
		lhs.add("rrrr");
		lhs.add("world");
		lhs.add("java");
		// 遍历
		for (String hs : lhs) {
			System.out.println(hs);
		}
	}

	/*
	 * TreeSet：能够对元素按照某种规则进行排序。 排序有两种方式 A:自然排序 B:比较器排序
	 * 
	 * TreeSet集合的特点：排序和唯一
	 * 
	 * 通过观察TreeSet的add()方法，我们知道最终要看TreeMap的put()方法。
	 * TreeSet存储自定义对象并保证排序和唯一。
	 * 
	 * A:你没有告诉我们怎么排序
	 * 		自然排序，按照年龄从小到大排序
	 * B:元素什么情况算唯一你也没告诉我
	 * 		成员变量值都相同即为同一个元素
	 */
	public static void treeSet() {
		// 创建集合对象
		// 自然顺序进行排序
		TreeSet<Integer> ts = new TreeSet<Integer>();
		// 创建元素并添加
		ts.add(20);
		ts.add(18);
		ts.add(30);
		ts.add(40);
		// 遍历
		for (Integer i : ts) {
			System.out.println(i);

		}
		
		// 创建集合对象
		TreeSet<Student> ts2 = new TreeSet<Student>();

		// 创建元素
		Student s1 = new Student("linqingxia", 27);///
		Student s2 = new Student("zhangguorong", 29);
		Student s3 = new Student("wanglihong", 23);
		Student s4 = new Student("linqingxia", 27);///
		Student s5 = new Student("liushishi", 22);
		Student s6 = new Student("wuqilong", 40);
		Student s7 = new Student("fengqingy", 22);

		// 添加元素
		ts2.add(s1);
		ts2.add(s2);
		ts2.add(s3);
		ts2.add(s4);
		ts2.add(s5);
		ts2.add(s6);
		ts2.add(s7);

		// 遍历
		for (Student s : ts2) {
			System.out.println(s.getName() + "---" + s.getAge());
		}
	}
	
	
	// end class
}

 student

package listdamo;

public class Student implements Comparable<Student>{
    
	private String name;
	private int age;
	@Override
	public String toString() {
		return "Student [name=" + name + ", 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;
	}
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name,int age){
		super();
		this.name=name;
		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;
	}
	@SuppressWarnings("unused")
	@Override
	public int compareTo(Student o) {
		// TODO Auto-generated method stub
       if(false){
		// 这里返回什么，其实应该根据我的排序规则来做
		// 按照年龄排序,主要条件
		int num =this.age-o.age;
		// 次要条件
		// 年龄相同的时候，还得去看姓名是否也相同
		// 如果年龄和姓名都相同，才是同一个元素
		int num2=num==0?this.name.compareTo(o.name):num;
		return num2;
       }else{
    	// 主要条件 姓名的长度
   		int num = this.name.length() -o.name.length();
   		// 姓名的长度相同，不代表姓名的内容相同
   		int num2 = num == 0 ? this.name.compareTo(o.name) : num;
   		// 姓名的长度和内容相同，不代表年龄相同，所以还得继续判断年龄
   		int num3 = num2 == 0 ? this.age - o.age : num2;
   		return num3;
       }
	}

}

 map集合

package listdamo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.function.Function;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;

public class mapdemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// hashMapAndMap();
	    // hashMap();
		// linkedHashMap();
		// treeMap();
		//hashTableDemo();
		//ArrayListIncludeHashMap();
		//hashMapIncludeHashMap();
		HashMapIncludeArrayList();
		
	}

	/*
	 * 作为学生来说，是根据学号来区分不同的学生的，那么假设我现在已经知道了学生的学号，我要根据学号去获取学生姓名，请问怎么做呢?
	 * 如果采用前面讲解过的集合，我们只能把学号和学生姓名作为一个对象的成员，然后存储整个对象，将来遍历的时候，判断，获取对应的名称。
	 * 但是呢，如果我都能把学生姓名拿出来了，我还需要根据编号去找吗?
	 * 针对我们目前的这种需求：仅仅知道学号，就想知道学生姓名的情况，Java就提供了一种新的集合 Map。
	 * 通过查看API，我们知道Map集合的一个最大的特点，就是它可以存储键值对的元素。这个时候存储我们上面的需求，就可以这样做 学号1 姓名1 学号2
	 * 姓名2 学号3 姓名3 学号2(不行)姓名4 学号4 姓名4 Map集合的特点：
	 * 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
	 * 
	 * Map集合和Collection集合的区别? Map集合存储元素是成对出现的，Map集合的键是唯一的，值是可重复的。可以把这个理解为：夫妻对
	 * Collection集合存储元素是单独出现的，Collection的儿子Set是唯一的，List是可重复的。可以把这个理解为：光棍(11.11)
	 * 
	 * 注意： Map集合的数据结构值针对键有效，跟值无关 HashMap，TreeMap等会讲。 Collection集合的数据结构是针对元素有效
	 * 
	 * Map集合的功能概述： 1:添加功能 V put(K key,V value):添加元素。这个其实还有另一个功能?先不告诉你，等会讲
	 * 如果键是第一次存储，就直接存储元素，返回null 如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值 2:删除功能 void
	 * clear():移除所有的键值对元素 V remove(Object key)：根据键删除键值对元素，并把值返回 3:判断功能 boolean
	 * containsKey(Object key)：判断集合是否包含指定的键 boolean containsValue(Object
	 * value):判断集合是否包含指定的值 boolean isEmpty()：判断集合是否为空 4:获取功能 Set<Map.Entry<K,V>>
	 * entrySet():??? V get(Object key):根据键获取值 Set<K> keySet():获取集合中所有键的集合
	 * Collection<V> values():获取集合中所有值的集合 5：长度功能 int size()：返回集合中的键值对的对数
	 */
	public static void hashMapAndMap() {
		Map<String, String> hashmap = new HashMap<String, String>();

		hashmap.put("id001", "xiaoming1");
		hashmap.put("id002", "xiaoming2");
		hashmap.put("id003", "xiaoming3");
		hashmap.put("id004", "xiaoming4");
		hashmap.put("id005", "xiaoming5");
		hashmap.put("id006", "xiaoming6");
		// void clear():移除所有的键值对元素
		// hashmap.clear();

		System.out.println("------------------------------------------");
		// V remove(Object key)：根据键删除键值对元素，并把值返回
		System.out.println("remove:" + hashmap.remove("id002"));
		System.out.println("remove:" + hashmap.remove("id007"));// 返回null

		System.out.println("------------------------------------------");
		// boolean containsKey(Object key)：判断集合是否包含指定的键
		System.out.println("containsKey:" + hashmap.containsKey("id003"));
		System.out.println("containsKey:" + hashmap.containsKey("id0072"));// 返回null

		System.out.println("------------------------------------------");
		// boolean isEmpty()：判断集合是否为空
		System.out.println("isEmpty:" + hashmap.isEmpty());

		System.out.println("------------------------------------------");
		// int size()：返回集合中的键值对的对数
		System.out.println("size:" + hashmap.size());
		System.out.println("hashmap" + hashmap);

		System.out.println("------------------------------------------");
		// V get(Object key):根据键获取值
		System.out.println("get:" + hashmap.get("id005"));
		System.out.println("get:" + hashmap.get("id009"));// 返回null
		System.out.println("------------------------------------------");

		// Set<K> keySet():获取集合中所有键的集合
		Set<String> set = hashmap.keySet();
		for (String key : set) {
			System.out.println(key);
		}
		System.out.println("------------------------------------------");

		// Collection<V> values():获取集合中所有值的集合
		Collection<String> con = hashmap.values();
		for (String values : con) {
			System.out.println(values);

		}
		System.out.println("------------------------------------------");

		// 遍历
		/*
		 * Map集合的遍历。 Map -- 夫妻对 思路： A:把所有的丈夫给集中起来。 B:遍历丈夫的集合，获取得到每一个丈夫。
		 * C:让丈夫去找自己的妻子。
		 * 
		 * 转换： A:获取所有的键 B:遍历键的集合，获取得到每一个键 C:根据键去找值 看看我们开始的一个方法：
		 * Set<Map.Entry<K,V>> entrySet()：返回的是键值对对象的集合
		 */
		// 获取所有的键
		Set<String> set2 = hashmap.keySet();
		// 遍历键的集合，获取得到每一个键
		for (String key : set2) {
			// 根据键去找值
			String value = hashmap.get(key);
			System.out.println(key + ":=======:" + value);
		}
		System.out.println("------------------------------------------");
		// 获取所有键值对对象的集合
		Set<Map.Entry<String, String>> set3 = hashmap.entrySet();
		// 遍历键值对对象的集合，得到每一个键值对对象
		for (Map.Entry<String, String> me : set3) {
			// 根据键值对对象获取键和值
			String key = me.getKey();
			String value = me.getValue();
			System.out.println(key + ":++++++++++:" + value);
		}
		System.out.println("------------------------------------------");
	}

	/*
	 * HashMap:是基于哈希表的Map接口实现。 哈希表的作用是用来保证键的唯一性的。
	 * 
	 * HashMap<String,String> 键：String 值：String
	 */
	public static void hashMap() {
		// 创建集合对象
		HashMap<String, String> hm = new HashMap<String, String>();
		// 创建元素并添加元素
		hm.put("id001", "xiaoming01");
		hm.put("id002", "xiaoming02");
		hm.put("id003", "xiaoming03");
		hm.put("id004", "xiaoming04");
		hm.put("id005", "xiaoming05");
		hm.put("id006", "xiaoming06");
		// 遍历
		Set<String> set = hm.keySet();
		for (String key : set) {
			String value = hm.get(key);
			System.out.println(key + ":========:" + value);
		}

		System.out.println("------------------------------------------");
		/*
		 * HashMap<Student,String> 键：Student 要求：如果两个对象的成员变量值都相同，则为同一个对象。
		 * 值：String
		 */
		// 创建集合对象
		HashMap<Student, String> hm2 = new HashMap<Student, String>();
		// 创建学生对象
		Student s1 = new Student("xiaoming1", 23);
		Student s2 = new Student("xiaoming2", 24);
		Student s3 = new Student("xiaoming3", 25);
		Student s4 = new Student("xiaoming4", 26);
		Student s5 = new Student("xiaoming5", 27);
		// 添加元素
		hm2.put(s1, "88888");
		hm2.put(s2, "99999");
		hm2.put(s3, "77777");
		hm2.put(s4, "66666");
		hm2.put(s5, "55555");
		// 遍历
		Set<Student> set2 = hm2.keySet();
		for (Student key : set2) {
			String value = hm2.get(key);
			System.out.println(key.getName() + ":=====:" + key.getAge()
					+ ":::::" + value);

		}

		System.out.println("------------------------------------------");
	}
	/*
	 * LinkedHashMap:是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。
	 * 由哈希表保证键的唯一性
	 * 由链表保证键盘的有序(存储和取出的顺序一致)
	 */
	public static void linkedHashMap() {
		// 创建集合对象
		LinkedHashMap<String,String> lhm = new LinkedHashMap<String, String>();
		// 创建并添加元素
		lhm.put("id001", "hello");
		lhm.put("id002", "world");
		lhm.put("id003", "java");
		lhm.put("id004", "world2");

		// 遍历
		Set<String> set =lhm.keySet();
		for(String key:set){
			String value=lhm.get(key);
			System.out.println(key+"======"+value);
		}
	
	}
	/*
	 * TreeMap:是基于红黑树的Map接口的实现。
	 * 
	 * HashMap<String,String>
	 * 键：String
	 * 值：String
	 */
	public static void treeMap() {
		// 创建集合对象
		TreeMap<String, String> tm = new TreeMap<String, String>();
		// 创建并添加元素
		tm.put("id001", "hello");
		tm.put("id002", "world");
		tm.put("id003", "java");
		tm.put("id004", "world2");

		// 遍历
		Set<String> set = tm.keySet();
		for (String key : set) {
			String value = tm.get(key);
			System.out.println(key + "======" + value);
		}
		System.out.println("------------------------------------------");	
		
		
		// 创建集合对象
		TreeMap<Student, String> tm2 = new TreeMap<Student, String>(
				new Comparator<Student>(){

					@Override
					public int compare(Student o1, Student o2) {
						// TODO Auto-generated method stub
						// 主要条件
						int num=o1.getAge()-o2.getAge();
						// 次要条件
						int num2=num==0?o1.getName().compareTo(o2.getName()):num;
						return num2;
					}

				
					});
		// 创建学生对象
		Student s1 = new Student("xiaoming1", 23);
		Student s2 = new Student("xiaoming2", 24);
		Student s3 = new Student("xiaoming3", 25);
		Student s4 = new Student("xiaoming4", 26);
		Student s5 = new Student("xiaoming5", 27);
		// 添加元素
		tm2.put(s1, "88888");
		tm2.put(s2, "99999");
		tm2.put(s3, "77777");
		tm2.put(s4, "66666");
		tm2.put(s5, "55555");
		// 遍历
		Set<Student> set2=tm2.keySet();
		for(Student key:set2){
			String value =tm2.get(key);
			System.out.println(key.getName()+"----------"+key.getAge()+"::::"+value);	
		}
		System.out.println("------------------------------------------");	
	}	
	/*
	 * 1:Hashtable和HashMap的区别?
	 * Hashtable:线程安全，效率低。不允许null键和null值
	 * HashMap:线程不安全，效率高。允许null键和null值
	 * 
	 * 2:List,Set,Map等接口是否都继承子Map接口?
	 * List，Set不是继承自Map接口，它们继承自Collection接口
	 * Map接口本身就是一个顶层接口
	 */
	public static void hashTableDemo(){
		// HashMap<String, String> hm = new HashMap<String, String>();
				Hashtable<String, String> hm = new Hashtable<String, String>();

				hm.put("id001", "hello");
				// hm.put(null, "world"); //NullPointerException
				// hm.put("java", null); // NullPointerException

				System.out.println(hm);
	}
	/*
	* ArrayList集合嵌套HashMap集合并遍历。
	* 需求：
	* 假设ArrayList集合的元素是HashMap。有3个。
	* 每一个HashMap集合的键和值都是字符串。
	* 元素我已经完成，请遍历。
	*/
	public static void ArrayListIncludeHashMap(){
	//创建集合对象
		ArrayList<HashMap<String, String>> array = new ArrayList<HashMap<String, String>>();
		// 创建元素1
		HashMap<String, String> hm1 = new HashMap<String, String>();
		hm1.put("id001", "xiaozhang");
		hm1.put("id002", "xiaowan");
		hm1.put("id003", "xiaozhao");
		// 把元素添加到array里面
		array.add(hm1);
		// 创建元素2
		HashMap<String, String> hm2 = new HashMap<String, String>();
		hm2.put("id004", "xiaozhang2");
		hm2.put("id005", "xiaowan2");
		hm2.put("id006", "xiaozhao2");
		// 把元素添加到array里面
		array.add(hm2);
		// 创建元素3
		HashMap<String, String> hm3 = new HashMap<String, String>();
		hm3.put("id007", "xiaozhang3");
		hm3.put("id008", "xiaowan3");
		hm3.put("id009", "xiaozhao3");
		// 把元素添加到array里面
		array.add(hm3);
		// 遍历
		for(HashMap<String,String>hm:array){
			Set<String> set=hm.keySet();
			for(String key:set){
				String value=hm.get(key);
				System.out.println(key+":====:"+value);
				
			}
		}

	}
	/*
	 * HashMap嵌套HashMap
	 * 
	 * 
	 * 		
	 * 
	 * 先存储元素，然后遍历元素
	 */
	public static void hashMapIncludeHashMap(){
		//创建主集合
	     HashMap<String,HashMap<String,Integer>>  hashMapBase=	new HashMap<String,HashMap<String,Integer>>();
	     HashMap<String,Integer> inhm1 =new HashMap<String,Integer>();
	 	// 添加元素
	     inhm1.put("xiaoming", 21);
	     inhm1.put("xiaozhang", 20);
	 	// 把基础班添加到大集合
	     hashMapBase.put("11111", inhm1);
	     
	     HashMap<String,Integer> inhm2 =new HashMap<String,Integer>(); 
	 	// 添加元素
	     inhm2.put("xiaozhao", 23);
	     inhm2.put("xiaoxu", 24);
	 	// 把基础班添加到大集合
	     hashMapBase.put("22222", inhm2);
	     
	     //遍历集合
	     Set<String> hashMapBaseSet= hashMapBase.keySet();
	     for(String hashMapBaseSetKey:hashMapBaseSet){
	    	 System.out.println(hashMapBaseSetKey);
	    	 HashMap<String,Integer> hashMapBaseValue =hashMapBase.get(hashMapBaseSetKey);
	    	 Set<String> hashMapBaseValueSet =hashMapBaseValue.keySet();
	    	 for(String hashMapBaseValuekey : hashMapBaseValueSet){
	    		 Integer hashMapBaseValueValue=hashMapBaseValue.get(hashMapBaseValuekey);
	    		 System.out.println("\t"+hashMapBaseValuekey+":====:"+hashMapBaseValueValue);
	    		 
	    	 }
	    	 
	     }
	
	}
	/*
	 *需求：
	 *假设HashMap集合的元素是ArrayList。有3个。
	 *每一个ArrayList集合的值是字符串。
	 *元素我已经完成，请遍历。
	 *结果：
	 *		 三国演义
	 *		 	吕布
	 *		 	周瑜
	 *		 笑傲江湖
	 *		 	令狐冲
	 *		 	林平之
	 *		 神雕侠侣
	 *		 	郭靖
	 *		 	杨过  
	 */
	public static void HashMapIncludeArrayList(){
		// 创建集合对象
		HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>>();

		// 创建元素集合1
		ArrayList<String> array1 = new ArrayList<String>();
		array1.add("吕布");
		array1.add("周瑜");
		hm.put("三国演义", array1);

		// 创建元素集合2
		ArrayList<String> array2 = new ArrayList<String>();
		array2.add("令狐冲");
		array2.add("林平之");
		hm.put("笑傲江湖", array2);

		// 创建元素集合3
		ArrayList<String> array3 = new ArrayList<String>();
		array3.add("郭靖");
		array3.add("杨过");
		hm.put("神雕侠侣", array3);
		
		//遍历集合
		Set<String> set = hm.keySet();
		for(String key : set){
			System.out.println(key);
			ArrayList<String> value = hm.get(key);
			for(String s : value){
				System.out.println("\t"+s);
			}
		}	
	}
	// end class
}