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升序排序。