1、数组的排序
2、集合排序概述
- 2.1、对存放在List中的整型数据进行排序
- 2.2、对存放在List中的字符串进行排序
3、Comparator接口
- 3.1、按名字进行排序
- 3.2、按年龄降序排序
4、Comparable接口
5、对比

1、数组的排序

1.新建一个名为SortProj的Java项目，新建一个com.cxs.sort的包，然后新建一个ArraysSort类。

public class ArraysSort {
    public static void main(String[] args) {
        int[] arr = { 1, 4, -1, 5, 0 };
        Arrays.sort(arr);// 这里使用的是Arrays类，不是Array
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

2.运行代码，结果为：-1 0 1 4 5，并且为升序排列。
说明：
- (1)Arrays类中的sort()使用的是“经过调优的快速排序法”;
- (2)比如int[]，double[]，char[]等基数据类型的数组，Arrays类之只是提供了默认的升序排列，没有提供相应的降序排列方法。

2、集合排序概述

上面我们知道，数组使用的是Arrays类的sort()方法，那么集合呢？可以借助Collections类的sort()方法对List集合当中的数据进行排序。
sort(List list)：根据元素的自然顺序对指定列表按升序进行排序。【自然顺序：比如数字会按数字大小进行排序，而字符或字符串会按ASCII值进行排序】

2.1、对存放在List中的整型数据进行排序

1.在sort包下新建一个IntSort类，勾选主方法。

public class IntSort {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();// 此处的泛型写基本类型对应的包装类
        list.add(5);
        list.add(8);
        list.add(4);
        list.add(7);
        System.out.println("排序前：");
        for (int n : list) {
            System.out.print(n + " ");
        }
        System.out.println();

        Collections.sort(list);
        System.out.println("排序后：");
        for (int n : list) {
            System.out.print(n + " ");
        }
    }
}

2.运行代码结果如下。

2.2、对存放在List中的字符串进行排序

1.在sort包下新建一个StringSort类，勾选主方法。

public class StringSort {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("orange");
        list.add("tomato");
        list.add("apple");
        list.add("pear");
        System.out.println("排序前：");
        for (String s : list) {
            System.out.print(s + " ");
        }
        System.out.println();

        Collections.sort(list);
        System.out.println("排序后：");
        for (String s : list) {
            System.out.print(s + " ");
        }
    }
}

2.运行代码。

3、Comparator接口

Comparator接口是可以强行对某个对象进行整体排序的比较函数，也称之为比较器。
可以将Comparator接口作为一个参数传递给sort方法（如Collections.sort或者Arrays.sort，它们两个使用方法是相同的）。
在Comparator接口中有一个方法int compare(T o1,T o2)，比较用来排序的两个参数（该方法必须被重写）。
- 若o1<o2，则返回负整数；
- 若o1==o2，则返回0；
- 若o1>o2，则返回正整数；
接口中还有一个方法boolean equals(Object obj)，指示某个其他对象是否”等于”此Comparator（此方法可以被Object类中的equals方法覆盖，不必重写）。

1.新建一个名为com.cxs.comparator的包，在包下新建一个名为Cat的宠物猫类。

public class Cat {
    private String name;
    private int month;
    private String species;

    public Cat() {
    }

