java学习-排序及加密签名时数据排序方式

Posted 2021-01-29 海绵般汲取

排序有两种，

基本数据类型的包装类Integer, Float, Double,Long,Byte等都实现的Comparable接口，用于列表List或数组arrays的排序

Comparable<Integer>接口方法的实现，对象列表的升序降序接口

我们通过重写改接口方法，可以对列表进行升序或降序排列。

public int compareTo(T o);

This interface imposes a total ordering on the objects of each class that implements it. This ordering is referred to as the class‘s natural ordering, and the class‘s compareTo method is referred to as its natural comparison method.

此接口对实现它的每个类的对象强加一个默认排序。这种排序被称为类的自然排序，类的compareTo方法被称为其自然比较方法。

Lists (and arrays) of objects that implement this interface can be sorted automatically by Collections.sort (and Arrays.sort).  

只有实现的这个接口的对象list列表或array数组才可以使用sort方法让列表或数组的元素被自动排序

 

只需要实现compareTo()方法即可

public int compareTo(){}这个比较方法，，
如果要将对象列表进行升序排序，则第i个元素和第i+1元素  要满足a[i]>a[i+1]  返回1   a[i]<a[i+1] 返回-1   a[i]=a[i+1]   返回0

如果要将对象列表进行降序排序　　要满足 a[i]>a[i+1] 返回-1   a[i]<a[i+1] 返回1 a[i]=a[i+1] 返回0

Collections.sort方法实现的就是按照此比较的东西排列
升序（从小到大）：
if(price < o.price){
    return -1;
}
if(price > o.price){
   return 1;
}
降序（从大到小）：
if(price < o.price){
   return 1;
}
if(price > o.price){
   return -1;
}

    //将对象按价格进行升序排序
    @Override
    public int compareTo(flower o) {
        //首先比较price，如果price相同返回0
        if(price < o.price){
            return -1;
        }
        if(price > o.price){
            return 1;
        }
        
        return 0;
    }

 

为什么升序  返回值为1时，是n的值要大于n+1的值，而返回值为-1时n的值要小于n+1呢？

这个要查看源码才可以知道原理。(不好奇的可以不看哦^~^)

 

由于这个List.sort（）这个排序方法时使用二分排序，源码如下，

private static void binarySort(Object[] a, int lo, int hi, int start) {
        assert lo <= start && start <= hi;
        if (start == lo)
            start++;
        for ( ; start < hi; start++) {
            Comparable pivot = (Comparable) a[start];

            // Set left (and right) to the index where a[start] (pivot) belongs
            int left = lo;
            int right = start;
            assert left <= right;
            /*
             * Invariants:
             *   pivot >= all in [lo, left).
             *   pivot <  all in [right, start).
             */
            while (left < right) {
                int mid = (left + right) >>> 1;
                if (pivot.compareTo(a[mid]) < 0)
                    right = mid;
                else
                    left = mid + 1;
            }
            assert left == right;

            /*
             * The invariants still hold: pivot >= all in [lo, left) and
             * pivot < all in [left, start), so pivot belongs at left.  Note
             * that if there are elements equal to pivot, left points to the
             * first slot after them -- that‘s why this sort is stable.
             * Slide elements over to make room for pivot.
             */
            int n = start - left;  // The number of elements to move
            // Switch is just an optimization for arraycopy in default case
            switch (n) {
                case 2:  a[left + 2] = a[left + 1];
                case 1:  a[left + 1] = a[left];
                         break;
                default: System.arraycopy(a, left, a, left + 1, n);
            }
            a[left] = pivot;
        }
    }

            while (left < right) {
                int mid = (left + right) >>> 1;
                if (pivot.compareTo(a[mid]) < 0)
                    right = mid;
                else
                    left = mid + 1;
            }

这个值是和已排序的数据的中间的数据进行比较，provot.compareTo（a[mid]）

注意看，上面的a[mid]是作为比较方法的参数。

当小于0，也就是值为-1时，是我们要插入的数据作为调用方，

 

小于0时，该数据插入到前面，

大于0时，数据插入到后面

 

思维惯性以为升序就是第一个元素比第二个元素小。obj1.compareTo(Object obj2)

即obj1=2是第一个元素，obj2=8是第二个元素

那么我们升序时，如果obj1小于obj2，返回值为-1，则会将obj2插入到obj1前面，，排序前【2， 8】这样排序完后却变成了，，【8, 2】

这跟我们想要的升序数据不一样，

 

原因是java的二分法进行比较了是，，obj2.compareTo(obj1),,与我们想的刚好相反，

所以我们返回的值取反就可以变成升序了，

 

如这个消费类，,只给出部分代码

public class ConsumInfo implements Comparable<ConsumInfo> {
    public double price;
　　 public String name;
　　public Consuminfo(double price, String name){
　　 this.price = price;
　　 this.name = name;
　　}

   @Override
    public int compareTo(ConsumInfo o) {
        //首先比较price，如果price相同
        if(price < o.price){
            return -1;
        }
        if(price > o.price){
            return 1;
        }
        
        return 0;
    }


}

　　　　ConsumInfo consumInfo1 = new ConsumInfo("consumInfo1", 400.0);
       ConsumInfo consumInfo2 = new ConsumInfo("consumInfo2", 200.0);

　　　　List<ConsumInfo> list = new ArrayList<ConsumInfo>();
       list.add(consumInfo1);
       list.add(consumInfo2);

　　　　System.out.println("排序前：");
　　　　for(ConsumInfo consumInfo : list ){
            System.out.println(consumInfo);
        }

　　　　Collections.sort(list);//排序
　　　　System.out.println("排序后：");//排序后
       for(ConsumInfo consumInfo :list){
            System.out.println(consumInfo);
       }

控制台输出信息为：

排序前：
ConsumInfo [name=consumInfo1, price=400.0]
ConsumInfo [name=consumInfo2, price=200.0]
排序后：
ConsumInfo [name=consumInfo2, price=200.0]
ConsumInfo [name=consumInfo1, price=400.0]

上面是最简单的两个元素进行排序，

第一次，往已排序列表中插入第一个元素，即数组中只有一个已排好序的元素，a[0] = consumInfo1 

第二次时，left为0，right为1，进入while循环中，

mid=0，privot=consumInfo2

即consumInfo2.comparTo(a[0])

当方法的返回值小于0时，consumInfo2会插入在consumInfo1之前，

大于0时，会在consumInfo1之后

进行比较时，consumInfo2.price<consumInfo1.price    返回值小于0，也就是consumInfo1的值比较大，插入在1之前