Java sort()数组排序

提示信息

轻烟

10月09日发表在 Java 编程语言阅读 116 评论 20 | 免费使用 “AI大模型GPT4.0” 提问

Java提供了两种对数组进行排序的方法：Arrays.sort()和Collections.sort()。

使用Arrays.sort()方法对数组进行排序：

import java.util.Arrays;  
public class Main {  
    public static void main(String[] args) {  
        int[] arr = {5, 2, 8, 1, 9};  
        Arrays.sort(arr);  
        for (int num : arr) {  
            System.out.print(num + " ");  
        }  
    }  
}

输出结果为：1 2 5 8 9

使用Collections.sort()方法对数组进行排序（需要将数组转换为ArrayList）：

import java.util.ArrayList;  
import java.util.Arrays;  
import java.util.Collections;  
import java.util.List;  
public class Main {  
    public static void main(String[] args) {  
        Integer[] arr = {5, 2, 8, 1, 9};  
        List<Integer> list = new ArrayList<>(Arrays.asList(arr));  
        Collections.sort(list);  
        for (int num : list) {  
            System.out.print(num + " ");  
        }  
    }  
}

输出结果为：1 2 5 8 9

注意：使用Collections.sort()方法需要将数组转换为ArrayList，并且数组类型需要是包装类型（如Integer），而不是基本类型（如int）。

遇到难题？ "AI大模型GPT4.0、GPT" 是你的私人解答专家！点击按钮去提问......

轻烟赞 | 0

最近一次登录：2024-10-26 17:30:53

暂时还没有签名，请关注我或评论我的文章

20条评论

按时间正序按时间倒序按喜欢排序

黑色照片

10月17日

很好的解释了Java中数组排序的方法。

赞 0 回复举报

苏黎： @黑色照片

对于Java中的数组排序，确实有多种方法可以选择，Arrays.sort() 方法是最常用的。除了基础的排序外，还可以自定义排序规则。下面这个示例展示了如何根据数组中的元素大小进行排序：

import java.util.Arrays;

public class ArraySortExample {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 8, 1, 3};
        Arrays.sort(numbers);
        System.out.println("Sorted array: " + Arrays.toString(numbers));

        // 自定义排序示例
        Integer[] customArr = {5, 2, 8, 1, 3};
        Arrays.sort(customArr, (a, b) -> b - a); // 按降序排序
        System.out.println("Custom sorted array (descending): " + Arrays.toString(customArr));
    }
}

在这里，首先展示了如何使用Arrays.sort()对整型数组进行升序排序，然后通过Lambda表达式展示了如何实现自定义的降序排序。这种灵活性使得数组排序不再单调，能够满足多种需求。

若想更深入了解Java排序的不同方法及其底层实现，可以参考Java官方文档。

11月15日回复举报

添加新评论

梦回俊尘

10月26日

使用Arrays.sort()非常简单直接，对于基本数据类型的数组排序尤其有用。

赞 0 回复举报

旧梦╃╰： @梦回俊尘

使用 Arrays.sort() 的确是一个便利的方法，特别是当处理基本数据类型数组时。对于对象数组的排序，可以考虑使用 Collections.sort() 结合自定义比较器，这样能够更灵活地满足不同的排序需求。

例如，假设我们有一个包含用户信息的对象数组，我们可以这样进行排序：

import java.util.Arrays;
import java.util.Comparator;

class User {
    String name;
    int age;

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

public class Main {
    public static void main(String[] args) {
        User[] users = {
            new User("Alice", 30),
            new User("Bob", 25),
            new User("Charlie", 35)
        };

        Arrays.sort(users, Comparator.comparingInt(user -> user.age));

        for (User user : users) {
            System.out.println(user.name + ": " + user.age);
        }
    }
}

这个例子中，我们根据用户的年龄对 User 对象数组进行了排序。可以看到，Arrays.sort() 的灵活性能够很方便地满足不同的排序需求。

如果需要更复杂的排序逻辑，可以参考 Java 的 Comparator 文档，了解如何实现自定义排序。

11月16日回复举报

添加新评论

义无

11月04日

在需要对对象进行排序时，Collections.sort()很方便，但需要注意转换过程。

赞 0 回复举报

第三只眼： @义无

对于对象的排序，Collections.sort()确实是一个强大的工具。使用时，可以通过实现 Comparable 接口或提供 Comparator 来定义排序规则。下面是一个简单的示例，展示了如何使用 Comparator 对自定义对象进行排序：

import java.util.*;

class Person {
    String name;
    int age;

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

    public String toString() {
        return name + ": " + age;
    }
}

public class SortExample {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 30));
        people.add(new Person("Bob", 25));
        people.add(new Person("Charlie", 35));

        // 使用 Comparator 按年龄排序
        Collections.sort(people, new Comparator<Person>() {
            public int compare(Person p1, Person p2) {
                return Integer.compare(p1.age, p2.age);
            }
        });

        System.out.println(people);
    }
}

