1.使用Collections.sort(List, Comparator)实现
/**
* Java对象排序的3种实现方式
* @author zhangwenzhang
*
*/
public class TestObjectSort {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
/**方法1
* 使用Collections.sort(List, Comparator)实现，必须实现Comparator的一个比较器并复写compare()方法
*/
Person1[] ps = new Person1[]{new Person1("p0",0),
new Person1("p1",3),
new Person1("p2",5),
new Person1("p3",4),
new Person1("p4",8),
new Person1("p5",6),
new Person1("p6",7),
new Person1("p7",1),
new Person1("p8",2),
new Person1("p9",9)};
List<Person1> pl = new ArrayList<Person1>();
for(int i = 0; i < 10; i++){
System.out.print(ps[i].getAge());
pl.add(ps[i]);
}
System.out.println("/n使用Collections.sort(List, Comparator)类来比较：");
long l1 = System.currentTimeMillis();
Collections.sort(pl, new MyComparator());
System.out.println("time: " + (System.currentTimeMillis() - l1));
for(Iterator it = pl.iterator(); it.hasNext();){
Person1 p = (Person1) it.next();
System.out.print(p.getAge());
}
2.使用Arrays.sort(Object[])实现
/**方法2* 使用Arrays.sort(Object[])实现, 对象必须实现Comparable接口并复写compareTo()方法
*/
Person2[] ps2 = new Person2[]{new Person2("p0",0),
new Person2("p1",3),
new Person2("p2",5),
new Person2("p3",4),
new Person2("p4",8),
new Person2("p5",6),
new Person2("p6",7),
new Person2("p7",1),
new Person2("p8",2),
new Person2("p9",9)};
System.out.println("/n使用Arrays.sort(Object[])类来比较：");
long l2 = System.currentTimeMillis();
Arrays.sort(ps2);
System.out.println("time: " + (System.currentTimeMillis() - l2));
for(int i = 0; i < 10; i++){
System.out.print(ps2[i].getAge());
}
3.使用Collections.sort(List)实现
/**方法3* 使用Collections.sort(List)实现， 对象必须实现Comparable接口并复写compareTo()方法
*/
Person2[] ps3 = new Person2[]{new Person2("p0",0),
new Person2("p1",3),
new Person2("p2",5),
new Person2("p3",4),
new Person2("p4",8),
new Person2("p5",6),
new Person2("p6",7),
new Person2("p7",1),
new Person2("p8",2),
new Person2("p9",9)};
List<Person2> pl3 = new ArrayList<Person2>();
for(int i = 0; i < 10; i++){
pl3.add(ps3[i]);
}
System.out.println("/n使用Collections.sort(List)类来比较：");
Collections.sort(pl3);
for(Iterator it = pl3.iterator(); it.hasNext();){
Person2 p = (Person2) it.next();
System.out.print(p.getAge());
}
}
}
/**
* 方法1需要
* @author zhangwenzhang
*
*/
class MyComparator implements Comparator{
public int compare(Object o1, Object o2){
Person1 p1 = (Person1)o1;
Person1 p2 = (Person1)o2;
if(p1.getAge() < p2.getAge()){
return -1;
}else if(p1.getAge() == p2.getAge()){
return 0;
}else{
return 1;
}
}
}
/**
* 方法1需要
* @author zhangwenzhang
*
*/
class Person1{
private String name;
private int age;
public Person1(){}
public Person1(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;
}
}
/**
* 方法2,3需要
* @author zhangwenzhang
*
*/
class Person2 implements Comparable{
private String name;
private int age;
public Person2(){}
public Person2(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 int compareTo(Object o){
Person2 p = (Person2)o;
if(this.age < p.age){
return -1;
}else if(this.age == p.age){
return 0;
}else{
return 1;
}
}
}
-----------------------------------------------------Arrays.sort和Collections.sort补充资料-------------------------------------------------------------
1.我们使用Arrays对数组进行排序，使用Collections对结合框架容器进行排序，如ArraysList,LinkedList等。
Arrays.sort 对基本数据类型(primitive type)或String类型的数组进行排序：
对基本数据类型(primitive type)或String类型的数组进行排序
int[] intArray = new int[] {4, 1, 3, -23};
Arrays.sort(intArray);
// [-23, 1, 3, 4]
String[] strArray = new String[] {"z", "a", "C"};
Arrays.sort(strArray);
// [C, a, z]
// Case-insensitive sort
Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
// [a, C, z]
// Reverse-order sort
Arrays.sort(strArray, Collections.reverseOrder());
// [z, a, C]
// Case-insensitive reverse-order sort
Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);
Collections.reverse(Arrays.asList(strArray));
// [z, C, a]
2.当然我们也可以指定数组的某一段进行排序比如我们要对数组下表0-2的部分(假设数组长度大于3)进行排序，其他部分保持不变，我们可以使用:
Arrays.sort(strArray,0,2);
这样，我们只对前三个元素进行了排序，而不会影响到后面的部分。
3.对对象数组进行排序，对象必须实现Comparable接口
这个数组的自然顺序是未知的，因此我们需要为该类实现Comparable接口
Name类
public class Name implements Comparable<Name>{
public String firstName, lastName;
public Name(String firstName,String lastName){
this.firstName=firstName;
this.lastName=lastName;
}
public int compareTo(Name o) { //实现接口
int lastCmp=lastName.compareTo(o.lastName);
return (lastCmp!=0?lastCmp:firstName.compareTo(o.firstName));
}
public String toString(){ //便于输出测试
return firstName+" "+lastName;
}
}
这样，当我们对这个对象数组进行排序时，就会先比较lastName，然后比较firstName 然后得出两个对象的先后顺序，就像compareTo(Name o)里实现的那样
用程序进行测试
NameSort类
import java.util.*;
public class NameSort {
public static void main(String[] args) {
// TODO Auto-generated method stub
Name[] nameArray = new Name[]{
new Name("John", "Lennon"),
new Name("Karl", "Marx"),
new Name("Groucho", "Marx"),
new Name("Oscar", "Grouch")
};
Arrays.sort(nameArray);
for(int i=0;i<nameArray.length;i++){
System.out.println(nameArray[i].toString());
}
}
}
对集合框架进行排序
如果已经理解了Arrays.sort()对数组进行排序的话，集合框架的使用也是大同小异。只是将Arrays替换成了Collections,注意Collections是一个类而Collection是一个接口.
假如有这样一个链表:
LinkedList list=new LinkedList();
list.add(4);
list.add(34);
list.add(22);
list.add(2);
我们只需要使用:
Collections.sort(list);
就可以将ll里的元素按从小到大的顺序进行排序，结果就成了:
[2, 4, 22, 34]
如果LinkedList里面的元素是String，同样会想基本数据类型一样从小到大排序。
如果要实现反序排序也就是从大到小排序:
Collections.sort(list,Collections.reverseOrder()); 此方法实际是： Collections.sort(List<T>, Comparator<? super T>)
或者 Collections.reverse(list);
如果LinkedList里面的元素是自定义的对象，可以像上面的Name对象一样实现Comparable接口，就可以让Collection.sort()为您排序了。
对对象进行自定义排序
可以使用sort(List<T> list, Comparator<? super T> c)这个方法进行排序，
FIRST_NAME_ORDER类
import java.util.*;
public class FIRST_NAME_ORDER implements Comparator<Name>{
public int compare(Name n1, Name n2) {
int firstCmp=n1.firstName.compareTo(n2.firstName);
return (firstCmp!=0?firstCmp:n1.lastName.compareTo
(n2.firstName));
}
}
在上面的NameSort中将 Arrays.sort(nameArray);替换成下面语句
List<Name> list=Arrays.asList(nameArray); //将名字数组转化为List
Collections.sort(list,new FIRST_NAME_ORDER());
下面举例根据TreeMap的key进行降序排序
import java.util.*;
public class DescMap implements Comparator<String>{
public int compare(String o1, String o2)
{
int map1 = Integer.parseInt(o1);
int map2 = Integer.parseInt(o2);
return map2-map1;
}
public static void main(String[] args)
{
String[] arraySources = {"1","2","3","0"};
int[] arrayValue = {1,424,32,123};
Map mapCurrentWebSite = new TreeMap(new DescMap());
for(int i=0;i<arraySources.length;i++)
{
mapCurrentWebSite.put(arraySources[i],new Integer(arrayValue[i]));
}
Collection col = mapCurrentWebSite.values();
Vector v1 = new Vector(col);
for(int i=0;i<v1.size();i++)
System.out.println((Integer)v1.get(i));
}
}
-------------------------------DK7中的排序算法详解--Collections.sort和Arrays.sort ----------------------------------------------
1. 为什么写这篇文章
这篇文章的根源是在产品中发现了一个诡异的bug：只能在产品环境下重现，在我的本地开发环境无法重现，而双方的代码没有任何区别。最后用remote debug的方法找到异常所在：
Exception in thread "main" java.lang.IllegalArgumentException: Comparison
method violates its general contract!
Google了这个错误，是由于Java 7内置的新排序算法导致的。这才猛然想起产品的编译环境最近升级到了Java 7。
2. 结论
在Java 6中Arrays.sort()和Collections.sort()使用的是MergeSort，而在Java 7中，内部实现换成了TimSort，其对对象间比较的实现要求更加严格：
Comparator的实现必须保证以下几点（出自这儿）：
a). sgn(compare(x, y)) == -sgn(compare(y, x))
b). (compare(x, y)>0) && (compare(y, z)>0) 意味着 compare(x, z)>0
c). compare(x, y)==0 意味着对于任意的z：sgn(compare(x, z))==sgn(compare(y, z)) 均成立
而我们的代码中，某个compare()实现片段是这样的：
public int compare(ComparatorTest o1, ComparatorTest o2) {
return o1.getValue() > o2.getValue() ? 1 : -1;
}
这就违背了a)原则：假设X的value为1，Y的value也为1；那么compare(X, Y) ≠ –compare(Y, X)
PS: TimSort不仅内置在各种JDK 7的版本，也存在于Android SDK中（尽管其并没有使用JDK 7）。
3. 解决方案
3.1) 更改内部实现：例如对于上个例子，就需要更改为
public int compare(ComparatorTest o1, ComparatorTest o2) {
return o1.getValue() == o2.getValue() ? 0 :
(o1.getValue() > o2.getValue() ? 1 : -1);
}
3.2) Java 7预留了一个接口以便于用户继续使用Java 6的排序算法：在启动参数中（例如eclipse.ini）添加-Djava.util.Arrays.useLegacyMergeSort=true
3.3) 将这个IllegalArgumentException手动捕获住（不推荐）
4. TimSort在Java 7中的实现
那么为什么Java 7会将TimSort作为排序的默认实现，甚至在某种程度上牺牲它的兼容性（在stackoverflow上有大量的问题是关于这个新异常的）呢？接下来我们不妨来看一看它的实现。
首先建议大家先读一下这篇文章以简要理解TimSort的思想。
4.1) 如果传入的Comparator为空，则使用ComparableTimSort的sort实现。
image
4.2) 传入的待排序数组若小于MIN_MERGE（Java实现中为32，Python实现中为64），则
a) 从数组开始处找到一组连接升序或严格降序（找到后翻转）的数
b) Binary Sort：使用二分查找的方法将后续的数插入之前的已排序数组
image
4.3) 开始真正的TimSort过程：
4.3.1) 选取minRun大小，之后待排序数组将被分成以minRun大小为区块的一块块子数组
a) 如果数组大小为2的N次幂，则返回16（MIN_MERGE / 2）
b) 其他情况下，逐位向右位移（即除以2），直到找到介于16和32间的一个数
image
4.3.2) 类似于4.2.a找到初始的一组升序数列
4.3.3) 若这组区块大小小于minRun，则将后续的数补足（采用binary sort插入这个数组）
4.3.4) 为后续merge各区块作准备：记录当前已排序的各区块的大小
4.3.5) 对当前的各区块进行merge，merge会满足以下原则（假设X，Y，Z为相邻的三个区块）：
a) 只对相邻的区块merge
b) 若当前区块数仅为2，If X<=Y，将X和Y merge
b) 若当前区块数>=3，If X<=Y+Z，将X和Y merge，直到同时满足X>Y+Z和Y>Z
image
4.3.6) 重复4.3.2 ~ 4.3.5，直到将待排序数组排序完
4.3.7) Final Merge：如果此时还有区块未merge，则合并它们
image
5. Demo
这一节用一个具体的例子来演示整个算法的演进过程：
*注意*：为了演示方便，我将TimSort中的minRun直接设置为2，否则我不能用很小的数组演示。。。同时把MIN_MERGE也改成2（默认为32），这样避免直接进入binary sort。
初始数组为[7,5,1,2,6,8,10,12,4,3,9,11,13,15,16,14]
=> 寻找连续的降序或升序序列 (4.3.2)
[1,5,7] [2,6,8,10,12,4,3,9,11,13,15,16,14]
=> 入栈 (4.3.4)
当前的栈区块为[3]
=> 进入merge循环 (4.3.5)
do not merge因为栈大小仅为1
=> 寻找连续的降序或升序序列 (4.3.2)
[1,5,7] [2,6,8,10,12] [4,3,9,11,13,15,16,14]
=> 入栈 (4.3.4)
当前的栈区块为[3, 5]
=> 进入merge循环 (4.3.5)
merge因为runLen[0]<=runLen[1]
1) gallopRight：寻找run1的第一个元素应当插入run0中哪个位置（”2”应当插入”1”之后），然后就可以忽略之前run0的元素（都比run1的第一个元素小）
2) gallopLeft：寻找run0的最后一个元素应当插入run1中哪个位置（”7”应当插入”8”之前），然后就可以忽略之后run1的元素（都比run0的最后一个元素大）
这样需要排序的元素就仅剩下[5,7] [2,6]，然后进行mergeLow
完成之后的结果：
[1,2,5,6,7,8,10,12] [4,3,9,11,13,15,16,14]
=> 入栈 (4.3.4)
当前的栈区块为[8]
退出当前merge循环因为栈中的区块仅为1
=> 寻找连续的降序或升序序列 (4.3.2)
[1,2,5,6,7,8,10,12] [3,4] [9,11,13,15,16,14]
=> 入栈 (4.3.4)
当前的栈区块大小为[8,2]
=> 进入merge循环 (4.3.5)
do not merge因为runLen[0]>runLen[1]
=> 寻找连续的降序或升序序列 (4.3.2)
[1,2,5,6,7,8,10,12] [3,4] [9,11,13,15,16] [14]
=> 入栈 (4.3.4)
当前的栈区块为[8,2,5]
=>
do not merege run1与run2因为不满足runLen[0]<=runLen[1]+runLen[2]
merge run2与run3因为runLen[1]<=runLen[2]
1) gallopRight：发现run1和run2就已经排好序
完成之后的结果：
[1,2,5,6,7,8,10,12] [3,4,9,11,13,15,16] [14]
=> 入栈 (4.3.4)
当前入栈的区块大小为[8,7]
退出merge循环因为runLen[0]>runLen[1]
=> 寻找连续的降序或升序序列 (4.3.2)
最后只剩下[14]这个元素：[1,2,5,6,7,8,10,12] [3,4,9,11,13,15,16] [14]
=> 入栈 (4.3.4)
当前入栈的区块大小为[8,7,1]
=> 进入merge循环 (4.3.5)
merge因为runLen[0]<=runLen[1]+runLen[2]
因为runLen[0]>runLen[2]，所以将run1和run2先合并。（否则将run0和run1先合并）
1) gallopRight & 2) gallopLeft
这样需要排序的元素剩下[13,15] [14]，然后进行mergeHigh
完成之后的结果：
[1,2,5,6,7,8,10,12] [3,4,9,11,13,14,15,16] 当前入栈的区块为[8,8]
=>
继续merge因为runLen[0]<=runLen[1]
1) gallopRight & 2) gallopLeft
需要排序的元素剩下[5,6,7,8,10,12] [3,4,9,11]，然后进行mergeHigh
完成之后的结果：
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16] 当前入栈的区块大小为[16]
=>
不需要final merge因为当前栈大小为1
=>
结束
6. 如何重现文章开始提到的Exception
这一节将剥离复杂的业务逻辑，用一个最简单的例子（不修改TimSort.java内置的各种参数）重现文章开始提到的Exception。因为尽 管google出来的结果中非常多的人提到了这个Exception及解决方案，但并没有人给出一个可以重现的例子和测试数据。另一方面，我也想从其他角 度来加深对这个问题的理解。
构造测试数据的过程是个反人类的过程:( 大家不要学我。。
以下是能重现这个问题的代码：
public class ReproJava7Exception {
public static void main(String[] args) {
int[] sample = new int[]
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,0,-2,0,0,0,0};
List list = new ArrayList();
for (int i : sample)
list.add(i);
// use the native TimSort in JDK 7
Collections.sort(list, new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
// miss the o1 = o2 case on purpose
return o1 > o2 ? 1 : -1;
}
});
}
}
7. Sample Code
这篇文章的所有代码可以到github：https://github.com/Huang-Wei/understanding-timsort-java7下载。
8. References
http://en.wikipedia.org/wiki/Timsort
http://www.geneffects.com/briarskin/theory/binary/index.html
http://docs.oracle.com/javase/6/docs/api/java/util/Comparator.html#compare(T, T)
http://www.oracle.com/technetwork/java/javase/compatibility-417013.html#source
本文属于转载。
4123
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
