对于一个普通的类，除了实现Comparable接口外，还可以通过什么方法能够对其进行排序？最好有代码实例......

应该是没有了吧，一个类实现了Comparable接口，就是给一个本来不具备排序的类实现了一个可排序的功能。
实现了Comparable接口之后可以自定义比较器或是采用默认的字典顺序进行排序。

在HashSet中Comparable接口并不能使用，那HashSet是如何去掉重复的元素的呢？

于汝国 发表于 2011-12-22 19:39
在HashSet中Comparable接口并不能使用，那HashSet是如何去掉重复的元素的呢？

可以添加类的equals方法去覆盖Object的equals方法.

1. class   MyObject{
   
2.     int   i;
   
3.     String   s;
   
4.     MyObject(int   i,String   s){
   
5.       this.i=i;
   
6.       this.s=s;
   
7.   }
   
8. 
   
9.   public   int   hashCode()   {
   
10.       return   s.hashCode();
    
11.   }
    
12. 
    
13.   public   boolean   equals(Object   o)   {
    
14.       if(o==null   ||!(   o   instanceof   MyObject)){
    
15.           return   false;
    
16.       }
    
17.       MyObject   ob=(MyObject)o;
    
18.       return   s.equals(ob.s)&&i==ob.i;
    
19.   }
    
20. }

复制代码

于汝国 发表于 2011-12-22 19:39
在HashSet中Comparable接口并不能使用，那HashSet是如何去掉重复的元素的呢？

重写hashCode()方法和equals()方法。

谢谢！通过hashCode()和equals()可以搞定，是吧！那我自己写个Person类搞搞……

实现Comparable接口是让类具有了排序功能
也可以自定义比较器（通过实现Comparator接口）让集合具有排序功能（通过集合的构造函数传入）

1. /*
   
2. 实现Comparator接口，自定义一个比较器，让容器具有比较功能， 实现容器内存放元素排序
   
3. 1.
   
4.   TreeSet 集合中靠比较器的 compareTo 或者compare 方法返回值的情况保证元素的唯一性
   
5.   返回是0的话，则元素重复，不添加到集合容器中
   
6.   
   
7.   2.如果同时使用了两个比较器，那么使用的是外部比较器（实现了Comparetor接口的比较器）
   
8.   */
   
9. package com.zengyun;
   
10. 
    
11. import java.util.Comparator;
    
12. import java.util.TreeSet;
    
13. 
    
14. public class ComparatorDemo
    
15. {
    
16. 
    
17.         public static void main(String[] args)
    
18.         {
    
19.                 TreeSet<Person> ts=new TreeSet<Person>(new MyComparator());//构造函数传入比较器
    
20.                 Person p1=new Person("abc",23);
    
21.                 Person p2=new Person("abc",24);
    
22.                 Person p3=new Person("abc",20);
    
23.                 Person p4=new Person("ebc",19);
    
24.                 Person p5=new Person("eec",22);
    
25.                 Person p6=new Person("abc",24);
    
26.                
    
27.                
    
28.                 ts.add(p1);
    
29.                 ts.add(p2);
    
30.                 ts.add(p3);
    
31.                 ts.add(p4);
    
32.                 ts.add(p5);
    
33.                
    
34.                 //输出容器内的元素
    
35.                 for(Person p:ts)
    
36.                 {
    
37.                         System.out.println(p);
    
38.                 }
    
39. 
    
40.         }
    
41. 
    
42. }
    
43. 
    
44. 
    
45. class MyComparator implements Comparator<Person>
    
46. {
    
47.         public int compare(Person p1,Person p2)
    
48.         {   
    
49.                 //先按年龄排序
    
50.                 if(p1.getAge()>p2.getAge())
    
51.                         return 1;
    
52.                 if(p1.getAge()<p2.getAge())
    
53.                         return -1;
    
54.                
    
55.                 //再按名字排序
    
56.                 if(p1.getName().compareTo(p2.getName())>0)
    
57.                         return 1;
    
58.                 if(p1.getName().compareTo(p2.getName())<0)
    
59.                         return -1;
    
60.                
    
61.                    return 0;
    
62.         }
    
63.        
    
64.        
    
65.        
    
66. }
    
67. 
    
68. 
    
69. 
    
70. class Person implements Comparable<Person>
    
