java 集合框架（二）

呜呜呜呜。。。。。，最近一直往前学，都没有停下来总结，以后学完会即时总结的。
紧接上文： java集合框架（一）.

五.JDK新特性

1.增强for：
格式：for(元素数据类型　变量：数组或者Collection集合) { }
注意：增强for的目标不能为null

public static void main(String[] args)
{
   	//增强for
   	for(int x:arr)
   	{
   		System.out.println(x);
   	}
   	
   	//定义一个字符串数组
   	String[] strArray = {"dd","kk","ll"};
   	for(String s:strArray)
   	{
   		System.out.println(s);
   	}
   	
   	//定义一个集合
   	ArrayList<String> array = new ArrayList<String>();
   	array.add("hello");
   	array.add("he");
   	array.add("java");
   	
   	for(String s :array)
   	{
   		System.out.println(s);
   	}
}

2.静态导入
格式：import static 包名.类名.方法名
静态导入的作用是为了简化书写，方法必须是静态的。

? 静态导入方式１：导入到类

import java.lang.Math
public class StaticImportDemo
{
	public static void main(String[] args)
	{
		System.out.println(Math.abs(-10));
		System.out.println(Math.pow(2,3));
		System.out.println(Math.max(23, 34));
	}
}

这种方法的缺点在于每次调用方法时，都要加上类名。

? 静态导入方式2：导入到方法

import static java.lang.Math.max;
import static java.lang.Math.pow;
import static java.lang.Math.abs;
public class StaticImportDemo
{
	public static void main(String[] args)
	{
		System.out.println(abs(-10));
		System.out.println(pow(2,3));
		System.out.println(max(23, 34));	
	}
}

这种方式简化了书写，直接使用方法名调用即可。
可是如果类中出现了同名的静态方法，为了明确调用谁，应该在调用时加上包名类名和方法名前缀，由此可见静态导入意义不大。

import static java.lang.Math.max;
import static java.lang.Math.pow;
import static java.lang.Math.abs;
public class StaticImportDemo
{
	public static void main(String[] args)
	{
		System.out.println(java.lang.Math.abs(-10));
		//System.out.println(abs(-10));
		System.out.println(pow(2,3));
		System.out.println(max(23, 34));	
	}	
	public static void abs (String s)
	{
        System.out.println(s);
	}
}

3.可变参数
格式：修饰符　返回值类型　方法名（数据类型...变量名）{ }
这里的变量是一个数组，可变参数位于形参的最后位置。

public static void main(String[] args)
	{
	    //求两个数据的和
		int a = 10;
		int b = 20;
	    int result = sum(a,b);
	    System.out.println(result);
		//求三个数据的和
		int c = 30;
		result = sum(a,b,c);
		System.out.println(result);
		//求四个数据的和
		int d = 10;
		result = sum(a,b,c,d);
		System.out.println(result);
		//需求：我要写一个求和的功能，但是不清处几个数据求和
		result = sum(a,b,c,d,40);
		System.out.println(result);	
	}
	public static int sum(int b,int ...a)
	{
		int s = 0;
		for(int x:a)
		{
			s +=x;		
		}
		return s;
	}	

六.Set接口

1.Set接口是Collection接口的子接口，它与Collection接口基本相同，没有提供任何额外的方法。
2.Set集合的特点：
无序（存储与取出的顺序不一致），唯一（不能有重复的元素）。
3.Set接口的方法：

七.Set接口的具体实现类

HashSet类：

java.lang.Object
  |_ java.util.AbstractCollection
    |_ java.util.AbstractSet
      |_ java.util.HashSet

1.HashSet的底层实现原理：呜呜呜…学的太肤浅，只能先转载，后期定补上自己的见解。转载－HashSet源码解析.
2.HashSet是按照Hash算法来存储集合中的元素，因此具有很好的存取和查询功能。
3.HashSet如何保证元素唯一性：

• 我们使用Set集合都是需要去掉重复元素的, 如果在存储的时候逐个equals()比较, 效率较低,哈希算法提高了去重复的效率, 降低了使用equals()方法的次数.
• 当HashSet调用add()方法存储对象的时候, 先调用对象的hashCode()方法得到一个哈希值, 然后在集合中查找是否有哈希值相同的对象
   ? 如果没有哈希值相同的对象就直接存入集合
   ? 如果有哈希值相同的对象, 就和哈希值相同的对象逐个进行equals()比较,    比较结果为false就存入, true则不存
  所以添加进HashSet集合的类必须重写HashCode()和equals()方法。