这个示例中，我们按照 Person 对象的年龄进行排序，通过创建一个匿名的 Comparator 实现来定义排序的逻辑。在处理对象排序时，确保类变量和比较逻辑的一致性将有助于避免不必要的错误。

了解更多关于 Java 中集合和排序的使用，可以参考官方文档：Java Collections Documentation。

5天前回复举报

添加新评论

阿巍

11月14日

文章很好地说明了两种方法间的区别，特别是对于初学者来说，帮助很大。

赞 0 回复举报

绿豆粥： @阿巍

有趣的是，排序在Java中确实有不同的实现方式，比如使用Arrays.sort()和Collections.sort()。对于初学者来说，理解它们的根本区别非常重要，因为前者主要用于数组，而后者则用于集合类。

值得一提的是，Arrays.sort()方法是快速排序的实现，它的时间复杂度在平均情况下为O(n log n)，适合处理基本类型和对象数组。例如：

int[] numbers = {5, 3, 8, 1, 2};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers)); // 输出：[1, 2, 3, 5, 8]

而Collections.sort()则适用于List接口的实现，例如ArrayList，它通常利用归并排序。下面是一个简单示例：

List<String> names = new ArrayList<>(Arrays.asList("John", "Alice", "Bob"));
Collections.sort(names);
System.out.println(names); // 输出：[Alice, Bob, John]

另外，值得探索的还有自定义排序的用法。可以通过实现Comparator接口来设置排序规则。例如：

List<Person> people = Arrays.asList(new Person("John", 25), new Person("Alice", 30), new Person("Bob", 20));
Collections.sort(people, Comparator.comparingInt(Person::getAge));

可以参考 Java Documentation 和 Collections.sort() 了解更多细节。

4天前回复举报

添加新评论

青春无悔

11月24日

可以补充一下使用自定义比较器的例子，帮助更好地理解Collections.sort()的扩展能力。

赞 0 回复举报

好网名： @青春无悔

可以分享一个使用自定义比较器的简单示例，这有助于了解如何通过 Collections.sort() 方法进行更灵活的排序。在Java中，使用自定义比较器时，可以创建一个实现了 Comparator 接口的类，或者使用Lambda表达式，这样代码会更简洁。

以下是一个使用Lambda表达式的示例，假设我们有一个包含学生对象的列表，我们希望根据他们的年龄进行排序：

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

class Student {
    String name;
    int age;

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

    @Override
    public String toString() {
        return name + ": " + age;
    }
}

public class Main {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("Alice", 22));
        students.add(new Student("Bob", 20));
        students.add(new Student("Charlie", 23));

        // 使用Lambda表达式进行排序
        Collections.sort(students, (s1, s2) -> Integer.compare(s1.age, s2.age));

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

在这个例子中，Collections.sort() 方法使用了一个Lambda表达式作为比较器来按年龄排序学生列表。这种方式不仅简洁明了，还可以轻松调整排序逻辑。

如果想进一步深入了解自定义比较器的其他用法，可以参考 Java官方文档，了解更多细节和示例。

11月09日回复举报

添加新评论

柔素年

11月29日

使用Arrays.sort()时要记得，它对对象数组排序时是通过自然顺序，需实现Comparable接口。

赞 0 回复举报

刹那： @柔素年

在使用 Arrays.sort() 对对象数组进行排序时，确实需要实现 Comparable 接口，以指定对象的自然排序顺序。实现该接口时，要重写 compareTo(T o) 方法，决定当前对象与参数对象的大小比较。

例如，可以创建一个简单的 Person 类：

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

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age); // 按年龄排序
    }
}

// 使用示例
Person[] people = {
    new Person("Alice", 30),
    new Person("Bob", 25),
    new Person("Charlie", 35)
};

Arrays.sort(people); // 使用 Arrays.sort 进行排序

排序结束后，people 数组将按年龄升序排列。不仅如此，还可以结合 Comparator 接口实现更灵活的排序方式，比如按名字排序等。如需了解更多信息，可以参考 Java官方文档，其中详细介绍了 Arrays.sort() 方法的使用。

11月15日回复举报

添加新评论

幽美

12月08日

比较丰富的代码示例增强了可理解性。

赞 0 回复举报

听风吟： @幽美

看到这段评论，确实让人觉得代码示例在理解上起到了很大的帮助。实际上，使用 Java 的 Arrays.sort() 方法来排序数组是一个相对简单的任务，但如果能够结合具体的示例，效果会更加直观。

例如，下面是一个简单的代码片段，展示了如何对一个整数数组进行排序：

import java.util.Arrays;

public class SortExample {
    public static void main(String[] args) {
        int[] numbers = {5, 3, 8, 1, 2};
        Arrays.sort(numbers);
        System.out.println(Arrays.toString(numbers));
    }
}