71. {
    
72.         private String name;
    
73.         private int age;
    
74.         Person(String name,int age)
    
75.         {
    
76.           this.name=name;
    
77.           this.age=age;
    
78.         }
    
79.        
    
80.         public void setName(String name)
    
81.         {
    
82.          this.name=name;
    
83.         }
    
84.        
    
85.         public String getName()
    
86.         {
    
87.                 return this.name;
    
88.         }
    
89.        
    
90.        
    
91.         public void setAge(int age)
    
92.         {
    
93.                 this.age=age;
    
94.         }
    
95.        
    
96.         public int getAge()
    
97.         {
    
98.                 return this.age;
    
99.         }
    
100.         public int compareTo(Person p)
     
101.         {   
     
102.                 //先按照姓名升序排序
     
103.                 if(this.name.compareTo(p.getName())>0)
     
104.                         return 1;
     
105.                 if(this.name.compareTo(p.getName())<0)
     
106.                         return -1;
     
107.                 //再按照年龄升序排序
     
108.                 if(this.age>p.getAge())
     
109.                         return 1;
     
110.                 if(this.age<p.getAge())
     
111.                         return -1;
     
112.                 return 0;
     
113.                
     
114.         }
     
115.        
     
116.         @Override
     
117.         public int hashCode()
     
118.         {   
     
119.                 System.out.println("hashCode.....");
     
120.                 int result;
     
121.                 result=(name==null)?0:this.name.hashCode();
     
122.                 return result+age*13;
     
123.         }
     
124.        
     
125.         @Override
     
126.         public boolean equals(Object o)
     
127.         {   
     
128.                 System.out.println("equals()......");
     
129.                 if(this==o)
     
130.                         return true;
     
131.                
     
132.                 if(!(o instanceof Person))
     
133.                         return false;
     
134.                 Person p=(Person)o;
     
135.                 if(this.getName().equals(p.getName())&&this.getAge()==p.getAge())
     
136.                         return true;
     
137.                
     
138.                 return false;
     
139.         }
     
140.        
     
141.         public String toString()
     
142.         {
     
143.                 return "姓名："+this.name+"\t"+"年龄："+this.age;
     
144.         }
     
145.        
     
146. }

复制代码

谢谢大家哈！这回我明白了！有两种方法可以解决，嘻嘻！

让比较器具备比较性。

实现comparetor并覆盖compare方法；

其实就是楼主自己定义两个类怎么比较大小，比如按按类的某1（几）个域的大小，按类的hashcode等等，反正按你需要自己定义，想通了就简单得很

import   java.util.*;
public   class   CompType   implements   Comparable{
int   i;
int   j;
public   CompType(int   n1,int   n2){
i   =   n1;
j   =   n2;
}
public   String   toString(){
return   "[i   =   "+i+ ",   j   =   "+j+ "] ";
}
public   int   compareTo(Object   rv){
int   rvi   =   ((CompType)rv).i;
int   rvj   =   ((CompType)rv).j;
return   (i <rvi   ?   -1   :   (i==rvi   ?   0:1));
}
}
这个就是只比较第一个元素的大小!

/**
      @version   1.30   2004-02-27
      @author   Cay   Horstmann
*/

import   java.util.*;

public   class   EmployeeSortTest
{     
      public   static   void   main(String[]   args)
      {     
            Employee[]   staff   =   new   Employee[3];

            staff[0]   =   new   Employee( "Harry   Hacker ",   35000);
            staff[1]   =   new   Employee( "Carl   Cracker ",   75000);
            staff[2]   =   new   Employee( "Tony   Tester ",   38000);

            Arrays.sort(staff);

            //   print   out   information   about   all   Employee   objects
            for   (int   i   =   0;i <staff.length;i++)
            {
                  Employee   e=staff[i];
                  System.out.println( "name= "   +   e.getName()   +   ",salary= "   +   e.getSalary());
            }
      }
}

class   Employee   implements   Comparable
{     
      public   Employee(String   n,   double   s)
      {     
            name   =   n;
            salary   =   s;
      }

      public   String   getName()
      {     
            return   name;
      }

      public   double   getSalary()
      {     
            return   salary;
      }

      public   void   raiseSalary(double   byPercent)
      {     
            double   raise   =   salary   *   byPercent   /   100;
            salary   +=   raise;
      }

      public   int   compareTo(Object   otherObject)
      {     
          Employee   other   =   (Employee)otherObject;
            if   (salary   <   other.salary)   return   -1;
            if   (salary   >   other.salary)   return   1;
            return   0;
      }

      private   String   name;
      private   double   salary;
}