4.因为HashSet中元素是无序的，所以无法通过索引来获取元素，也就没有get()方法，因此只能通过迭代的方式获取元素。
5.HashSet类的方法：

public static void main(String[] args)
	{
		//创建集合对象
		HashSet<String> set = new HashSet<String>();
		//创建并添加元素
		set.add("hello");
		set.add("world");
		set.add("java");
		set.add("world");
		//遍历
		for(String s :set)
		{
			System.out.println(s);
		}
	}

LinkedHashSet类：

1.LInkedHashSet是HashSet的子类
2.特点：
底层数据结构由哈希表和链表组成 ，哈希表保证唯一性，链表保证存储有序。
LinkedHashSet集合是根据元素的hashCode值来决定元素的存储位置，但它同时使用链表维护元素的次序，这样使得元素看起来是以插入的顺序保存的。也就是说，当遍历LinkedHashSet集合里的元素时，LinkedHashSet将会按元素的添加顺序来访问集合里的元素。

public static void main(String[] args)
	{
		//创建集合对象
		LinkedHashSet<String> hs = new LinkedHashSet<String>();	
		//创建并添加元素
		hs.add("hello");
		hs.add("hh");
		hs.add("java");
		hs.add("hh");
		hs.add("java");	
		//遍历
		for(String s:hs)
		{
			System.out.println(s);
		}
	}
结果：
hello
hh
java

TreeSet类：

1.具有Set集合的特点，即无序（存储顺序与取出顺序不同），唯一。
2.底层结构为红黑树（一个自平衡的二叉树）
3.TreeSet可以确保集合元素处于排序状态，有两种排序方式：

• 自然排序：
  自定义的类实现了Comparable接口，然后创建TreeSet对象，通过无参构造形式创建对象。

TreeSet会调用集合元素的compareTo(Object obj)方法来比较元素之间的大小关系，然后将集合元素按升序排列，这种方式就是自然排序。
Java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现该接口的类必须实现该方法，实现了该接口的类的对象就可以比较大小。当一个对象调用该方法与另一个对象进行比较时，例如obj1.compareTo(obj2)，如果该方法返回0，则表明这两个对象相等；如果该方法返回一个正整数，则表明obj1大于obj2；如果该方法返回一个负整数，则表明obj1小于obj2。

?　对于一些常用类已经实现了Comparable接口，并提供了比较大小的标准。

• BigDecimal、BigInteger以及所有的数值型对应的包装类：按它们对应的数值大小进行比较。
• Character：按字符的UNICODE值进行比较。
• Boolean：true对应的包装类实例大于false对应的包装类实例。
• String：按字符串中字符的UNICODE值进行比较。
• Date、Time：后面的时间、日期比前面的时间、日期大。

	public static void main(String[] args)
	{
		//自然顺序进行排序（无参构造）
		TreeSet<Integer> ts = new TreeSet<Integer>();	
		//创建元素并添加
		ts.add(20);
		ts.add(18);
		ts.add(23);
		ts.add(22);
		ts.add(17);
		ts.add(24);
		ts.add(19);
		ts.add(18);
		ts.add(24);		
		//遍历
		for(Integer i :ts)
		{
			System.out.println(i);
		}
	}

? 如果试图把一个自定义对象添加到TreeSet时，则该对象的类必须实现Comparable接口，否则程序将会抛出异常。

例：使用TreeSet方法存储自定义对象并排序，要求：按照年龄排序，如果成员变量值都相同，即为同一个元素。

public static void main(String[] args)
	{
		//创建集合对象
		TreeSet<Student> set = new TreeSet<Student>();
		//创建元素
		Student s1 = new Student("linqingxia",27);
		Student s2 = new Student("zhangguorong",27);
		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("fengqingyang",40);
		//添加元素
		set.add(s1);
		set.add(s2);
		set.add(s3);
		set.add(s4);
		set.add(s5);
		set.add(s6);
		set.add(s7);
		//遍历
		for(Student s:set)
		{
			System.out.println(s.getAge()+"---"+s.getName());
		}	
}	

