如果加入TreeSet和TreeMap的元素没有实现comprable中的compareTo()方法，那么会报错“treeset cannot be cast to java.lang.Comparable”.
要解决这个问题有两种方法：
（1）让元素自身具有比较性；可以实现Comparable接口，实现compareTo()方法；
（2）让集合自身具有比较性；可以定义比较器，即让集合实现Comparator接口，然后实现compare()方法；
方法一：
因此需要对元素类型实现Comparable借口，并实现compareTo()方法，即告诉TreeSet和TreeMap你要怎么排列，它才能进行排序。
基础类：
package niukewang;
import java.util.Objects;
public class setClass implements Comparable<setClass>{
String a;
String b;
public setClass(String a, String b)
{
this.a=a;
this.b=b;
}
public int hashCode() {
return a.hashCode();
}
public boolean equals(Object obj)
{
if(obj==null) return false;
if(getClass() != obj.getClass()) return false;
final setClass s=(setClass)obj;
return Objects.equals(this.a, s.a);
}
@Override
public int compareTo(setClass o) {
int num=this.b.compareTo(o.b);
return num;
}
}测试类：
package niukewang; import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Vector; public class test1 { public static void main(String args[])
{
setClass s1=new setClass("http://www.yjbys.com/", "same0");
setClass s2=new setClass("http://www.yjbys.com1/", "same0");
setClass s3=new setClass("http://www.yjbys.com2/", "same2");
setClass s4=new setClass("http://www.yjbys.com2/", "same3"); //hasSet
System.out.println("hasSet......");
Set<setClass> set=new HashSet<setClass>();
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
Iterator it= set.iterator();
while(it.hasNext())
{
setClass ob=(setClass)it.next();
System.out.println(ob.a);
} //TreeSet
System.out.println("\nTreeSet........");
Set<setClass> tree=new TreeSet<setClass>();
tree.add(s1);
tree.add(s2);
tree.add(s3);
tree.add(s4);
Iterator treeit=tree.iterator();
while(treeit.hasNext())
{
setClass ob=(setClass) treeit.next();
System.out.println(ob.a);
} //TreeMap
System.out.println("\nTreeMap.........");
Map<setClass,String> treemap=new TreeMap<setClass,String>();
treemap.put(s1, "TreeMap one");
treemap.put(s2, "TreeMap two");
treemap.put(s3, "TreeMap three");
treemap.put(s4, "TreeMap four");
for(Map.Entry<setClass, String> entry: treemap.entrySet())
{
System.out.println("The treemap key is "+entry.getKey().a+" The value is "+ entry.getValue());
} //HasMap
System.out.println("\nHashMap......");
Map<setClass,String> hashmap=new HashMap<setClass, String>();
hashmap.put(s1, "HashMap one");
hashmap.put(s2, "HashMap two");
hashmap.put(s3, "HashMap three");
hashmap.put(s4, "HashMap four");
for(Map.Entry<setClass, String> entry : hashmap.entrySet())
{
System.out.println("The key is "+entry.getKey().a+" The value is "+entry.getValue());
} //HasTable
System.out.println("\nHashTable......");
Map<setClass,String> hashtable=new Hashtable<setClass, String>();
hashtable.put(s1, "HashTable one");
hashtable.put(s2, "HashTable two");
hashtable.put(s3, "HashTable three");
hashtable.put(s4, "HashTable four");
for(Map.Entry<setClass, String> entry: hashtable.entrySet())
{
System.out.println("The HashTable key is "+entry.getKey().a+" The HashTable value is "+entry.getValue());
} //LinkedList
System.out.println("\nLinkedList.....");
List list=new LinkedList();
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
Iterator listit=list.iterator();
while(listit.hasNext())
{
setClass ob=(setClass)listit.next();
System.out.println(ob.a);
} //ArrayList
System.out.println("\nArrayList.....");
List array=new ArrayList();
array.add(s1);
array.add(s2);
array.add(s3);
array.add(s4);
Iterator arrayit=array.iterator();
while(arrayit.hasNext())
{
setClass ob=(setClass)arrayit.next();
System.out.println(ob.a);
} //vector
System.out.println("\nvector.....");
Vector v=new Vector();
v.add(s1);
v.add(s2);
v.add(s3);
v.add(s4);
Iterator vit=v.iterator();
while(vit.hasNext())
{
setClass ob=(setClass)vit.next();
System.out.println(ob.a);
} }
}
输出结果：
hasSet......
http://www.yjbys.com1/
http://www.yjbys.com/
http://www.yjbys.com2/
TreeSet........
http://www.yjbys.com/
http://www.yjbys.com2/
http://www.yjbys.com2/ TreeMap.........
The treemap key is http://www.yjbys.com/ The value is TreeMap two
The treemap key is http://www.yjbys.com2/ The value is TreeMap three
The treemap key is http://www.yjbys.com2/ The value is TreeMap four HashMap......
The key is http://www.yjbys.com1/ The value is HashMap two
The key is http://www.yjbys.com/ The value is HashMap one
The key is http://www.yjbys.com2/ The value is HashMap four HashTable......
The HashTable key is http://www.yjbys.com1/ The HashTable value is HashTable two
The HashTable key is http://www.yjbys.com/ The HashTable value is HashTable one
The HashTable key is http://www.yjbys.com2/ The HashTable value is HashTable four LinkedList.....
http://www.yjbys.com/
http://www.yjbys.com1/
http://www.yjbys.com2/
http://www.yjbys.com2/ ArrayList.....
http://www.yjbys.com/
http://www.yjbys.com1/
http://www.yjbys.com2/
http://www.yjbys.com2/ vector.....
http://www.yjbys.com/
http://www.yjbys.com1/
http://www.yjbys.com2/
http://www.yjbys.com2/
TreeSet并不像hashSet那样，用hashCode和equals取决于元素是否相等。
而是取决于compareTo()方法中指定的排序的方式；
setClass s1=new setClass("http://www.yjbys.com/", "same0");
setClass s2=new setClass("http://www.yjbys.com1/", "same0");
setClass s3=new setClass("http://www.yjbys.com2/", "same2");
setClass s4=new setClass("http://www.yjbys.com2/", "same3");
如果用hashCode和equals取决于元素是否相等，那么s3和s4是相等的；
而此时候，是根据compareTo()方法中的第二个字符串b来判断是否相等，则s1与s2相等，s3和s4不相等，所以才有这样的输出：
TreeSet........
http://www.yjbys.com/
http://www.yjbys.com2/
http://www.yjbys.com2/
方法二：
定义比较器，让集合实现Comparator接口，然后实现compare方法，则集合自身具有比较性。
其中Class Student 是实现了Comparable接口的，是元素本身具有比较性，在main方法中添加到TreeSet中的时候，能体现出来，通过年龄来比较大小；如果年龄和姓名相同，则是完全相等；
其中成员方法testComparator()中，定义了一个TreeSet，使其实现Comparator接口，并实现了方法compare()，通过setClass类中的a的属性的大小；因此此方法中的TreeSet具有比较性；
package niukewang; import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet; import org.junit.Test; //非线程安全
public class TreeSetTest {
/**
* TreeSet:它可以给Set集合中的元素进行指定方式的排序。 保证元素唯一性的方式：通过比较的结果是否为0. 底层数据结构是：二叉树。
*
* 排序的第一种方式： 让元素自身具备比较性。只要让元素实现Comparable接口，覆盖compareTo方法即可。
*
* 但是，如果元素自身不具备比较性，或者元素自身具备的比较性，不是所需要的。
* 比如，学生的自然排序是按年龄排序，现在想要按照学生姓名排序。还可以不改动原有代码。 这时怎么办呢？
*
* 排序的第二种方式：自定比较器的方式。这时可以让集合自身具备比较性。
*
* 可以定义一个类实现Comparator接口，覆盖compare方法。
* 将该Comparator接口子类对象作为实际参数传递给TreeSet集合构造函数。
*/
public static void main(String[] args) {
TreeSet<Student> ts = new TreeSet<Student>();
// Student如果不实现Comparable，add时会出错，Student cannot be cast to java.lang.Comparable
//添加第一个对象时，TreeSet里没有任何元素，所以没有问题；
//当添加第二个Err对象时，TreeSet就会调用该对象的compareTo(Object obj)方法与集合中其他元素进行比较——
//如果对应的类没有实现Comparable接口，则会引发ClassCastException异常
// add方法内部会对插入的数据进行排序，此时元素自身具备比较性，因为其实现了Comparable接口
ts.add(new Student("lisi0", 30));
ts.add(new Student("lisixx", 29));
ts.add(new Student("lisi9", 29));
ts.add(new Student("lisi8", 38));
// 重复插入无效，但是不报错（根据年龄和名字进行比较，都相同，视为同一个学生）
ts.add(new Student("lisixx", 29));
ts.add(new Student("lisixx", 28));
ts.add(new Student("lisi4", 14));
ts.add(new Student("lisi7", 27));
System.out.println(ts); System.out.println("testComparator........\n");
TreeSetTest ob=new TreeSetTest();
ob.testComprator();
} //自定义比较器，让集合自身具备比较性
@Test
public void testComprator()
{
setClass s1=new setClass("http://www.yjbys.com/", "same0");
setClass s2=new setClass("http://www.yjbys.com1/", "same0");
setClass s3=new setClass("http://www.yjbys.com2/", "same2");
setClass s4=new setClass("http://www.yjbys.com2/", "same3"); Set<setClass> treeset=new TreeSet<setClass>(new Comparator<setClass>(){ @Override
public int compare(setClass arg0, setClass arg1) {
// TODO Auto-generated method stub
int num=arg0.a.compareTo(arg1.a); //只比较属性a的大小
return num;
}
}); treeset.add(s1);
treeset.add(s2);
treeset.add(s3);
treeset.add(s4); System.out.println(treeset);
} //同姓名同年龄的学生视为同一个学生
public static class Student implements Comparable<Student> { private int age;
private String name; public Student(String name, int age) {
this.age = age;
this.name = name;
} @Override
public int compareTo(Student stu) {
int num = new Integer(this.age).compareTo(new Integer(stu.age));
return num == 0 ? this.name.compareTo(stu.name) : num;
} public String toString() {
return name + "::" + age;
} public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
}
}
}
运行结果：
[lisi4::14, lisi7::27, lisixx::28, lisi9::29, lisixx::29, lisi0::30, lisi8::38]
testComparator........ [http://www.yjbys.com/ :: same0, http://www.yjbys.com1/ :: same0, http://www.yjbys.com2/ :: same2]
由上图可知：
Stuent类是通过年龄判断的，所以按年龄排序；只有姓名和年龄都相同时，则认为是相同的，所以ts.add(new Student("lisixx", 29))不会重复添加；其他因为姓名不同，就算年龄相同，也认为是不相同的；
setClass类，是根据setClass中的属性a的值是否相等,就算hashCode和equals方法被重写了，它只看比较性。
注意：
如果在setClass类中，如果没有重写public String toString()方法，则会输出类似下面的输出：
[niukewang.setClass@cbf33da, niukewang.setClass@8b2747d3, niukewang.setClass@8b2747f2]
但是如果重写了public String toString()方法：
public String toString()
{
return this.a+" :: "+this.b;
}
则会输出：[http://www.yjbys.com/ :: same0, http://www.yjbys.com1/ :: same0, http://www.yjbys.com2/ :: same2]