这段代码创建了一个整数数组 numbers，并使用 Arrays.sort() 方法对其进行排序。输出结果将是 [1, 2, 3, 5, 8]，这不仅能帮助理解排序的机制，同时也展示了 Java 提供的方便性。

在理解排序的同时，也可以进一步学习自定义排序的方法，比如使用 Comparator 接口来对对象数组进行排序：

import java.util.Arrays;
import java.util.Comparator;

class Person {
    String name;
    int age;

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

public class CustomSortExample {
    public static void main(String[] args) {
        Person[] people = {
            new Person("Alice", 30),
            new Person("Bob", 25),
            new Person("Charlie", 35)
        };

        Arrays.sort(people, Comparator.comparingInt(p -> p.age));
        for (Person p : people) {
            System.out.println(p.name + ", " + p.age);
        }
    }
}

这段代码根据年龄对 Person 对象数组进行排序，输出将会是按年龄升序排列的人员名单。这样的示例可以帮助加深对 Java 排序机制的理解。

如果想更深入了解 Java 中的排序方式，可以参考 Oracle 的官方文档：Java Arrays.sort() Documentation.

6天前回复举报

添加新评论

韦华霖

12月13日

对于需要倒序排序的情况，可以使用Collections.reverse(list)，这个需要加到例子中。

赞 0 回复举报

词穷： @韦华霖

对于倒序排序的需求，使用 Collections.reverse(list) 的确是一个简便的选择。不过，使用 Collections.sort(list, Collections.reverseOrder()) 来实现倒序排序也非常直接。这样可以在排序时就指定排序顺序，避免了额外的反转步骤。例如：

List<Integer> list = Arrays.asList(5, 2, 9, 1, 5, 6);
Collections.sort(list, Collections.reverseOrder());
System.out.println(list);

这段代码会在一次性排序的同时，直接输出倒序排列的列表。

若要获取更全面的排序技巧，可以参考这篇文章：Java Collections Framework，里面包含了各种排序方法和示例，尤其适合需要深入了解的朋友。希望能对大家的学习有所帮助！

11月09日回复举报

添加新评论

古月神仙

12月14日

可以考虑补充注释说明

赞 0 回复举报

独木桥： @古月神仙

对于数组排序的理解，确实将注释补充完整会大大提升代码的可读性和可维护性。例如，在使用 Arrays.sort() 方法时，可以在代码中详细说明排序的方式和适用的场景：

import java.util.Arrays;

public class SortExample {
    public static void main(String[] args) {
        // 创建一个整数数组
        int[] numbers = {5, 2, 8, 3, 1};

        // 使用 Arrays.sort() 对数组进行升序排序
        Arrays.sort(numbers);

        // 输出排序后的数组
        System.out.println(Arrays.toString(numbers)); // 结果: [1, 2, 3, 5, 8]
    }
}

注释可以解释 Arrays.sort() 是如何通过快速排序算法实现升序排序的，或者在特定条件下如负数或者浮点数时有何区别。此外，可以提到对于自定义对象的排序，可以实现 Comparator 接口，并在代码中应用，这样也能帮助读者理解如何进行多样化的排序。

进一步的阅读和实践，可以参考 Oracle 的 Java 文档来获取更多关于排序方法的详细信息和示例。

4天前回复举报

添加新评论

33010136

12月23日

很实用的基础功能，但是需要注意Collections.sort()需要使用包装类，而不是基本类型。

赞 0 回复举报

玻璃杯： @33010136

对于数组排序的讨论，确实值得关注基本类型与包装类的差异。在使用 Collections.sort() 方法时，基本类型如 int、double 等不能直接使用，这确实需要用到相应的包装类，比如 Integer 和 Double。

以下是一个简单的代码示例，展示了如何将基本类型数组转换为包装类数组以便排序：

import java.util.Arrays;
import java.util.Collections;

public class SortExample {
    public static void main(String[] args) {
        int[] numbers = {5, 3, 8, 1, 4};

        // 转换为包装类数组
        Integer[] wrappedNumbers = Arrays.stream(numbers)
                                          .boxed()
                                          .toArray(Integer[]::new);

        // 使用 Collections.sort() 进行排序
        Arrays.sort(wrappedNumbers, Collections.reverseOrder());

        // 输出结果
        System.out.println(Arrays.toString(wrappedNumbers));
    }
}

在这个例子中，通过 Arrays.stream() 方法将基本类型的数组转换成了 Integer 类型的数组，然后可以顺利使用 Collections.sort() 进行排序。同时，还需注意排序的顺序，可以使用 Collections.reverseOrder() 来实现倒序排序。

更多关于数组排序的信息可以参考官方文档：Java Collections Framework。这样可以提高代码安全性和稳定性，也可以帮助理解 Java 中不同类型的处理方式。

11月12日回复举报

添加新评论

免费图表工具，画流程图、架构图

Java sort()数组排序

举报评论

删除

删除后，将不可回复，确认要删除？

提示

复制代码，请先登录