public class Student implements Comparable<Student>
{
	private String name;
	private int age;

	public Student()
	{
		super();	
	}
	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 String toString()
	{
		return "Student [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int compareTo(Student s)
	{
		//返回何值应该实际情况来定
		//按照年龄排序,主要条件
		int num = this.age-s.age;
		//次要条件
		//年龄相同的时候，还要看姓名是否相同
		//如果年龄和姓名都相同，才是同一个元素
		int num2 = num == 0 ?this.name.compareTo(s.name):num;
		return num2;
	}
}

• 比较器排序：
  public TreeSet(Comparable comparator)

如果需要实现定制排序，则可以通过Comparator接口的帮助。该接口里包含一个int compare(T o1, T o2)方法，该方法用于比较o1和o2的大小：如果该方法返回正整数，则表明o1大于o2；如果该方法返回0，则表明o1等于o2；如果该方法返回负整数，则表明o1小于o2。
如果需要实现定制排序，则需要在创建TreeSet集合对象时，提供一个Comparator对象与该TreeSet集合关联，由该Comparator对象负责集合元素的排序逻辑。

两种方式：
方式1:自定义一个类该类实现Comparator接口，重写Comparator接口中的compare()方法
方式2:直接使用内部类的方式。

? 方式１：自定义一个类实现Comparator接口，重写Comparator接口中的compare()方法

public class MyComparator implements Comparator<Student>
{
	@Override
	public int compare(Student s1, Student s2)
	{
		//姓名长度
		int num = s1.getName().length()-s2.getName().length();
		//姓名内容
		int num2 = num == 0 ? s1.getName().compareTo(s2.getName()):num;
		//年龄
		int num3 = num2 == 0 ? s2.getAge()-s2.getAge():num2;
		return num3;
	}

? 方式2:直接使用内部类的方式

TreeSet<Student> set = new TreeSet<Student>(new Comparator<Student>(){
			public int compare(Student s1, Student s2)
			{
				//姓名长度
				int num = s1.getName().length()-s2.getName().length();
				//姓名内容
				int num2 = num == 0 ? s1.getName().compareTo(s2.getName()):num;
				//年龄
				int num3 = num2 == 0 ? s2.getAge()-s2.getAge():num2;
				return num3;
			}
		}); 

4.往TreeSet添加元素时的注意事项：

• 往TreeSet添加元素的时候，如果元素的所属类是已经实现了Comparable接口的常用类，那么直接自然排序即可。
• 往TreeSet添加元素的时候，如果是一个对象，那么该对象所属的类必须要实现Comparable接口，把元素的比较规则定义在compareTo(T o)方法上。
• 往TreeSet添加元素的时候, 如果元素所属的类也没有实现Comparable接口，那么必须要在创建TreeSet的时候传入一个比较器。
• 往TreeSet添加元素的时候，如果元素所属的类已经实现了Comparable接口， 在创建TreeSet对象的时候也传入了比较器那么是以比较器的比较规则优先使用。

八.Map集合：
1.特点：

Map用于保存具有映射关系的数据，因此Map集合里保存着两组值，一组值用于保存Map里的key，另外一组值用于保存Map里的value，key和value都可以是任何引用类型的数据。Map的key不允许重复，即同一个Map对象的任何两个key通过equals方法比较总是返回false。

key和value之间存在单向一对一关系，即通过指定的key，总能找到唯一的、确定的value。从Map中取出数据时，只要给出指定的key，就可以取出对应的value。如果把Map的两组值拆开来看，Map里的所有key组成了Set集合（所有的key没有顺序，key与key之间不能重复），所有的value组成了List集合。

2.Map接口中的方法：

功能	方法	说明
删除	void clear()	删除该Map对象中的所有key-value对。
删除	Object remove(Object key)	删除指定key所对应的key-value对，返回被删除key所关联的value，如果该key不存在，则返回null。
添加	Object put(Object key, Object value)	添加一个key-value对，如果当前Map中已有一个与该key相等的key-value对，则新的key-value对会覆盖原来的key-value对。
添加	void putAll(Map m)	将指定Map中的key-value对复制到本Map中。
长度	int size()	返回集合中键值对的对数
判断	boolean containsKey(Object key)	查询Map中是否包含指定的key，如果包含则返回true。
判断	boolean containsValue(Object value)	查询Map中是否包含一个或多个value，如果包含则返回true。
判断	boolean isEmpty()	查询该Map是否为空（即不包含任何key-value对），如果为空则返回true。
获取	Set keySet()	返回该Map中所有key组成的Set集合。
获取	Object get(Object key)	返回指定key所对应的value；如果此Map中不包含该key，则返回null。
获取	Collection values()	返回该Map里所有value组成的Collection。
获取	Set<Map.Entry<K,V>> entrySet()	返回Map中包含的key-value对所组成的Set集合，每个集合元素都是Map.Entry （Entry是Map的内部类）对象。

public static void main(String[] args)
	{
		//创建集合对象
		Map<String,String> map = new HashMap<String,String>();
		
		//添加元素
		map.put("邓超", "孙俪");
		map.put("黄晓明", "杨颖");
		map.put("周杰伦", "蔡依林");
		map.put("杨幂", "刘恺威");
		
		//(2)void clear()移除所有的键值对元素
		//map.clear();
		
		//(3)V remove(Object key)根据建删除键值对元素
		//System.out.println("remove:"+map.remove("黄晓明"));
		//System.out.println("remove:"+map.remove("黄晓波"));
		
		//(4)boolean containsKey(Object key)判断集合是否包含指定的键
		//System.out.println(map.containsKey("黄晓明"));
		//System.out.println(map.containsKey("黄晓波"));
		
		//(5)boolean containsValue(Object value)判断集合是否包含指定的值
		//System.out.println(map.containsValue("杨颖"));
		
		//(6)boolean isEmpty()判断集合是否为空
		//System.out.println(map.isEmpty());
		
		//(7)int size()返回集合中键值对的对数
		System.out.println(map.size());
		//输出集合名称
		System.out.println("map"+map);	
	}

Map集合的获取功能方法测试：

public static void main(String[] args)
	{
		//创建集合对象
		Map<String,String> map = new HashMap<String,String>();
		
		//创建并添加元素
		map.put("邓超", "孙俪");
		map.put("黄晓明", "杨颖");
		map.put("周杰伦", "蔡依林");
		map.put("杨幂", "刘恺威");
		
		//(1)V get(Object key)根据建获取值
		//System.out.println(map.get("周杰伦"));
		
		//(2)Set<K> keySet()获取集合中所有键的集合
		Set<String> set = map.keySet();
		for(String key :set)
		{
			System.out.println(key);
		}
		
		//(3)Collection<V> values()获取集合中所有值的集合
		Collection<String> v = map.values();
		for(String value:v)
		{
			System.out.println(value);
		}
	}

3.关于keySet()与entrySet()的说明：

keySet()：返回值是Map中key值的set集合
entrySet()：返回Map中包含的key-value对所组成的Set集合，每个集合元素都是Map.Entry （Entry是Map的内部类）对象。

4.Map集合的遍历:
? 方式一：如果同时需要key和value，可以使用keySet()先获取key，再通过map的get(key)方法获取value.

public static void main(String[] args)
	{
		//创建集合对象
		Map<String,String> map = new HashMap<String,String>();
		//创建元素并添加集合
		map.put("杨过", "小龙女");
		map.put("郭靖", "黄蓉");
		map.put("杨康", "穆念慈");
		map.put("陈选", "梅超风");
		//遍历
		//获取所有的键
		Set<String> set = map.keySet();
		for(String key:set)
		{
			//根据建去找值
			String value  = map.get(key);
			System.out.println(key+"---"+value);
		}
	}

? 方式二：entrySet()遍历，可以同时拿到key和value。

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);
		}	
	}

