Collections.sort()学习笔记1：基础类的排序

package com.ethjava;

import java.util.*;

//对于String或Integer这些已经实现Comparable接口的类来说，
// 可以直接使用Collections.sort方法传入list参数来实现默认方式（正序）排序
// 将ArrayList存储的值按照从小到大的顺序排序---或者从大到小
public class Arraylistlianxi2 {
    public static void main(String[] args) {
        List<Integer> arrayList = new ArrayList<>();
        List<Integer> arrayList2 = new ArrayList<>();
        Random random2 = new Random();//系统采取当前时间毫秒数做种子数做到随机
        Random random = new Random(1);//1为种子数随机数，就是定值了；
        // 做为种子的数字只是随机算法的起源数字，和生成的随机数字的区间无关。
        // 相同种子数的Random对象，相同次数生成的随机数字是完全相同的
        for (int i = 0; i < 10; i++) {
            Integer x = random.nextInt(100);
            arrayList.add(x);
            Integer y = random2.nextInt(100);
            arrayList2.add(y);
        }

        System.out.println("random(1)产生的数组成的list" + arrayList);
        System.out.println("random()产生的数组成的list" + arrayList2);

        Collections.sort(arrayList);//从小到大的顺序排序
        System.out.println("random(1)产生的数组成的list排序后" + arrayList);

        Collections.sort(arrayList2);//从小到大的顺序排序
        System.out.println("random()产生的数组成的list排序后" + arrayList2);
        //第一次运行
        //random(1)产生的数组成的list[85, 88, 47, 13, 54, 4, 34, 6, 78, 48]
        //random()产生的数组成的list[98, 6, 99, 73, 59, 44, 49, 22, 62, 33]
        //random(1)产生的数组成的list排序后[4, 6, 13, 34, 47, 48, 54, 78, 85, 88]
        //random()产生的数组成的list排序后[6, 22, 33, 44, 49, 59, 62, 73, 98, 99]

        //第二次运行
        //random(1)产生的数组成的list[85, 88, 47, 13, 54, 4, 34, 6, 78, 48]
        //random()产生的数组成的list[48, 52, 83, 60, 48, 81, 7, 7, 36, 36]
        //random(1)产生的数组成的list排序后[4, 6, 13, 34, 47, 48, 54, 78, 85, 88]
        //random()产生的数组成的list排序后[7, 7, 36, 36, 48, 48, 52, 60, 81, 83]

        //从上面两次打印结果可以看出：random(seed)产生的随机数当运行次数相同时，随机数是定值。

        //默认的排序是正序，那么如何实现逆序呢，这就要使用第二种方式了，
        // 即通过实现Comparator接口的compare方法来完成自定义排序
        //方法1
        Collections.reverse(arrayList2);//逆序输出函数
        System.out.println(arrayList2);//[93, 90, 58, 28, 24, 13, 9, 7, 7, 6]
        System.out.println("yxf");

        //方法2
        Collections.sort(arrayList,new Comparator<Integer>(){
            public int compare(Integer o1,Integer o2){
                //// 返回值为int类型，大于0表示正序，小于0表示逆序
                return o2-o1;
            }
        });

        System.out.println("after sort 逆序:"+ arrayList);
        //after sort 逆序:[88, 85, 78, 54, 48, 47, 34, 13, 6, 4]
        //从输出可以看出，确实是逆序输出了

        //这里我们再写一个有关String的
         ArrayList<String> arrstr=new ArrayList<>();
         arrstr.add("ddd");
         arrstr.add("bbb");
         arrstr.add("ccc");
         System.out.println("String的List的origin order: "+arrstr);

         Collections.sort(arrstr);

         System.out.println("String after order :"+arrstr);

         //String的List的origin order: [ddd, bbb, ccc]
        //String after order :[bbb, ccc, ddd]
        //正序排序是按照字母顺序排序
        //

      //逆序排序1
       Collections.reverse(arrstr);
       System.out.println(arrstr+"yxf");
       //[ddd, ccc, bbb]yxf

        //逆序排序
        Collections.sort(arrstr,new Comparator<String>(){

            public int compare(String o1,String o2){
                return o2.compareTo(o1);//这里是两个字符串的比较
                //逆序就是后面减去前面
                //compareTo() 方法用于两种方式的比较：
                //1\字符串与对象进行比较。
                //2\按字典顺序比较两个字符串。
                //返回值是整型，它是先比较对应字符的大小(ASCII码顺序)，如果第一个字符和参数的第一个字符不等，结束比较，返回他们之间的差值

            }
        });
         System.out.println("String nixu: "+arrstr);
         //String nixu: [ddd, ccc, bbb]









        //总结
        //1、对于String或Integer这些已经实现Comparable接口的类来说，可以直接使用Collections.sort方法传入list参数来实现默认方式（正序）排序；
        //2.如果不想使用默认方式（正序）排序，可以通过Collections.sort传入第二个参数类型为Comparator来自定义排序规则；
//或者采用函数Collections.reverse(list)函数，直接进行逆序输出




    }

}

参考：

https://www.cnblogs.com/yw0219/p/7222108.html?utm_source=itdadao&utm_medium=referral

https://www.cnblogs.com/ShallByeBye/p/8419027.html

https://www.runoob.com/java/java-string-compareto.html

谢谢各位博主的贡献!