Java中的Arrays类中sort方法comparable接口

http://blog.csdn.net/congcongsuiyue/article/details/40616335

1，实现此接口的对象列表（和数组）可以通过Collections.sort （和Arrays.sort ）进行自动排序。

P215Java核心思想：

Arrays类中的sort方法承诺可以对对象数组进行排序，但要求满足前提：对象所属的类必须实现了Comparable接口

2，与Comparator的区别

Comparator位于包java.util下，而Comparable位于包java.lang下，Comparable接口将比较代码嵌入自身类中，而后者在一个独立的类中实现比较。 如果类的设计师没有考虑到Compare的问题而没有实现Comparable接口，可以通过  Comparator来实现比较算法进行排序，并且为了使用不同的排序标准做准备，比如：升序、降序。

自己感觉：comparator完全独立于元素类，因此可以非常方便地修改排序规则。你还可以定义一系列比较器，供排序时选择使用

实现其compare（T o1,T o2）有一个约定，就是 a.compare(b) == 0 和a.equals(b)要有相同的boolean结果。

我们看一个Comparator的例子：

import java.util.TreeSet;
import java.util.Comparator;
class NumComparator implements Comparator<NameTag> {
    public int compare (NameTag left,NameTag right) {
        return(left.getNumber() - right.getNumber());
    }
}
public class CollectionNine {
    public static void main(String arg[]) {
        new CollectionNine();
    }
    CollectionNine() {
        NumComparator comparator = new NumComparator();
        TreeSet<NameTag> set = new TreeSet<NameTag>(comparator);
        set.add(new NameTag("Agamemnon",300));
        set.add(new NameTag("Cato",400));
        set.add(new NameTag("Plato",100));
        set.add(new NameTag("Zeno",200));
        set.add(new NameTag("Archimedes",500));
        for(NameTag tag : set)
            System.out.println(tag);
    }
}

http://blog.csdn.net/wang_yubin/article/details/8059332

Sorting an Array

      1. 数字排序  int[] intArray = new int[] { 4, 1, 3, -23 };

　　Arrays.sort(intArray);

　　输出： [-23, 1, 3, 4]

　　2. 字符串排序，先大写后小写 String[] strArray = new String[] { "z", "a", "C" };

　　Arrays.sort(strArray);

　　输出： [C, a, z]     //按照ASCII的升序排序。

　　3. 严格按字母表顺序排序，也就是忽略大小写排序 Case-insensitive sort

　　Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);

　　输出： [a, C, z]

　　4. 反向排序， Reverse-order sort  按照ASCII的降序排序。

　　Arrays.sort(strArray, Collections.reverseOrder());

　　输出：[z, a, C]

　　5. 忽略大小写反向排序 Case-insensitive reverse-order sort

　　Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);

　　Collections.reverse(Arrays.asList(strArray));

　　输出： [z, C, a]

http://developer.51cto.com/art/200906/128330.htm

一、数组列数据的添加与删除：list.add(0, "b"); b = list.remove(0);  

二、Java list排序：上面4种

三、list的操作：

list1.retainAll(list2);

只保留list1和list2中相同的部分（交集）？

list1.subList(newSize, list1.size()).clear();

返回newSize到list1.size之间的部分。

方法总结：

list.add()：添加数据                                 

list.remove()：删除数据

Arrays.asList()：指定大小的列

Collections.sort()：按ASCII升序排序        

Collections.reverseOrder()和Collections.reverse()：按ASCII降序排序，区别在于参数

list.addAll()：添加()所有数据                  

list.removeAll()：删除()所有数据

list.retainAll()：保留交集                            

list.subList(size1, size2)： 返回size1到size2之间的数据

http://blog.csdn.net/oanqoanq/article/details/3321257

java对primitive（int，float等原型数据）数组采用快速排序，对Object对象数组采用归并排序。如果数组的长度小于7，则是最简单的插入排序，否则采用快速排序，优化的归并排序既快速（nlog(n)）又稳定。

    对于对象的排序，稳定性很重要。比如成绩单,一开始可能是按人员的学号顺序排好了的,现在让我们用成绩排,那么你应该保证,本来张三在李四前面,即使他们成绩相同,张三不能跑到李四的后面去。

    而快速排序是不稳定的，而且最坏情况下的时间复杂度是O(n^2)。

    另外，对象数组中保存的只是对象的引用，这样多次移位并不会造成额外的开销，但是，对象数组对比较次数一般比较敏感，有可能对象的比较比单纯数的比较开销大很多。归并排序在这方面比快速排序做得更好，这也是选择它作为对象排序的一个重要原因之一。  

    如果数组的长度小于7，则是最简单的插入排序，否则采用快速排序。在归并过程中如果数组长度小于7，则采用插入排序使数组有序。

http://blog.csdn.net/zlj526/article/details/41296305     (重点推荐！！！！！！！测试代码)

Java API针对集合类型排序提供了两种支持：java.util.Collections.sort(java.util.List)
java.util.Collections.sort(java.util.List, java.util.Comparator)
      第一个方法要求所排序的元素类必须实现java.lang.Comparable接口。第二个方法要求实现一个java.util.Comparator接口。注意这两者的区别，Comparable 接口的方法：public int compareTo(T o)，绝不会是Object; 只有一个参数，而Comparator接口却有两个参数：int compare(T o1, T o2)出处！！！！

通过实现Comparable接口实现个性化排序测试。

升序排列，Collection.sort(list);

降序排列Collections.sort(list, Collections.reverseOrder());

反转排序，先输出列表最后一个元素；Collections.reverse(list);  //??!!

comparable和comparato的区别：！！！！！

http://blog.csdn.net/LVXIANGAN/article/details/19630971

http://blog.csdn.net/longshengguoji/article/details/41598741

http://blog.csdn.net/zolalad/article/details/17070247

在对集合元素进行比较时一般使用TreeSet.对于简单的数据类型，TreeSet可以直接进行比较。但是对于复杂的数据类型，比如自己定义的数据类型或者类，就需要自己设置比较方法与比较规则了，这时就需要使用Comparable和Comparator。 Comparable和Comparator都是用来实现集合中的排序的，只是Comparable是在集合内部定义的方法实现排序，而Comparator是在集合外部实现的排序。所以如果想对结合排序，需要在集合外定义Comparator接口的方法或在集合内部实现Comparable接口的方法。

一个类实现了Comparable接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的结合就可以直接使用sort方法排序。

Comparator是策略模式，就是在不改变对象自身，而用一种策略对象来改变它的行为，将算法和数据分离，Comparator还可以在下面两种环境下使用：

1.类在设计时没有考虑到比较问题而没有实现Comparable接口，则可以通过Comparator来实现排序而不必修改原来的类代码。

2.类设计时实现了Comparable接口，但是后面的使用者却想用一种新的比较规则对类进行比较

利用Comparator进行排序有两种方法，第一种方法是把需要排序的People对象放在List集合中，然后调用

Collection.sort(list,comparator)方法进行排序；

1. * 定义一个实现Comparator接口的类，并重载compara方法，设定比较规则 
2. * 利用Collection.sort(list,comparator)方法实现排序， 
3. * Collection.sort(list,comparator)方法的第一个参数为List类型，因此要排序的元素需要放在List集合中

第二中排序方法是直接把Comparator对象传递给TreeSet的构造器，并重载Comparator类的compara方法，指定排序规则，这种方法不需要让People类实现Comparator接口，且其代码较简洁。

1.          * 该方法不需要People实现Comparator接口 
2.         * 直接Comparator对象传递给TreeSet的构造器， 
3.         * 并重载Comparator类的compara方法，指定排序规则