Java 排序用法总结

2019独角兽企业重金招聘Python工程师标准>>>

String实例方法compareTo

    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;
    }

由源码可以看出：

     首先取出两个字符串的长度，比较较小的长度内，两者是否相等。

          若不相等，则直接返回该位置字符的ASCII码相减后的值。

          若各位置都相等，则将两个字符串长度的差值返回。

接下来看我们的单元测试：

    @Test
    public void testString(){
        System.out.println("aaa".compareTo("AAA"));
        System.out.println("a".charAt(0)+0);
        System.out.println("A".charAt(0)+0);
    }
32
97
65

a 对应的ASCII码为97  A为65   之间相差32.

 

集合排序操作：Collections.sort

1.数字类型集合排序：

    @Test
    public void testSimpleD0(){
        List<Integer> list = new ArrayList<>(10);
        list.add(1);
        list.add(4);
        list.add(2);
        Collections.sort(list);
        System.out.println(list);
    }
[1, 2, 4]

默认是按数值的升序排序的，即小的在前面，大的在后面。

2.我们来看String类型集合默认的的排序方式：

    @Test
    public void testStringColl(){
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("A");
        list.add("s");
        list.add("S");
        list.add("sS");
        Collections.sort(list);
        System.out.println(list);
    }
[A, S, a, s, sS]

按照ASCII码升序排序的，ASCII码小的在前面。如果ASCII相同，比较长度，长度短的在前面。

3.接下来查看我们自定义的排序规则。

    @Test
    public void testSimple(){
        List<Integer> list = new ArrayList<>(10);
        list.add(1);
        list.add(4);
        list.add(2);
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
//                return o2-o1;
            }
        });
        System.out.println(list);
    }
[1, 2, 4]

数字的默认排序方式是升序排序。

自定义排序时：

• 升序：如果o1小于o2,返回一个负数;如果o1大于o2，返回一个正数;如果他们相等，则返回0;
• 降序：如果o1小于o2,返回一个正数;如果o1大于o2，返回一个负数;如果他们相等，则返回0;

4.集合的排序方式：

    @Test
    public void testObj(){
        List<Dog> list= new ArrayList<>();
        list.add(new Dog(5, "DogA"));
        list.add(new Dog(6, "DogB"));
        list.add(new Dog(7, "DogC"));
        Collections.sort(list, new Comparator<Dog>() {
            @Override
            public int compare(Dog o1, Dog o2) {
                return o1.age - o2.age;//如果o1比o2大 则 o1在后面
            }
        });
        System.out.println("给狗狗按照年龄升序："+list);//年龄越小越在前面
    }
给狗狗按照年龄升序：[Dog [age=5, name=DogA], Dog [age=6, name=DogB], Dog [age=7, name=DogC]]

对象排序规则同上。

5.实体类自己实现比较规则

public class Dog implements Comparable<Dog>{
    public int age;
    public String name;
    public Dog(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Dog [age=" + age + ", name=" + name + "]";
    }

    @Override
    public int compareTo(Dog o) {
//如果实体与入参比较 实体排前面 实体与入参比较，返回小于0的数 升序
//如果实体与入参比较 实体排后面 实体与入参比较，返回大于0的数 降序
        return this.age > o.getAge()? 1: -1;//降序
    }
}

    @Test
    public void testInner(){
        List<Dog> list= new ArrayList<>();
        list.add(new Dog(5, "DogA"));
        list.add(new Dog(7, "DogC"));
        list.add(new Dog(6, "DogB"));
        Collections.sort(list);
        System.out.println(list);
    }
[Dog [age=5, name=DogA], Dog [age=6, name=DogB], Dog [age=7, name=DogC]]

 

 

 

 

 

转载于:https://my.oschina.net/LucasZhu/blog/1589615