    public Cat(String name, int month, String species) {
        super();
        this.name = name;
        this.month = month;
        this.species = species;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public String getSpecies() {
        return species;
    }

    public void setSpecies(String species) {
        this.species = species;
    }

    @Override
    public String toString() {
        return "Cat [name=" + name + ", month=" + month + ", species=" + species + "]";
    }
}

3.1、按名字进行排序

2.在comparator包下新建一个NameComparator的类并实现Comparator接口，按提示重写其compare方法。

public class NameComparator implements Comparator<Cat> {
    @Override
    public int compare(Cat o1, Cat o2) {
        String n1 = o1.getName();
        String n2 = o2.getName();
        int n = n1.compareTo(n2);
        return n;
    }
}

3.新建一个类名为CatTest，勾选主方法。

public class CatTest {
    public static void main(String[] args) {
        Cat huahua = new Cat("huahua", 5, "英国短毛猫");
        Cat fanfan = new Cat("fanfan", 2, "中华田园猫");
        Cat maomao = new Cat("maomao", 3, "英国短毛猫");

        List<Cat> catList = new ArrayList<>();
        catList.add(huahua);
        catList.add(fanfan);
        catList.add(maomao);

        System.out.println("排序前：");
        for (Cat cat : catList) {
            System.out.println(cat + "  ");
        }
        System.out.println("---------------------");

        // 按名字升序排序
        Collections.sort(catList, new NameComparator());

        System.out.println("按名字升序排序后：");
        for (Cat cat : catList) {
            System.out.println(cat + "  ");
        }
    }
}

4.运行代码，结果如下。
5.那么降序（倒序）排序呢？其实只要修改一句代码即可，即修改NameComparator中的compareto方法即可。即将int n = n1.compareTo(n2);改为int n = n2.compareTo(n1);即可。此时再次运行代码，宠物猫则会按名字降序排序。图略。

3.2、按年龄降序排序

7.新建一个名为AgeComparator类，实现Comparator接口，并重写compare方法。

public class AgeComparator implements Comparator<Cat> {
    @Override
    public int compare(Cat o1, Cat o2) {
        int a1 = o1.getMonth();
        int a2 = o2.getMonth();
        return a2 - a1;
    }
}

8.在CatTest类中补充以下代码。

// 按年龄降序排序
Collections.sort(catList, new AgeComparator());
System.out.println("按年龄降序排序后：");
for (Cat cat : catList) {
    System.out.println(cat + "  ");
}

9.运行代码结果如下。若按年龄升序排序，则将compare方法中的return a2 - a1;改为return a1 - a2;

4、Comparable接口

此接口强行对实现它的每个类的对象进行整体排序（同Comparator）。
这种排序被称为自然排序，类的compareTo方法被称为它的自然比较方法。
int compareTo(T o)方法：该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数（返回值含义和前面的compare方法的返回值含义相同）。

1.在包下（这里不再新建包了）新建一个Goods类并实现Comparable接口，重写compareTo方法。

public class Goods implements Comparable<Goods> {
    private String id;
    private String name;
    private double price;

    public Goods() {
    }

    public Goods(String id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Goods [商品编号：" + id + ", 商品名称:" + name + ", 商品价格：" + price + "]";
    }

    @Override
    public int compareTo(Goods o) {
        double p1 = this.getPrice();
        double p2 = o.getPrice();
        int n = new Double(p2 - p1).intValue();
        return n;
    }
}

2.新建一个GoodsTest测试类。

public class GoodsTest {
    public static void main(String[] args) {
        Goods g1 = new Goods("001", "手机", 2099);
        Goods g2 = new Goods("002", "电视", 5000);
        Goods g3 = new Goods("003", "电视机", 3000);

        List<Goods> goodsList = new ArrayList<>();
        goodsList.add(g1);
        goodsList.add(g2);
        goodsList.add(g3);

        System.out.println("排序前：");
        for (Goods good : goodsList) {
            System.out.println(good);
        }

        Collections.sort(goodsList);

        System.out.println("按商品价格降序排序后：");
        for (Goods good : goodsList) {
            System.out.println(good);
        }
    }
}

3.结果如下图所示。

5、对比

Comparator	Comparable
位于java.util包	位于java.lang包
在要比较的类的外部实现该接口	在要比较的类上实现该接口
调用sort方法时，要指定Comparator的实现类	调用sort方法时，只需指定集合名即可

Java零基础入门笔记19-Java集合排序

1、数组的排序

2、集合排序概述

2.1、对存放在List中的整型数据进行排序

2.2、对存放在List中的字符串进行排序

3、Comparator接口

3.1、按名字进行排序

3.2、按年龄降序排序

4、Comparable接口

5、对比

猜你喜欢