Java 排序问题

算法中经常有排序,有时候很模糊,所以做如下总结
比较有3中情况
o1(前一个) vs o2(后一个)
return 1 o1>o2 交换
return 0 o1=o2
return -1 o1<o2 不交换

public class SortTest {

    public static void main(String[] args) {
        ArrayList<Integer> ints = new ArrayList<>();
        ints.add(2);
        ints.add(4);
        ints.add(1);
        ints.add(3);

        ArrayList<Integer> ints1 = new ArrayList<>(ints);
        ArrayList<Integer> ints2 = new ArrayList<>(ints);
        System.out.println("排序前 :" + ints1);
        //升序
        asc(ints1);

        System.out.println("排序前 :" + ints2);
        //降序
        desc(ints2);
    }

    //升序
    private static void asc(ArrayList<Integer> ints) {
        Collections.sort(ints, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {

                // return ascMethod1(o1,o2);
                // return ascMethod2(o1,o2);
                // return ascMethod3(o1,o2);
               
            }

            private int ascMethod1(Integer o1, Integer o2) {
                //升序
                if(o1!=o2){
                    if(o1>o2){
                        //前一个 > 后一个,需要交换  return 1
                        return o1-o2;
                    }else if(o1<o2){
                        //前一个 < 后一个,不需要交换  return -1
                        return o1-o2;
                    }
                }
                return 0;
            }

            private int ascMethod2(Integer o1, Integer o2) {
                //升序,总结 ascMethod1
                if(o1!=o2){
                    return o1-o2;
                }
                return 0;
            }

            private int ascMethod3(Integer o1, Integer o2) {
                //升序 api调用
                if(o1!=o2){
                  return Integer.compare(o1,o2);
                }
                return 0;
            }

        });
        System.out.println("升序后 :" + ints);
    }



    //降序
    private static void desc(ArrayList<Integer> ints) {
        Collections.sort(ints, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                // return descMethod1(o1, o2);
                // return descMethod2(o1, o2);
               return descMethod3(o1, o2);
            }
            
            private int descMethod1(Integer o1, Integer o2) {
                if (o1 != o2) {
                    if (o1 > o2) {
                        //前一个 大于 后一个 不用交换   return -1
                        return o2 - o1;
                    } else if (o1 < o2) {
                        //前一个 小于 后一个 交换  return 1
                        return o2-o1;
                    }
                }
                return 0;
            }

            private int descMethod2(Integer o1, Integer o2) {
                //归纳 descMethod1
                if (o1 != o2) {
                    return o2-o1;
                }
                return 0;
            }

            private int descMethod3(Integer o1, Integer o2) {
                //调用api
                if (o1 != o2) {
                    return Integer.compare(o2,o1);
                }
                return 0;
            }

        });
        System.out.println("降序后 :" + ints);
    }

输出结果
排序前 :[2, 4, 1, 3]
升序后 :[1, 2, 3, 4]
排序前 :[2, 4, 1, 3]
降序后 :[4, 3, 2, 1]

总结:
升序 前一个 大于 后一个 交换
Integer.compare(o1,o2);
降序 后一个 大于 前一个 交换
Integer.compare(o2,o1);