Java-小技巧-006 List 排序 Collections.sort()

一、数组操作类：Arrays

最早开始使用，查看方法
二分查找：public static int binarySearch(数据类型[] a, 数据类型 key)
　　前提是有序的
　　equals
　　先排序
　　fill
　　sort:直接针对对象数据进行排序
　　toString（数据类型【】 a）

二、两种比较器的使用：

　　Comparable接口、Comparator接口

2.1、Comparable【核心】

方法：public static void sort(Object【】a)

　　此方法可以直接对对向数据数组进行排序，并不是意味着直接调用此方法即可，java.lang.ClassCastException: com.lhx.thread.impl.Person1 cannot be cast to java.lang.Comparable

　　需要解决对象大小关系问题，然而对象无法区分出大小关系，Java会自动在排序的时候将所有的对象强制转换为Comparable接口

　　要想实现对象数组的排序，那么对象所在的类一定要实现Comparable接口　　

public interface Comparable<T> { 
    public int compareTo(T o);
}

　　

　　String中的CompareTo方法本身就是覆写了Comparable接口中的compareTo(),需要排序返回三个值即可 -1、0、1
示例：

class Person1 implements Comparable<Person1> {
    @Override
    public int compareTo(Person1 o) {
        if(this.age>o.age)
            return 1; //升序 -1 降序 
        else if (this.age<o.age)
            return -1;
        return 0;
    }
}
Arrays.sort(per);        

代码简化

class Person1 implements Comparable<Person1> {
    @Override
    public int compareTo(Person1 o) {
        return this.age-o.age； //正负数即可
    }
}
Arrays.sort(per);

2.2、Comparator挽救的比较器

要想对对象进行排序，那么就要实现Comparable接口，但是有一种情况，一个类原本定义完成了，后期确需要追加排序，并且这个类已经不能修改了。那么这种情况下使用java.util.Compartor

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
    boolean equals(Object obj);
}

使用Arrays的public static <T> void sort(T[] a, Comparator<? super T> c) 

示例：

class Person3 {
    private String name;
    private int age;
    public Person3(String name , int age){
        this.name=name;
        this.age=age;
    }
    //setter,getter
    @Override
    public String toString() {
        return "Person3 [name=" + name + ", age=" + age + "]";
    }    
}
class PersonComparator implements Comparator<Person3> {
    @Override
    public int compare(Person3 o1, Person3 o2) {
        return o1.getAge()-o2.getAge();
    }
}

public class TestArrays2 {

    @Test
    public void testMath() {
        // Person不能被改变
        Person3 per[] =new Person3[]{
            new Person3("张三1",65),
            new Person3("张三2",12),
            new Person3("张三3",16)
        };
        Arrays.sort(per,new PersonComparator());
        System.out.println(Arrays.toString(per));
    }
}    

简化写法

不用定义比较器类。直接使用时候编写

class Person3 {
    private String name;
    private int age;
    public Person3(String name , int age){
        this.name=name;
        this.age=age;
    }
    //setter,getter
    @Override
    public String toString() {
        return "Person3 [name=" + name + ", age=" + age + "]";
    }    
}
public class TestArrays2 {

    @Test
    public void testMath() {
        // Person不能被改变
        Person3 per[] =new Person3[]{
            new Person3("张三1",65),
            new Person3("张三2",12),
            new Person3("张三3",16)
        };
        Arrays.sort(per,new Comparator<Person3 >(){
                @Override
                    public int compare(Person3 o1, Person3 o2) {
                        return o1.getAge()-o2.getAge();
                    }
        });
        System.out.println(Arrays.toString(per));
    }
}

请解释两种比较器的区别

1.对象排序过程中有两个Comparable和Comparator
2.java.lang.Comparable是在类定义的时候实现好的接口，使用compareTo
3.java.util.Comparator:需要顶一个排序比较规则类，里面有两个方法compare、equals
开发中优先考虑使用Comparable。

如果要按照升序排序，
则o1 小于o2，返回-1（负数），相等返回0，01大于02返回1（正数）
如果要按照降序排序
 则o1 小于o2，返回1（正数），相等返回0，01大于02返回-1（负数）

示例一、字符串集合排序

    public static void main(String args[]){
        List<String> list = new ArrayList<>();
        list.add("51003");
        list.add("510020");
        list.add("");
        list.add(null);
        list.add("510060");
        Collections.sort(list,new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                if(o1 == null || o2 == null){
                    return -1;
                }
                if(o1.length() > o2.length()){
                    return 1;
                }
                if(o1.length() < o2.length()){
                    return -1;
                }
                if(o1.compareTo(o2) > 0){
                    return 1;
                }
                if(o1.compareTo(o2) < 0){
                    return -1;
                }
                if(o1.compareTo(o2) == 0){
                    return 0;
                }
                return 0;
            }
        });
        for(String s:list){
            System.out.println(s);
        }
    }

实例二、JSONArray中嵌套JSONObject, 对JSONArray进行排序

排序前：

[{"id":1,"name":"ljw"},{"id":3,"name":"ljw"},{"id":2,"name":"ljw"}]

排序后：

[{"id":1,"name":"ljw"},{"id":2,"name":"ljw"},{"id":3,"name":"ljw"}]

利用Collections.sort()

JSONObject o1 = JSONObject.parseObject("{"id":1,"name":"ljw"}");
JSONObject o2 = JSONObject.parseObject("{"id":3,"name":"ljw"}");
JSONObject o3 = JSONObject.parseObject("{"id":2,"name":"ljw"}");
JSONArray a = new JSONArray();
a.add(o1);
a.add(o2);
a.add(o3);
//转list 1
List<JSONObject> list = JSONArray.parseArray(a.toJSONString(), JSONObject.class);
//转list 2
//List<JSONObject> list = new ArrayList<JSONObject>();
//for (int i = 0; i < a.size(); i++) {
//    list.add((JSONObject) a.get(i));
//}
System.out.println("排序前："+a);
Collections.sort(list, new Comparator<JSONObject>() {
    @Override
    public int compare(JSONObject o1, JSONObject o2) {
        int a = o1.getInteger("id");
        int b = o2.getInteger("id");
        if (a > b) {
            return 1;
        } else if(a == b) {
            return 0;
        } else
            return -1;
        }
});
JSONArray jsonArray = JSONArray.parseArray(list.toString());
System.out.println("排序后：" + jsonArray);