list排序

参考

list本身是有顺序的，list的顺序就是插入顺序（Collections.reverse(rlist)可将rlist反序）
注意* 1. 使用compareTo进行排序，比较的数据不能使用基本类型（int,double,char），必须使用它们对应的包装类型

​ 2. 使用compare或compareTo方法比较大小排序时，被比较的值不能为null，如果是null，会报空指针异常。因此使用compare方法时必须保证被比较的值不为null
3. 使用compare或compareTo方法比较大小排序时，返回-1为升序，1为降序。可参照以下解释：来源为此提问中的下面这条回答
public int compare(Object o1, Object o2)
本来的顺序就是参数的先后顺序o1、o2；
如果保持这个顺序就返回-1，交换顺序就返回1，什么都不做就返回0；
所以 升序的话 如果o1<o2，就返回-1。
其实这个方法可以想象成数字减法，compare(1,2)就是return 1-2 返回-1小于0。默认升序,因为1小于2，1应该在2前面。

(1) 对jdk类库中的包装类排序，如：Intger、String、Long等，这些类都已经重写了compare 方法。
  例如：Integer类型会比较值的大小：
    在Integer类的源码中提供了两个比较方法：compare 和 compareTo，分别如下：
    public static int compare(int x, int y) {
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }
	 public int compareTo(Integer anotherInteger) {
        return compare(this.value, anotherInteger.value);
    }
	以上两个方法可以看出，compare 方法的参数可以是 int ，compareTo 方法实际调用的就是 compare 方法，但参数为 Integer 类型。两个方式使用如下：
        int a = 10;
		int b = 20;
		int c = Integer.compare(a, b);

		Integer a = 10;
		Integer b = 20;
		int c = a.compareTo(b);
	附加题：Integer类的源码中还提供了第三个比较方法：compareUnsigned，源码如下：
         @Native public static final int   MIN_VALUE = 0x80000000;//-2^31(负的最小值)
         public static int compareUnsigned(int x, int y) {
       		 return compare(x + MIN_VALUE, y + MIN_VALUE);
   		 }
		此方法表示比较两个值转化为无符号数后的大小，无符号数指整个机器字长的全部二进制位均表示数值位，相当于数的绝对值。无符号数中0相当于int型的（-2^31），为最小值；-1相当于int型的（2^31 -1），为最大值。此处不详述，想了解的自行百度。
            
   String类型会以长度最小字符串为基准，逐一比较相同位置字符的ASCII码大小，如果都相同则比较字符串的长度。
    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;
    }  

  以Integer为例子，升序排序：
      //Integer集合，正序排序
      List<Integer> list = new ArrayList<Integer>(Arrays.asList(10, 3, 6, 1, 4, 5, 9));
      Collections.sort(list);

    降序排序:
     List<Integer> list = new ArrayList<Integer>(Arrays.asList(10, 3, 6, 1, 4, 5, 9));
      Collections.sort(list);//先排正序
      Collections.reverse(rlist);//再将rlist反序
    或：
    Collections.sort(rlist,Collections.reverseOrder());//直接对rlist排倒序

（2）list中的元素为引用对象，需要自定义排序
  如：有一个User对象，属性包括id、name   rlist<User>
    升序排序：
      //使用Collections中的sort方法
      Collections.sort(rlist,((r1,r2) -> r1.getId().compareTo(r2.getId())));
 注意*  //使用compareTo进行排序，比较的数据不能使用基本类型（int,double,char），必须使用它们对应的包装类型
如果是基本类型，如int类型，可使用如下方式排序
      Collections.sort(rlist,((r1,r2) -> r1.getId() - (r2.getId())));//直接做减法，数字类型均可使用此方法，包括int和Integer（如果是Integer，不能为null）

      //使用list中的sort方法
      rlist.sort((r1,r2) -> r1.getId().compareTo(r2.getId()));
同理，也可如下使用
      rlist.sort((r1,r2) -> r1.getId() - (r2.getId()));
    降序排序：最简单的方法：将上述lambda表达式中的r1与r2位置互换即可
      或使用如下方法
      //使用Collections中的Collections.reverseOrder()方法
      Collections.sort(rlist,Collections.reverseOrder((r1,r2) -> r1.getId().compareTo(r2.getId())));
      //对rlist正序排序之后，在对rlist使用反序方法
      rlist.sort((r1,r2) -> r1.getId().compareTo(r2.getId()));Collections.reverse(rlist);
        以上方式等同于 rlist.sort((r1,r2) -> r2.getId().compareTo(r1.getId()));

[^]: