如何使用Arrays.sort()对任意类型的数据进行排序？

最新推荐文章于 2024-07-22 08:37:45 发布
最新推荐文章于 2024-07-22 08:37:45 发布
阅读量7.1k 收藏 39
点赞数 16
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Forlogen/article/details/106085173
版权

前段时间看到一篇关于Arrays.sort()基本原理和使用的解读，正好之前自己也想总结一下关于Java中和排序相关的一些内容，不限于Arrays.sort()、ArrayList.sort()以及Comparator和Comparable接口。在本文中将介绍Arrays中各种重载的sort()，以及解释如何使用Arrays.sort()对任意类型的数据进行排序，这其中又涉及到Comparable接口和Comparator类的相关内容，最后在对比看一下ArrayList中的sort()。

文章目录

1. 引入

如果现在有一个包含具体类型数据元素的数组，如何对数组中的元素进行排序呢？当然我们需要根据不同的数据类型确定具体的排序规则，如果是int型等数值类型，那么可以根据元素的大小进行排序；如果是String类型的数据，我们可以根据字典序进行排序；如果是自定义类型的数据，我们可以根据类中不同类型的成员变量进行排序，如根据int型的age或是String类型的name……

在确定了数据元素数据类型和排序规则的前提下，接下来就需要编写排序逻辑。如果自己手造代码，可能工作量不是很大，但能不能利用Java中已有的东西来实现排序逻辑呢？当然！下面我们就来介绍一下如何使用Arrays.sort()、ArrayList.sort()以及自定义类来实现排序。

2. Arrays.sort()

Java.utils.Arrays是Java内置的一个方便操作数组的工具类，使用其中提供的众多静态方法可以快速简便的实现有关数组的大部分要求。

浅析Java中的Arrays

根据今天讨论的主题来说，我们只关注其中各种的sort()。Arrays中提供的sort()方法如下所示：
在这里插入图片描述

从图中的方框划分可以看出，全部的sort()大致可以分为三类：

  • 针对于基本数据类型的方法sort(xxx[] a)：其中xxx表示基本的数据类型，包括byte、char、double、float、int、long和short。每个数据类型又分别有两种实现方式：

    • static void sort(xxx[] a)
    • static void sort(xxx[] a, int fromIndex, int toIndex)

  • 针对于引用类型的方法，其中的引用类型可以是String、Integer等包装类型，也可以是自定义数据类型，只不过自定义类型有进一步的要求，这个下面会说。同样有两种实现方式：

    • sort(Object[] a)
    • sort(Object[] a, int fromIndex, int toIndex)

  • 针对于泛型的方法：

    • static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)
    • static <T> void sort(T[] a, Comparator<? super T> c)

因此，如果是上面提到的基本数据类型，可以直接使用Arrays.sort()对数组中的元素进行排序：

import java.util.Arrays;

public class ArraySort {
    public static void main(String[] args) {
        int[] arr1 = new int[]{2,10,5,8,3};
        System.out.println(Arrays.toString(arr1));  // [2, 10, 5, 8, 3]

        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1)); // [2, 3, 5, 8, 10]
        System.out.println("-----------------");
    }
}

如果类似于String、Integer等对应于基本数据类型的包装类，那么可以使用第二类的sort()进行排序。

import java.util.ArrayList;
import java.util.Arrays;

public class ArraySort {
    public static void main(String[] args) {
        Integer[] arr2 = {2,10,5,8,3};
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2)); // [2, 3, 5, 8, 10]
        System.out.println("-----------------");

        String[] arr3 = new String[]{"James", "Forlogen", "Kobe"};
        Arrays.sort(arr3);
        System.out.println(Arrays.toString(arr3));  // [Forlogen, James, Kobe]
        System.out.println("-----------------");
    }
}

对于自定义的数据类型来说，参数列表中有Comparator<? super T> c>这个参数，而它是除了Arrays中对于已支持类型之外，其他类型使用sort()方法的关键。为什么需要在参数列表中传递Comparator，它起到了什么作用，接下来来具体看一下。

3. 自定义类型使用集合类中的sort()

对于自定义类型的数据来说，如果直接将保存数据的自定义类型数据的数组传入Arrays.sort()，那么程序将会抛出ClassCastException异常

Exception in thread "main" java.lang.ClassCastException: collections.Student cannot be cast to java.lang.Comparable

异常信息提示我们说，自定义的Student类无法转换为Comparable。至于其中涉及的泛型知识以及泛型中关于限定类型的东西，不了解的可以自行查阅下相关资料较好。这里就引出了对自定义类型数据使用Arrays.sort()的一个实现路径： 自定义类要实现Camparable接口，从重写其中的CompareTo()，重写的方法中定义自己的排序逻辑 。

首先看一下定义的Student类为什么出现异常的原因，类的定义如下：

public class Student{

    private int age;
    private String name;

    public Student() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

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

如果按照前面说明的方式来实现Comparable接口，并重写CompareTo()，定义如下：

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

    public Student() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

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

    @Override
    public int compareTo(Student o) {
        // 降序为 o.getAge() - this.getAge()
        return this.getAge() - o.getAge();
    }
}

然后我们再来看一下之前的代码能否正常进行排序，输出如下：

Student{age=6, name='James'}
Student{age=10, name='Forlgoen'}
Student{age=20, name='Kobe'}

从输出结果中可以看出，数组已经实现了按照age升序排列，说明方法是可行的。

另一种方式是实现自定义的Comparator，并重写其中的Compare()，同样需要在重写方法中定义排序的规则。然后将定义好的Comparator作为static <T> void sort(T[] a, Comparator<? super T> c)方法中的参数传入，从而实现使用Arrays.sort()对自定义类型数据进行排序。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;

public class ArraySort {
    public static void main(String[] args) {
        Student[] s = new Student[]{new Student(10, "Forlgoen"),
                new Student(6, "James"),  new Student(20, "Kobe")};

        Arrays.sort(s, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 降序为 o2.getAge() - o1.getAge()
                return o1.getAge() - o2.getAge();
            }
        });
        for (Student student : s) {
            System.out.println(student);
        }
        System.out.println("-----------------");
        /*
        Student{age=6, name='James'}
        Student{age=10, name='Forlgoen'}
        Student{age=20, name='Kobe'}
         */
    }
}

输出结果和第一种方法是一样的，同样实现了按age进行升序排列。

既然包装类和自定义类同属于引用类型，那么包含包装类型数据的数组为什么能直接使用Arrays.sort()呢？我们看一下Integer的实现源码：首先它实现了Comparable接口

public final class Integer extends Number implements Comparable<Integer> {
	...
}

我们继续在类中找一下看有没有CompareTo()，发现它果然也重写了CompareTo()

public int compareTo(Integer anotherInteger) {
	return compare(this.value, anotherInteger.value);
}

而CompareTo()的实现中又调用了compare()

public static int compare(int x, int y) {
	return (x < y) ? -1 : ((x == y) ? 0 : 1);
}

从代码中可以看出，compare()根据x和y的大小关系分别返回-1、0和1。

然后我们再看一下上面使用的String的实现源码：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
	...
}

可以看到它同样实现了 Comparable接口。然后我们再找一下重写的CompareTo()：

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;
}

从实现代码中可以看出，它确实是按照字符串中字符的字典序进行的排序。其他的类型同理，可能CompareTo()的实现逻辑有所区别，有兴趣的可以再详看其他类的实现源码。

4. ArrayList.sort()

ArrayList中同样提供了关于排序的实现方法：void sort(Comparator<? super E> c)，方法的参数列表同样需要传入一个Comparator，它的实现逻辑和上面Comparator的实现是相同的。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;

public class ArraySort {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "James", "Forlogen", "Kobe");
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        });
        list.forEach(k-> System.out.println(k));
        System.out.println("-----------------");
        Iterator<String> iter = list.iterator();
        while (iter.hasNext()){
            System.out.println(iter.next());
        }
        System.out.println("-----------------");
        /*
        Kobe
        James
        Forlogen
         */
    }
}

从排序后的结果中可以看出，Comparator中的Compare()实现了按照名字的长度进行升序排列。

5. 总结

从上面分析的内容中可以看出，如果对于除基本数据类型的数据使用Arrays.sort()或ArrayList.sort()进行排序时，有两种使用方式：

  • 自定义类要实现Camparable接口，从重写其中的CompareTo()，重写的方法中定义自己的排序逻辑
  • 实现自定义的Comparator，并重写其中的Compare()，同样需要在重写方法中定义排序的规则，然后将其作为方法的参数传入

另外，在代码实现中我们还随便复习了一下有关集合类的遍历的三种方法：

  • 使用for-each进行遍历

    for (Student student : s) {
    System.out.println(student);
}

  • 使用Iterator进行遍历

    Iterator<String> iter = list.iterator();
while (iter.hasNext()){
    System.out.println(iter.next());
}

  • 使用forEach()进行遍历

    list.forEach(k-> System.out.println(k));

6. 完整测试代码

import java.util.*;

public class ArraySort {
    public static void main(String[] args) {
        int[] arr1 = new int[]{2,10,5,8,3};
        System.out.println(Arrays.toString(arr1));  // [2, 10, 5, 8, 3]

        Arrays.sort(arr1);
        System.out.println(Arrays.toString(arr1)); // [2, 3, 5, 8, 10]
        System.out.println("-----------------");

        Integer[] arr2 = {2,10,5,8,3};
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2)); // [2, 3, 5, 8, 10]
        System.out.println("-----------------");

        String[] arr3 = new String[]{"James", "Forlogen", "Kobe"};
        Arrays.sort(arr3);
        System.out.println(Arrays.toString(arr3));  // [Forlogen, James, Kobe]
        System.out.println("-----------------");

        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "James", "Forlogen", "Kobe");
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        });
        list.forEach(k-> System.out.println(k));
        System.out.println("-----------------");
        Iterator<String> iter = list.iterator();
        while (iter.hasNext()){
            System.out.println(iter.next());
        }
        System.out.println("-----------------");
        /*
        Kobe
        James
        Forlogen
         */

        Student[] s = new Student[]{new Student(10, "Forlgoen"),
                new Student(6, "James"),  new Student(20, "Kobe")};
        new ArrayList<Student>(Arrays.asList(s)).forEach(k-> System.out.println(k));
        System.out.println("-----------------");

        Arrays.sort(s);
        for (Student student : s) {
            System.out.println(student);
        }
        System.out.println("-----------------");
        /*
        Exception in thread "main" java.lang.ClassCastException: collections.Student cannot be cast to java.lang.Comparable
        at java.util.ComparableTimSort.countRunAndMakeAscending(ComparableTimSort.java:320)
        at java.util.ComparableTimSort.sort(ComparableTimSort.java:188)
        at java.util.Arrays.sort(Arrays.java:1246)
        at collections.ArraySort.main(ArraySort.java:35)
         */

        Arrays.sort(s, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return o1.getAge() - o2.getAge();
            }
        });
        for (Student student : s) {
            System.out.println(student);
        }
        System.out.println("-----------------");
        /*
        Student{age=6, name='James'}
        Student{age=10, name='Forlgoen'}
        Student{age=20, name='Kobe'}
         */
    }
}
Forlogen
关注
专栏目录
Arrays类的sort方法对数组的升序和降序
adolph_1的博客
03-31 6737
Arrays类在java.util包下，使用时需要导包。Arrays的sort方法可以直接对数据进行升序和降序排列。本人小白，前段时间刚学到sort方法时，看到Arrays操作数组只能升序，使用了很多奇怪的办法来进行降序。例如： import java.util.Arrays; public class ArraysDemo { public static void main(Stri...
Arrays.sort()自定义比较函数
liuqinhou的博客
07-19 1046
数组排序
【Java】Java数组排序详解：全面掌握Arrays.sort()的几种用法
最新发布
科技改变人类，技术成就未来
07-22 1864
在 Java 开发中，java.util.Arrays 类提供了许多实用工具，用于操作数组。其中，Arrays.sort() 方法是对数组进行排序的常用方法。本文将详细介绍 Arrays.sort() 的不同用法，包括基本类型数组、对象数组、多维数组和自定义比较器的排序。
Java Arrays类进行数组排序
weixin_34406086的博客
07-03 498
　　排序算法，基本的高级语言都有一些提供。C语言有qsort()函数，C++有sort()函数，java语言有Arrays类(不是Array)。用这些排序时，都可以写自己的排序规则。 　　Java API对Arrays类的说明是：此类包含用来操作数组（比如排序和搜索）的各种方法。 1.对基本数据类型的数组的排序 　　　说明：(1)Arrays类中的sort()使用的是“经过调优的快速排序法”...
java数组排序Arrays.sort（）
zhjtzwx的博客
08-31 1776
1、Arrays.sort(int[] a) 这种形式是对一个数组的所有元素进行排序，并且是按从小到大的顺序。 举例如下 import java.util.Arrays; public class Main { public static void main(String[] args) { int[] a = {9, 8, 7, 2, 3, 4, 1...
任意类型排序
weixin_33991727的博客
05-02 127
模拟qsort（）函数，实现任意类型排序：qsort（）简介：原型：voidqsort(void*base,size_tnum,size_twidth,int(__cdecl*compare)(constvoid*elem1,constvoid*elem2)base:要排序的的数组的首地址num:要排序的元素的个数width:元素所占的字...
Go语言：使用sort包对任意类型元素的集合进行排序
books1958的专栏
04-15 5282
使用sort包的函数进行排序时，
使用java.util.Arrays.sort方法可以对哪些类型的数组进行排序？此排序方法是否创建新数组
05-05
使用java.util.Arrays.sort方法可以对任意类型的数组进行排序，包括基本数据类型和引用类型。但是，对于自定义的类型或者复杂的对象，需要实现Comparable接口或者传入比较器Comparator来进行排序。 在Arrays.sort...
arrays.sort()自定义排序
09-12
Arrays.sort()方法可以使用自定义排序规则来对数组进行排序。可以通过实现Comparator接口来定义自己的排序规则，然后将其作为参数传递给Arrays.sort()方法。Comparator接口中有一个compare()方法，用于比较两个对象...
collections.sort和Arrays.sort之间的区别
05-23
Arrays.sort方法则是对原始数据类型进行排序的，它使用快速排序或双轴快速排序来实现排序。 3. 排序稳定性不同： Collections.sort方法是稳定的，即如果两个元素相等，它们在排序后的相对位置不会改变。 Arrays....
Arrays.sort
05-11
它可以对任意类型的数组进行排序，包括基本数据类型和对象类型。对于对象类型，需要实现 Comparable 接口或者传入一个 Comparator 对象来进行比较排序。 Arrays.sort 方法有多个重载形式，最常用的是对数组进行升序...
Arrays.sort()如何使用
07-15
Arrays.sort()方法可以使用自定义排序规则来对数组进行排序。可以通过实现Comparator接口来定义自己的排序规则，然后将其作为参数传递给Arrays.sort()方法。Comparator接口中有一个compare()方法，用于比较两个对象...
Arrays排序
weixin_30246221的博客
03-31 128
一，数组排序 1. 数字排序 int[] intArray = new int[] { 4, 1, 3, -23 }; 　　Arrays.sort(intArray); 　　输出： [-23, 1, 3, 4] 　　2. 字符串排序，先大写后小写 String[] strArray = new String[] { "z", "a", "C" }; 　　Arrays.sor...
用Array.Sort对字符串进行排序的问题
Anders Liu (lover_P)的.NET天空
01-31 1万+
近日在用Array.Sort方法对字符串数组进行排序时遇到了一个郁闷的问题。Array.Sort要求T应该事先IComparable接口，而观察System.String类的定义，的确也实现了这个接口。看来不应该有什么问题。但请看下面的代码：using System;namespace ConsoleApplication1...{    class Program    ...{  
Arrays.sort 降序排列
热门推荐
付石头的博客
07-17 2万+
今天一个需求里需要用到降序排列，首先想到了Arrays.sort方法，但是Arrays.sort默认是升序排列， 可以使用一下方式来达到降序的需求。 Arrays.sort(a,Collections.reverseOrder()); 但是存在一个问题，Arrays.sort(a,Collections.reverseOrder())不支持基本类型(int，double，char等)，如果是in...
Array - 顺序排序
csdn_ygy的博客
04-23 407
最近有一位java入门级朋友问了我冒泡排序，在这里，我将数组中最常见的几种简单排序作出简要分析，代码已写为通用类形式，希望对刚入门的同学能有所帮助。 //冒泡排序，每次相邻比较，大值向右移，即先确定最大值 public static<T extends Object & Comparable<? super T>> void bubble_Sort(T [] arr){
包含int元素的数组如何进行使用Arrays.sort()进行降序排序
StephanieXYM的博客
06-12 1075
因为使用Arrays.sort(a, Collections.reverseOrder());会导致报错"the method sort(int[]) in the type arrays is not applicable for the arguments (int[], collections.reverseorder())" 那么包含int元素的数组如何进行使用Arrays.sort()进行降序排序呢？
Java基础——Arrays类的排序方法
weixin_61275790的博客
04-06 1468
public static void sort(类型[] a, Comparator
通过Arrays.sort()方法对数组进行排序
qq_36138652的博客
07-23 5962
一、Arrays.sort()方法是一种快速排序方法，它合适用于元素少于47个数的排序,具体排序可以参考下面的代码。 二、它可以用于数组的从小到大也可以用于数组的从大到小进行排序，下面讲解一下四种排序的方法。 a) 从小到大排序Arrays.sort(num)。 Integer[] arr = new Integer[]{3,60,2,1,4,55,6,8,47,2,3,5}; Ar...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值