JAVA------sort-----------------排序
转自：
http://www.mkyong.com/java/java-object-sorting-example-comparable-and-comparator/
1. Sort an Array
To sort an Array, use the Arrays.sort().
String[] fruits = new String[] {"Pineapple","Apple", "Orange", "Banana"};
Arrays.sort(fruits);
int i=0;
for(String temp: fruits){
System.out.println("fruits " + ++i + " : " + temp);
}
Output
fruits 1 : Apple fruits 2 : Banana fruits 3 : Orange fruits 4 : Pineapple
2. Sort an ArrayList
To sort an ArrayList, use the Collections.sort().
List<String> fruits = new ArrayList<String>(); fruits.add("Pineapple"); fruits.add("Apple"); fruits.add("Orange"); fruits.add("Banana"); Collections.sort(fruits); int i=0; for(String temp: fruits){ System.out.println("fruits " + ++i + " : " + temp); }
Output
fruits 1 : Apple fruits 2 : Banana fruits 3 : Orange fruits 4 : Pineapple
3. Sort an Object with Comparable
How about a Java Object? Let create a Fruit class:
public class Fruit{ private String fruitName; private String fruitDesc; private int quantity; public Fruit(String fruitName, String fruitDesc, int quantity) { super(); this.fruitName = fruitName; this.fruitDesc = fruitDesc; this.quantity = quantity; } public String getFruitName() { return fruitName; } public void setFruitName(String fruitName) { this.fruitName = fruitName; } public String getFruitDesc() { return fruitDesc; } public void setFruitDesc(String fruitDesc) { this.fruitDesc = fruitDesc; } public int getQuantity() { return quantity; } public void setQuantity(int quantity) { this.quantity = quantity; } }
To sort it, you may think of Arrays.sort() again, see below example :
package com.mkyong.common.action; import java.util.Arrays; public class SortFruitObject{ public static void main(String args[]){ Fruit[] fruits = new Fruit[4]; Fruit pineappale = new Fruit("Pineapple", "Pineapple description",70); Fruit apple = new Fruit("Apple", "Apple description",100); Fruit orange = new Fruit("Orange", "Orange description",80); Fruit banana = new Fruit("Banana", "Banana description",90); fruits[0]=pineappale; fruits[1]=apple; fruits[2]=orange; fruits[3]=banana; Arrays.sort(fruits); int i=0; for(Fruit temp: fruits){ System.out.println("fruits " + ++i + " : " + temp.getFruitName() + ", Quantity : " + temp.getQuantity()); } } }
Nice try, but, what you expect the Arrays.sort() will do? You didn’t even mention what to sort in the Fruit class. So, it will hits the following error :
Exception in thread "main" java.lang.ClassCastException: com.mkyong.common.Fruit cannot be cast to java.lang.Comparable at java.util.Arrays.mergeSort(Unknown Source) at java.util.Arrays.sort(Unknown Source)
To sort an Object by its property, you have to make the Object implement the Comparable interface and override thecompareTo() method. Lets see the new Fruit class again.
public class Fruit implements Comparable<Fruit>{ private String fruitName; private String fruitDesc; private int quantity; public Fruit(String fruitName, String fruitDesc, int quantity) { super(); this.fruitName = fruitName; this.fruitDesc = fruitDesc; this.quantity = quantity; } public String getFruitName() { return fruitName; } public void setFruitName(String fruitName) { this.fruitName = fruitName; } public String getFruitDesc() { return fruitDesc; } public void setFruitDesc(String fruitDesc) { this.fruitDesc = fruitDesc; } public int getQuantity() { return quantity; } public void setQuantity(int quantity) { this.quantity = quantity; } public int compareTo(Fruit compareFruit) { int compareQuantity = ((Fruit) compareFruit).getQuantity(); //ascending order return this.quantity - compareQuantity; //descending order //return compareQuantity - this.quantity; } }
The new Fruit class implemented the Comparable interface, and overrided the compareTo() method to compare its quantity property in ascending order.
The
compareTo() method is hard to explain, in integer sorting, just remember
- this.quantity – compareQuantity is ascending order.
- compareQuantity – this.quantity is descending order.
To understand more about compareTo() method, read this Comparable documentation.
Run it again, now the Fruits array is sort by its quantity in ascending order.
fruits 1 : Pineapple, Quantity : 70 fruits 2 : Orange, Quantity : 80 fruits 3 : Banana, Quantity : 90 fruits 4 : Apple, Quantity : 100
4. Sort an Object with Comparator
How about sorting with Fruit’s “fruitName” or “Quantity”? The Comparable interface is only allow to sort a single property. To sort with multiple properties, you need Comparator. See the new updated Fruit class again :
import java.util.Comparator; public class Fruit implements Comparable<Fruit>{ private String fruitName; private String fruitDesc; private int quantity; public Fruit(String fruitName, String fruitDesc, int quantity) { super(); this.fruitName = fruitName; this.fruitDesc = fruitDesc; this.quantity = quantity; } public String getFruitName() { return fruitName; } public void setFruitName(String fruitName) { this.fruitName = fruitName; } public String getFruitDesc() { return fruitDesc; } public void setFruitDesc(String fruitDesc) { this.fruitDesc = fruitDesc; } public int getQuantity() { return quantity; } public void setQuantity(int quantity) { this.quantity = quantity; } public int compareTo(Fruit compareFruit) { int compareQuantity = ((Fruit) compareFruit).getQuantity(); //ascending order return this.quantity - compareQuantity; //descending order //return compareQuantity - this.quantity; } public static Comparator<Fruit> FruitNameComparator = new Comparator<Fruit>() { public int compare(Fruit fruit1, Fruit fruit2) { String fruitName1 = fruit1.getFruitName().toUpperCase(); String fruitName2 = fruit2.getFruitName().toUpperCase(); //ascending order return fruitName1.compareTo(fruitName2); //descending order //return fruitName2.compareTo(fruitName1); } }; }
The Fruit class contains a static FruitNameComparator method to compare the “fruitName”. Now the Fruit object is able to sort with either “quantity” or “fruitName” property. Run it again.
1. Sort Fruit array based on its “fruitName” property in ascending order.
Arrays.sort(fruits, Fruit.FruitNameComparator);
Output
fruits 1 : Apple, Quantity : 100 fruits 2 : Banana, Quantity : 90 fruits 3 : Orange, Quantity : 80 fruits 4 : Pineapple, Quantity : 70
2. Sort Fruit array based on its “quantity” property in ascending order.
Arrays.sort(fruits)
Output
fruits 1 : Pineapple, Quantity : 70 fruits 2 : Orange, Quantity : 80 fruits 3 : Banana, Quantity : 90 fruits 4 : Apple, Quantity : 100
The
java.lang.Comparable and
java.util.Comparator are powerful but take time to understand and make use of it, may be it’s due to the lacking of detail example.
My thoughts…
In future, Arrays class should provides more generic and handy method – Arrays.sort(Object, String, flag).
To sort a object array by its “fruitName” in ascending order.
Arrays.sort(fruits, fruitName, Arrays.ASCENDING);
To sort a object array by its “quantity” in ascending order.
Arrays.sort(fruits, quantity, Arrays.DESCENDING);
Reference
- Comparable documentation
- Comparator documentation
========一个关于comparable<T> ===排序
============================================
import java.util.Iterator;
import java.util.TreeSet;
class testSort
{
public static void main(String[] args)
{
TreeSet<Object> ts=new TreeSet<Object>();
ts.add(new MyStudents(2,"Vida")); ///从打印信息可以看出，从第二个开始起，每加入一个对象，排序一次。
System.out.println("-----------insert one-->");
ts.add(new MyStudents(4,"Lillian"));
System.out.println("-----------insert one-->");
ts.add(new MyStudents(2,"Lightmoon"));
System.out.println("-----------insert one-->");
ts.add(new MyStudents(1,"Chaner"));
System.out.println("-----------insert one-->");
Iterator it=ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
class MyStudents implements Comparable<Object>
{
int number;
String name;
MyStudents(int number,String name)
{
this.number=number;
this.name=name;
}
public String toString()
{
return "The Student's information is: Number="+number+" name="+name;
}
public int compareTo(Object o) ///排序的方法。
{
MyStudents mst=(MyStudents)o;
int result;
result=number > mst.number ? 1 : (number==mst.number ? 0 : -1);
System.out.println("----------start sort-->");
if(result==0)
{
return result=name.compareTo(mst.name);
}
return result;
}
}============================关于
Comparator<Object> 的排序＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
import java.util.*;
class TreeSetTest
{
public static void main(String[] args)
{
TreeSet<Object> ts=new TreeSet<Object>(new MyStudents.MyStudentsComparator());
ts.add(new MyStudents(2,"Vida"));
ts.add(new MyStudents(4,"Lillian"));
ts.add(new MyStudents(2,"Lightmoon"));
ts.add(new MyStudents(1,"Chaner"));
Iterator it=ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
class MyStudents
{
int number;
String name;
MyStudents(int number,String name)
{
this.number=number;
this.name=name;
}
public String toString()
{
return "The Student's information is: Number="+number+" name="+name;
}
static class MyStudentsComparator implements Comparator<Object>
{
public int compare(Object o1,Object o2)
{
MyStudents mst1=(MyStudents)o1;
MyStudents mst2=(MyStudents)o2;
int result=mst1.number>mst2.number?1:(mst1.number==mst2.number?0:-1);
if(result==0)
{
return mst1.name.compareTo(mst2.name);
}
return result;
}
}
}
一个是lang包下面的接口,一个是util包下面的接口,看起来两个是实现相同的目的,但两者还是有区别的,
1.Comparable<T>只有一个要实现的方法叫CompareTo
而Comparator<T>取有两个方法.一个是Compare和equals
2Comparable是一个参数的.而且他是系统调用的方法.所以他只能表示传入对象与当前对象的比较
而Comparator是两个参数的,虽然也是系统调用的方法,不过他的比较就可以不是当前对象于传入对象的比较了,范围就大多了.