九.Map集合的具体实现类

HashMap类：

1.HashMap是Map接口的具体实现类
2.HahMap的特性：
当我们要将一个自定义类作为HashMap的key时。需要重写hashCode()和equals(Object object)方法，并且保证这两个方法的返回值一致。当两个类的hashCode()返回一致时，应该保证equasl()方法也返回true。

示例1： HashMap<Integer,String>

public static void main(String[] args)
	{
		//创建集合对象
		HashMap<Integer,String> hm = new HashMap<Integer,String>();
		hm.put(27, "林青霞");
		hm.put(28, "风清扬");
		hm.put(29, "刘意");
		hm.put(23, "林青霞");
		//遍历
		Set<Integer> set = hm.keySet();
		for(Integer key:set)
		{
			String value = hm.get(key);
			System.out.println(key+"---"+value);
		}	
	}

示例2：HashMap<String,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;
	}
}

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

示例3：HashMap<Student,String>
对于键：如果两个对象的成员变量值都相同，则为同一个对象。
注意，键的数据结构为哈希结构，哈希结构的底层为hasnCode()和equals()方法

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;
	}
}

public class HashMapDemo4
{
	public static void main(String[] args)
	{
		//创建集合对象
		HashMap<Student,String> hm = new HashMap<Student,String>();
		
		//创建学生对象
		Student s1 = new Student("貂蝉",27);
		Student s2 = new Student("王昭君",30);
		Student s3 = new Student("杨玉环",233);
		Student s4 = new Student("西施",36);
		Student s5 = new Student("貂蝉",27);
		
		//添加元素
		hm.put(s1, "8888");
		hm.put(s2, "6666");
		hm.put(s3, "7777");
		hm.put(s4, "5555");
		hm.put(s5, "9999");
		
		//遍历
		Set<Student> set = hm.keySet();
		for(Student key:set)
		{
			String value = hm.get(key);
			System.out.println(key.getAge()+"---"+key.getName()+"---"+value);
		}
	}
}

