您的位置:88bifa必发唯一官网 > 八八必发娱乐 > 首先使用基本类型(此处使用Integer)来演示第一

首先使用基本类型(此处使用Integer)来演示第一

发布时间:2019-05-20 22:01编辑:八八必发娱乐浏览(179)

        private static void sortEmpByDefaultMode()
        {
            System.out.println("before sort:");
            PrintUtil.showList(empList);
            System.out.println("=========================");
            Collections.sort(empList);
            System.out.println("after sort:");
            PrintUtil.showList(empList);
        }
    
        private static void sortBaseTypeByIDefineMode() {
            System.out.println("before sort:");
            PrintUtil.showList(intList);
            System.out.println("=========================");
            Collections.sort(intList,new Comparator<Integer>() {
    
                @Override
                public int compare(Integer o1, Integer o2) {
                    // 返回值为int类型,大于0表示正序,小于0表示逆序
                    return o2-o1;
                }
            });
            System.out.println("after sort:");
            PrintUtil.showList(intList);
        }
    

    图片 1

    图片 2

    图片 3

    Collections是一个工具类,sort是其中的静态方法,是用来对List类型进行排序的,它有两种参数形式:

    首先使用基本类型(此处使用Integer)来演示第一个方法:

    图片 4

    使用Collections.sor方法的第一种形式实现:

    图片 5

    public class Emp implements Comparable<Emp>{
    
        /*属性、getter/setter方法、toString方法及构造方法略*/
        @Override
        public int compareTo(Emp emp) {
            /*按员工编号正序排序*/
            //return this.getEmpno()-emp.getEmpno();
            /*按员工编号逆序排序*/
            //return emp.getEmpno()-this.getEmpno();
            /*按员工姓名正序排序*/
            //return this.getEname().compareTo(emp.getEname());
            /*按员工姓名逆序排序*/
            return emp.getEname().compareTo(this.getEname());
        }
    }    
    

    可以看到,默认的排序是正序,那么如何实现逆序呢,这就要使用第二种方式了,即通过实现Comparator接口的compare方法来完成自定义排序,代码如下:

    根据不同的排序方式即可呈现不同的结果。

        private static void sortEmpByIDefineMode()
        {
            System.out.println("before sort:");
            PrintUtil.showList(empList);
            System.out.println("=========================");
            Comparator<Emp> comparator = new Comparator<Emp>() {
    
                @Override
                public int compare(Emp o1, Emp o2) {
                    /*按员工编号正序排序*/
                    return o1.getEmpno()-o2.getEmpno();
                    /*按员工编号逆序排序*/
                    //return o2.getEmpno()-o1.getEmpno();
                    /*按员工姓名正序排序*/
                    //return o1.getEname().compareTo(o2.getEname());
                    /*按员工姓名逆序排序*/
                    //return o2.getEname().compareTo(o1.getEname());
                }
    
            };
    
            /*新的逆序实现方式*/
            Collections.sort(empList,comparator.reversed());
            System.out.println("after sort:");
            PrintUtil.showList(empList);
        }
    

    图片 6

    图片 7

    1.对于String或Integer这些已经实现Comparable接口的类来说,可以直接使用Collections.sort方法传入list参数来实现默认方式(正序)排序;

    图片 8

    图片 9

    总结:

      定义泛型违Emp类型的List:

    图片 10

    图片 11

    图片 12

    The method sort(List<T>) in the type Collections is not applicable for the arguments (List<Emp>)

    private static void sortBaseTypeByDefaultMode() {
            System.out.println("before sort:");
            PrintUtil.showList(intList);
            System.out.println("=========================");
            Collections.sort(intList);
            System.out.println("after sort:");
            PrintUtil.showList(intList);
        }
    
        public static <T extends Comparable<? super T>> void sort(List<T> list) {
            list.sort(null);
        }
    

    接下来看看第一种形式的实现,首先让Emp类继承Comparable接口并重写compareTo方法(为了和上面的排序方式区别开,此次按照员工姓名逆序排列):

    图片 13

        static List<Integer> intList = Arrays.asList(2, 3, 1);
    

     

     

     

    public class Emp{
        private int empno;
        private String ename;
        public int getEmpno() {
            return empno;
        }
        public void setEmpno(int empno) {
            this.empno = empno;
        }
        public String getEname() {
            return ename;
        }
        public void setEname(String ename) {
            this.ename = ename;
        }
    
        public Emp(int empno, String ename) {
            super();
            this.empno = empno;
            this.ename = ename;
        }
        @Override
        public String toString()
        {
            return "empno:t" empno "tename:t" ename;
        }
    }
    

    图片 14

    图片 15

    首先使用基本类型(此处使用Integer)来演示第一个方法。3.对于自定义类型(如本例子中的Emp),如果想使用Collections.sort的方式一进行排序,可以通过实现Comparable接口的compareTo方法来进行,如果不实现,则参考第2点;

    图片 16

    图片 17

    图片 18

     

    接下来看看自定义类的排序:

    图片 19

    运行结果:

    此时会报错:

    图片 20

    可以看到,已经实现了逆序的排序了。

        private static void sortEmpByIDefineMode()
        {
            System.out.println("before sort:");
            PrintUtil.showList(empList);
            System.out.println("=========================");
            Collections.sort(empList,new Comparator<Emp>() {
    
                @Override
                public int compare(Emp o1, Emp o2) {
                    /*按员工编号正序排序*/
                    return o1.getEmpno()-o2.getEmpno();
                    /*按员工编号逆序排序*/
                    //return o2.getEmpno()-o1.getEmpno();
                    /*按员工姓名正序排序*/
                    //return o1.getEname().compareTo(o2.getEname());
                    /*按员工姓名逆序排序*/
                    //return o2.getEname().compareTo(o1.getEname());
                }
            });
            System.out.println("after sort:");
            PrintUtil.showList(empList);
        }
    

    意思是参数类型为List<Emp>时,sort方法无法执行,原因是泛型没有继承Comparable接口,这种方式稍后再说,我们先使用sort方法的第二种形式:

    2.如果不想使用默认方式(正序)排序,可以通过Collections.sort传入第二个参数类型为Comparator来自定义排序规则;

        static List<Emp> empList;
        static 
        {
            Emp emp1 = new Emp(2,"Guan YunChang");
            Emp emp2 = new Emp(3,"Zhang Fei");
            Emp emp3 = new Emp(1,"Liu Bei");
            empList = Arrays.asList(emp1,emp2,emp3);
        }
    

     

    图片 21

    图片 22

    首先使用同样的方式来使用Collections.sort方法:

    运行结果: 

    对empList进行排序:

    4.jdk1.8的Comparator接口有很多新增方法,其中有个reversed()方法比较实用,是用来切换正序和逆序的,代码如下:

        public static <T> void sort(List<T> list, Comparator<? super T> c) {
            list.sort(c);
        }
    

    定义一个Emp类:

    图片 23

    PrintUtil.showList是自定义的一个打印List类型的方法,此处只关心输出结果就行,如下:

    图片 24

    本文由88bifa必发唯一官网发布于八八必发娱乐,转载请注明出处:首先使用基本类型(此处使用Integer)来演示第一

    关键词: 八八必发娱乐

上一篇:没有了

下一篇:没有了