import java.util.*;
class Student implements Comparable<Student>
{
  private String name;
  private int age;
  Student(String name,int age )
   {
     this.name=name;
  this.age=age;
   }
   public String toString()
    {
     return name+"+++"+age;
    }
   public int compareTo(Student s) //明明定义了比较方法，可还是不能排序，为什么？
    {
      int num=new Integer(this.age).compareTo(new Integer(s.age));
   if(num==0)
     return this.name.compareTo(s.name);
      return num;
    }   
   public boolean equals(Object obj)
   {
     if(!(obj instanceof Student))
    throw new ClassCastException("类型不匹配");
     Student s=(Student)obj;
  return name.equals(s.name)&&this.age==s.age;
   }
  }
class MapTest
{
public static void main(String[] args)
{
  HashMap<Student,String>hm=new HashMap<Student,String>();
  hm.put(new Student("lisi05",20),"beijing1");
  hm.put(new Student("lisi05",20),"beijing1");
  hm.put(new Student("lisi02",21),"beijing2");
  hm.put(new Student("lisi03",22),"beijing3");
  hm.put(new Student("lisi04",23),"beijing4");
  hm.put(new Student("lisi04","23"),"beijing4");//为什么抛出的异常不是我自己定义的："类型不匹配"

  Set<Student> keySet=hm.keySet();
  Iterator <Student> it=keySet.iterator();
  while (it.hasNext())
  {
     Student stu=it.next();
     String addr=hm.get(stu);
     System.out.println(stu+"..."+addr);
  }  
}
}
//原来只是想着练习keySet（）；没想到出现排序问题，解决不了了，求解

collection
  List：元素是有序的，元素可以重复，因为该集合体系有索引。
      ArrayList：底层的数据结构使用的是数组结构。 特点：查询速度很快，但是增删稍慢。线程不同步，
      LinkedList：底层使用的是链表数据结构。特点：增删的速度很快，查询稍慢。
      Vector：底层是数组数据结构。线程同步。被ArrayList替代了。枚举就是Vector特有的取出方式。
              发现枚举和迭代器很像。其实枚举和迭代是一样的，因为枚举的名称以及方法的名称都
              过长，所以被迭代器取代了。枚举郁郁而终了。

  Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。
      HashSet：底层数据结构是哈希表。线程不同步的。
             HashSet是如何保证元素唯一性的呢？
                是通过元素的两个方法，hashSetCode和equals来完成，
                如果元素的HashCode值相同，才会判断equals是否为true。、
                如果元素的hashCode值不同，不会调用equals。
               注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素
                   的hashcode和equals方法。
      TreeSet：可以对Set集合中的元素进行排序。
               底层数据结构是二叉树。保证元素唯一性的依据compareto方法return 0
              排序的第一种方式：让元素自身具备比较性，元素需要实现compareTo方法。
                                  这种方式也称为元素的自然顺序，或者叫做默认顺序。
               排序的第二种方式：当元素自身不具备比较性时，或者具备的比较性不是
                                 所需要的，这时就需要让集合自身具备比较性。
                                 在集合初始化时，就有了比较方式。

Map集合：该集合存储键值对，一对一对往里存，而且要保证键的唯一性。
        Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。

Map
   Hashtable：底层是哈希表数据结构，不可以存入Null键或者Null值。该集合是线程同步的。JDK1.0 效率低
   HashMap：底层是哈希表数据结构，可以存入Null键或者Null值。该集合是线程是不同步的。JDK1.2效率高
   TreeMap：底层是二叉树数据结构，线程不同步，可以用语给Map集合中的键进行排序。
            和Set很像。其实Set底层就是使用了Map集合的方法。

记住：排序时，当主要条件相同时，一定判断一下次要条件。                 


当元素自身不具备比较性，或者具备的比较性不是所需要的。
这时需要让容器自身具备比较性，定义了比较器，将比较器对象
作为参数传递给TreeSet集合的构造函数。



当两种排序都存在时，以比较器为主。
定义一个类，实现Comparator接口，覆盖compare方法。

字符串本身具备比较性。但是他的比较方式不是所需要的。
这时只能使用比较器。

//  hm.put(new Student("lisi04","23"),"beijing4");//为什么抛出的异常不是我自己定义的："类型不匹配"  因为这里是构造函数传值错误 不是类型转换异常 所以当然不会调用你自定义的那个

因为你定义的时候就确定了类型，HashMap<Student,String>hm=new HashMap<Student,String>();
只能是传Student和String.Student中定义的int age 怎么能传入字符串呢？
这里编译器肯定是通不过的。
排序的话得用TreeMap.

import java.util.*;
class Student implements Comparable<Student>
{
  private String name;
  private int age;
  Student(String name,int age )
   {
     this.name=name;
  this.age=age;
   }
   public String toString()
    {
     return name+"+++"+age;
    }
   public int compareTo(Student s) //明明定义了比较方法，可还是不能排序，为什么？
    {
      int num=new Integer(this.age).compareTo(new Integer(s.age));
   if(num==0)
     return this.name.compareTo(s.name);
      return num;
    }   
   public boolean equals(Object obj)//只有在这里 比如你随便传个Person对象进来 那才会抛你所定义的ClassCastException异常
   {
     if(!(obj instanceof Student))
    throw new ClassCastException("类型不匹配");
     Student s=(Student)obj;
  return name.equals(s.name)&&this.age==s.age;
   }
  }
class MapTest
{
public static void main(String[] args)
{
  TreeMap<Student,String>hm=new TreeMap<Student,String>();//改成TreeMap集合就可以了
  hm.put(new Student("lisi05",20),"beijing1");
  hm.put(new Student("lisi05",20),"beijing1");
  hm.put(new Student("lisi02",21),"beijing2");
  hm.put(new Student("lisi03",22),"beijing3");
  hm.put(new Student("lisi04",23),"beijing4");
//  hm.put(new Student("lisi04","23"),"beijing4");//为什么抛出的异常不是我自己定义的："类型不匹配"  因为这里是构造函数传值错误 不是类型转换异常 所以当然不会调用你自定义的那个

  Set<Student> keySet=hm.keySet();
  Iterator <Student> it=keySet.iterator();
  while (it.hasNext())
  {
     Student stu=it.next();
     String addr=hm.get(stu);
     System.out.println(stu+"..."+addr);
  }  
}
}
楼主,顺便帮你整理下几种集合的区别吧   Map一样用  底层原理都差不多

List:元素是有序的，元素可以重复。因为该集合体系有索引。
    ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
    LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
    Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。





Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。
   HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
              是通过元素的两个方法，hashCode和equals来保证元素唯一性的。
              如果元素的HashCode值相同，才会判断equals是否为true。
              如果元素的hashcode值不同，不会调用equals。

              注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

   TreeSet：可以对Set集合中的元素进行排序。
               底层数据结构是二叉树。线程不同步.
                      保证元素唯一性的依据：
               通过compareTo方法或者比较器来实现元素的唯一性.

               TreeSet排序的第一种方式：让元素自身具备比较性。
               元素需要实现Comparable接口，覆盖compareTo方法。
               也种方式也成为元素的自然顺序，或者叫做默认顺序。

               TreeSet的第二种排序方式。
               当元素自身不具备比较性时，或者具备的比较性不是所需要的。
               这时就需要让集合自身具备比较性。
               在集合初始化时，就有了比较方式。(比较器)

  hm.put(new Student("lisi04","23"),"beijing4")=========23不要加引号

  hm.put(new Student("lisi04","23"),"beijing4")=========23不要加引号