list元素排序需要满足两个条件

关于List

　　说到list,我的印象就是单值集合接口,插入取出是有序的，允许重复，用他的实现类用的最频繁的就是ArrayList了。如果我现在有一个list，插入了一些值，想让里面的值按照我自定义的规则排序。

以下测试基于JDK1.7

①list里面是String的情况

 public static void main(String[] args) {
         List<String> listStrs = new ArrayList<String>();
         listStrs.add("aba");
         listStrs.add("aba2111");
         listStrs.add("aba22");
         for (String s : listStrs) {
             System.out.println(s);
         }

                 Collections.sort(listStrs);  //排序操作

                 System.out.println("操作后");
         for (String s : listStrs) {
             System.out.println(s);
         }
 }
 console:
 aba
 aba2111
 aba22
 操作后
 aba
 aba2111
 aba22

从打印结果可以看出，collections.sort(listStrs);是排序了的，看下sort方法的源码

 public static <T extends Comparable<? super T>> void sort(List<T> list) {
         Object[] a = list.toArray();
         Arrays.sort(a);
         ListIterator<T> i = list.listIterator();
         for (int j=0; j<a.length; j++) {
             i.next();
             i.set((T)a[j]);
         }
     }

实际上就是把list转成数组，再执行Arrays.sort(a); sort源码就不看了，我简单跟了一下，实际上它是调用了ComparableTimSort.sort方法，继续跟下去最终会把数组a 转换成 Comparable接口：Comparable<Object> pivot = (Comparable) a[start];，到这里就可以解释为什么String类实现了Comparable接口；

下面是跟踪Arrays.sort(a)的源码

接下来看看String实现了Comparable接口，是怎么实现它里面唯一的方法的

 public int compareTo(String anotherString) {
         int len1 = value.length;
         int len2 = anotherString.value.length;
         int lim = Math.min(len1, len2);
         char v1[] = value;
         char v2[] = anotherString.value;

         int k = 0;
         while (k < lim) {
             char c1 = v1[k];
             char c2 = v2[k];
             if (c1 != c2) {
                 return c1 - c2;
             }
             k++;
         }
         return len1 - len2;
     }

这个方法就是定义了排序的规则，返回负数则调换这两个数的顺序，返回正数和0不管，所以从代码中可以看到优先比较字符串中的字符大小，然后比较长度，这就是String的排序规则。

② list里面是普通实体类Person的情况

 public class Person{
         private String name;
         private int age;

         public Person(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;
         }
         @Override
         public String toString() {
             return "Person [name=" + name + ", age=" + age + "]";
         }

     @Test
     public void fun1() {
         List<Person> listStrs = new LinkedList<Person>();
         listStrs.add(new Person("zhangsan", 20));
         listStrs.add(new Person("lisi", 28));
         listStrs.add(new Person("wangwu", 24));
         for (Person p : listStrs) {
             System.out.println(p);
         }
         System.out.println("我排序之后:");
         Collections.sort(listStrs, new Comparator<Person>() {

             @Override
             public int compare(Person p1, Person p2) {

                 return p1.age - p2.age;
             }
         });

         for (Person p : listStrs) {
             System.out.println(p);
         }
     }

我采用的是new Comparator()的方式才定义排序规则，规则比较简单，就是按照年龄升序

也可以让Person类和String类玩一个套路，让他实现Comparable接口。

 public class Person<T> implements Comparable<T>{
         private String name;
         private int age;

         public Person(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;
         }
         @Override
         public String toString() {
             return "Person [name=" + name + ", age=" + age + "]";
         }
         @Override
         public int compareTo(T o) {
             if(o instanceof Integer) {
                 return (Integer)o - age;
             }
             if(o instanceof Person) {
                 System.out.println("是啥：" + ((Person) o).getAge() + "this是啥：" + this.getAge());
                 return this.age - ((Person) o).getAge();
             }
             return 0;
         }
     }

     @Test
     public void fun2() {
         List<Person> listStrs = new LinkedList<Person>();
         listStrs.add(new Person("zhangsan", 20));
         listStrs.add(new Person("lisi", 28));
         listStrs.add(new Person("wangwu", 24));
         for (Person p : listStrs) {
             System.out.println(p);
         }
         System.out.println("我排序之后:");
         Collections.sort(listStrs);

         for (Person p : listStrs) {
             System.out.println(p);
         }
     } 

总结：

　　1 list默认是存取是有序的。

　　2 要想让List按照自己定义的规则进行排序，需满足两点：① list中的元素实现Comparable接口，② Collections.sort(list)方法

　　2 String类实现了Comparable接口，规则是按照字符串长度和字母a-z升序排序。