LinkedHashMap类：

1.特点：

LinkedHashMAp：是Map结构的哈希表和链接列表实现，具有可预知的迭代顺序
由哈希表保证键的唯一性， 由链表保证键的有序性（存储和取出的顺序一致）
LInkedHashMap是HashMAp的子类，LinkedHashMap使用双向链表来维护key-value对的次序（其实只需要考虑key的次序），该链表负责维护Map的迭代顺序，迭代顺序与key-value对的插入顺序保持一致。

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", "andriod");
		
		//遍历
		Set<String> set = hm.keySet();
		for(String key:set)
		{
			String value = hm.get(key);
			System.out.println(key+"---"+value);
		}
	}
结果：2345---hello
1234---javaee
3456---andriod

TreeMap类：

１.特点：

TreeMap就是一个红黑树数据结构，每个key-value对即作为红黑树的一个节点。TreeMap存储key-value对（节点）时，需要根据key对节点进行排序。TreeMap可以保证所有的key-value对处于有序状态。

2.TreeMap的两种排序方式：

• 自然排序：TreeMap的所有key必须实现Comparable接口，而且所有的key应该是同一个类的对象，否则将会抛出ClassCastException异常。
• 定制排序：创建TreeMap时，传入一个Comparator对象，该对象负责对TreeMap中的所有key进行排序。采用定制排序时不要求Map的key实现Comparable接口。
  学习TreeMap时可以参考TreeSet。

3.如果使用自定义类作为TreeMap的key，且想让TreeMap良好地工作，则重写该类的equals()方法和compareTo()方法时应保持一致的返回结果：两个key通过equals()方法比较返回true时，它们通过compareTo()方法比较应该返回0。

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 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;
	}
}

public class TreeMapDemo2
{
	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 num1 = num == 0 ? s1.getName().compareTo(s2.getName()):num;			
				return num1;
			}
		});
		//创建对象
		Student s1 = new Student("周星驰",51);
		Student s2 = new Student("刘德华",55);
		Student s3 = new Student("梁朝伟",55);
		Student s4 = new Student("刘嘉玲",50);
		Student s5 = new Student("刘嘉玲",50);
		//添加元素
		tm.put(s1, "12");
		tm.put(s2, "13");
		tm.put(s3, "14");
		tm.put(s4, "15");
		tm.put(s5, "16");	
		//遍历
		Set<Student> set = tm.keySet();
		for(Student key:set)
		{
			String value = tm.get(key);
			System.out.println(key.getAge()+"--"+key.getName()+"--"+value);
		}	
	}
}