List集合排序 sort方法

List集合排序

sort方法:

• public static void sort(List list) :将集合中元素按照默认规则排序。

• public static void sort(List list，Comparator<? super T> ) :将集合中元素按照指定规则排

序。

sort方法的重载使用1

1.字符串作为集合中的类型进行排序

public class Demo {
    public static void main(String[] args) {
        //定义一个字符串的list集合,并排序
        List<String> list = new ArrayList<>();
        list.add("123");
        list.add("213");
        list.add("abc");
        list.add("aac");
        list.add("112");
        list.add("224");
        list.add("223");
        list.add("Aac");
        System.out.println(list);
        //[123, 213, abc, aac, 112, 224, 223, Aac]

        Collections.sort(list);
        System.out.println(list);
        //[112, 123, 213, 223, 224, Aac, aac, abc]
    }
}

如果想要使用该方法进行排序，条件是：集合中的类型T必须是Comparable的子类型。

String是Comparable的子类型，所以支持排序。

字符串排序的规则：先从字符串中的第一个字符开始比较其编码的大小，按照升序排序。如果第一个相同比较第二个，如果第二个相同比较第三个.......

2.自定义类型实现排序

自定义学生类型含有年龄，名称属性，创建多个学生对象。放入List集合按照年龄升序排序。

package com.liqiliang.demo02;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Demo {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("迪丽热巴",28));
        list.add(new Student("呜呜",20));
        list.add(new Student("马尔扎",19));

        Collections.sort(list);
        System.out.println(list);
        //[Student{name='呜呜', age=20}, Student{name='马尔扎', age=19}, Student{name='迪丽热巴', age=28}]
    }
}


class Student implements Comparable<Student>{
    String name;
    int age;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Student o) {
        //如何重写方法
        //按年龄升序排序比较
        //this(当前调用方法的对象)   o(参数传入)
        //所有比较最底层的逻辑都是发生两两比较逻辑的,返回比较结果
        //只关心结果结果三种:
        //正数:   this.age - o.age    >
        //负数:   this.age - o.age    <
        //0       this   ==


//        return this.age-o.age; 升序排序
//        return o.age-this.age; 降序排序
        //按照名字字符串长度升序排序
        return this.name.length()-o.name.length();
    }
}

sort方法的重载使用2

• public static void sort(List list，Comparator<? super T> ) :将集合中元素按照指定规则排

序。

方法可以可以接收任意类型的数据，以进行排序。T没有要求

不管T是否是Comparable的子类型，都无所谓了。采用的标准是Comparator的比较标准。

int compare(T o1, T o2);

目的就是为了比较o1和o2的大小
原始的排序：o1 , o2
返回值int：只关心正负或者0
  如果返回值为负数：o1 < o2   ==> o1 o2
  如果返回值为正数：o1 > o2   ==> o2 o1
  如果返回值为0：o1 == o2   ==> o1 o2

public class Demo01 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("abc12");
        list.add("AA");
        list.add("1ab123123");
        list.add("abdsdfsd");
        list.add("Abcsdfsfsdfsdsdg");
        list.add("2bcsd");
        Collections.sort(list);
        System.out.println("list = " + list);
        //按照字符串的长度升序排序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        });
        System.out.println("list = " + list);

    }
}

区别：

Comparable：是让一个类具备比较排序的功能

Comparator：自己定义的一个比较器

注意:如果比较的属性类型是浮点型

 public int compareTo(T o); //抽象方法
//子类实现后，需要进行重写

返回值int，只关心正负或者0，不需要关系具体值
  
原始排序：this【我】  o【他】
如果要升序排序：我减他
如果要降序排序：他-我
    
如果比较的属性类型是浮点型：
    this.score = 99.9     o.score = 99.5
      if(this.score>o.score){
        return 1;
    }else if(this.score<0.score){
        return -1;
    }else{
        return 0;
    }

唯有努力，人生没有白走的路，每一步都算数