System.out.print("before sort: ");
for (int i = 0; i< arr.length; i++)
System.out.print(arr[i] + " ");
System.out.println();
Arrays.sort(arr);
System.out.print("after sort: ");
for (int i = 0; i< arr.length; i++)
System.out.print(arr[i] + " ");
System.out.println();
输出结果：
before sort: 2 3 1 10 7 4
after sort: 1 2 3 4 7 10
我们看到排序结果是按照升序排列的，下面的排序都是如此。
对象的排序
对象可以放在数组里，同样调用Arrays.sort(Object[] arr)即可；也可以放到集里，用java.util.Collections的
sort(List list)。
但是这个类必须实现了java.lang.Comparable接口。这个接口只有一个方法：int compartTo(Object o)，
当本对象比传入的对象大时，返回一个正整数。 以类Programmer为例：
class Programmer implements Comparable{
private String name;
private String language;
private double pay;
public Programmer(String name, String language, double pay) {
this.name = name;
this.language = language;
this.pay = pay;
}
public int compareTo(Object o) {
Programmer other = (Programmer)o;
return (int)pay - (int)other.pay;
}
public String toString(){
return "{name: " + name + ", language: " + language + ", money: " + pay + "}";
}
}
对其进行排序：
ArrayList list = new ArrayList();
list.add(new Programmer("张三", "C", 12000));
list.add(new Programmer("李四", "Java", 200));
list.add(new Programmer("王五", "C++", 5000));
list.add(new Programmer("钱六", "VB", 3000));
System.out.println("before sort: " + list);
Collections.sort(list);
System.out.println("after sort: " + list);
输出：
before sort: [{name: 张三, language: C, money: 12000.0}, {name: 李四, language: Java, money: 200.0},
{name: 王五, language: C++, money: 5000.0}, {name: 钱六, language: VB, money: 3000.0}]
after sort: [{name: 李四, language: Java, money: 200.0}, {name: 钱六, language: VB, money: 3000.0},
{name: 王五, language: C++, money: 5000.0}, {name: 张三, language: C, money: 12000.0}]
够简单吧！查查Comparable的javadoc可以知道，有很多类已经实现了该接口，因此对这些类的排序几行代码就可以搞定。
最近看C#发现其中用System.Array.sort对数组排序，适用于所有实现了IComparable接口的对象，看来微软的借鉴能力还真是强啊！
对已有类进行排序
上面的方法有一个问题，就是一个类已经存在了，并且没有实现Comparable接口，使用一个子类进行封装？
很麻烦（你可以对下面的例子试试）。还有一种情况就是对一个类没法实现多种排序。以File类为例，它实现了Comparable接口，
但是是按照名称排序的。如果要按照大小排序，或者按修改时间排序呢？对这两种情况，使用java.util包的Comparator接口：
Arrays.sort(Object[] arr, Comparator com)
Collections.sort(Object[] arr, Comparator com)
Comparator接口的方法：
public int compare(Object o1, Object o2) 当o1比o2大时返回一个正整数
public boolean equals(Object obj) 判断obj与这个Comparator是否同一个对象
下面使用Comparator对文件实现了按文件大小或修改时间排序：
class FileUtils {
static class CompratorByLastModified implements Comparator {
public int compare(Object o1, Object o2) {
File file1 = (File)o1;
File file2 = (File)o2;
long diff = file1.lastModified() - file2.lastModified();
if (diff > 0)
return 1;
else if (diff == 0)
return 0;
else
return -1;
}
public boolean equals(Object obj){
return true; //简单做法
}
}
static class CompratorBySize implements Comparator {
public int compare(Object o1, Object o2) {
File file1 = (File)o1;
File file2 = (File)o2;
long diff = file1.length() - file2.length();
if (diff > 0)
return 1;
else if (diff == 0)
return 0;
else
return -1;
}
public boolean equals(Object obj){
return true; //简单做法
}
}
}
调用的示例：
File dir = new File("C:\\temp");
File[] files = dir.listFiles();
System.out.print("before sort: ");
for (int i = 0; i< files.length; i++)
System.out.print(files[i] + " ");
System.out.println();
Arrays.sort(files);
System.out.print("sort by name: ");
for (int i = 0; i< files.length; i++)
System.out.print(files[i] + " ");
System.out.println();
Arrays.sort(files, new FileUtils.CompratorBySize());
System.out.print("sort by size: ");
for (int i = 0; i< files.length; i++)
System.out.print(files[i] + " ");
System.out.println();
Arrays.sort(files, new FileUtils.CompratorByLastModified());
System.out.print("sort by last modified: ");
for (int i = 0; i< files.length; i++)
System.out.print(files[i] + " ");
System.out.println();
自己找个目录试一下吧。用这些Java类库中的方法，一般情况下应该是不用自己写排序算法了吧？
最后附上完整代码占点版面：
import java.io.*;
import java.util.*;
public class TestSort {
public static void main(String[] args) {
sortSimpleType();
sortComparable();
sortComparator();
}
public static void sortSimpleType() {
int[] arr = {2, 3, 1,10,7,4};
System.out.print("before sort: ");
for (int i = 0; i< arr.length; i++)
System.out.print(arr[i] + " ");
System.out.println();
Arrays.sort(arr);
System.out.print("after sort: ");
for (int i = 0; i< arr.length; i++)
System.out.print(arr[i] + " ");
System.out.println();
}
public static void sortComparable() {
ArrayList list = new ArrayList();
list.add(new Programmer("张三", "C", 12000));
list.add(new Programmer("李四", "Java", 200));
list.add(new Programmer("王五", "C++", 5000));
list.add(new Programmer("钱六", "VB", 3000));
System.out.println("before sort: " + list);
Collections.sort(list);
System.out.println("after sort: " + list);
}
public static void sortComparator() {
File dir = new File("C:\\java");
File[] files = dir.listFiles();
System.out.print("before sort: ");
for (int i = 0; i< files.length; i++)
System.out.println(files[i] + " ");
System.out.println();
Arrays.sort(files);
System.out.print("sort by name: ");
for (int i = 0; i< files.length; i++)
System.out.println(files[i] + " ");
System.out.println();
Arrays.sort(files, new FileUtils.CompratorBySize());
System.out.print("sort by size: ");
for (int i = 0; i< files.length; i++)
System.out.println(files[i] + " ");
System.out.println();
Arrays.sort(files, new FileUtils.CompratorByLastModified());
System.out.print("sort by last modified: ");
for (int i = 0; i< files.length; i++)
System.out.println(files[i] + " ");
System.out.println();
}
}
class Programmer implements Comparable{
private String name;
private String language;
private double pay;
public Programmer(String name, String language, double pay) {
this.name = name;
this.language = language;
this.pay = pay;
}
public int compareTo(Object o) {
Programmer other = (Programmer)o;
return (int)pay - (int)other.pay;
}
public String toString(){
return "{name: " + name + ", language: " + language + ", money: " + pay + "}";
}
}
class FileUtils {
static class CompratorByLastModified implements Comparator {
public int compare(Object o1, Object o2) {
File file1 = (File)o1;
File file2 = (File)o2;
long diff = file1.lastModified() - file2.lastModified();
if (diff > 0)
return 1;
else if (diff == 0)
return 0;
else
return -1;
}
public boolean equals(Object obj){
return true; //简单做法
}
}
static class CompratorBySize implements Comparator {
public int compare(Object o1, Object o2) {
File file1 = (File)o1;
File file2 = (File)o2;
long diff = file1.length() - file2.length();
if (diff > 0)
return 1;
else if (diff == 0)
return 0;
else
return -1;
}
public boolean equals(Object obj){
return true; //简单做法
}
}
}
运行结果：
C:\java>java TestSort
before sort: 2 3 1 10 7 4
after sort: 1 2 3 4 7 10
before sort: [{name: 张三, language: C, money: 12000.0}, {name: 李四, language:
Java, money: 200.0}, {name: 王五, language: C++, money: 5000.0}, {name: 钱六, language: VB, money: 3000.0}]
after sort: [{name: 李四, language: Java, money: 200.0}, {name: 钱六, language:
VB, money: 3000.0}, {name: 王五, language: C++, money: 5000.0}, {name: 张三, language: C, money: 12000.0}]
before sort: C:\java\class.bat
C:\java\onlyfun
C:\java\build.xml
C:\java\1.txt
C:\java\native.bat
C:\java\hib.bat
C:\java\hjar
C:\java\src
C:\java\xdoclet
C:\java\lib2
C:\java\jsf.bat
C:\java\struts.bat
C:\java\TestSort.java
C:\java\TestSort.class
C:\java\jar
C:\java\messages_zh_TW1.properties
C:\java\messages.properties
C:\java\messages_zh_TW.properties
C:\java\Programmer.class
C:\java\FileUtils$CompratorByLastModified.class
C:\java\FileUtils$CompratorBySize.class
C:\java\FileUtils.class
C:\java\lib
C:\java\bean.xml
sort by name: C:\java\1.txt
C:\java\bean.xml
C:\java\build.xml
C:\java\class.bat
C:\java\FileUtils$CompratorByLastModified.class
C:\java\FileUtils$CompratorBySize.class
C:\java\FileUtils.class
C:\java\hib.bat
C:\java\hjar
C:\java\jar
C:\java\jsf.bat
C:\java\lib
C:\java\lib2
C:\java\messages.properties
C:\java\messages_zh_TW.properties
C:\java\messages_zh_TW1.properties
C:\java\native.bat
C:\java\onlyfun
C:\java\Programmer.class
C:\java\src
C:\java\struts.bat
C:\java\TestSort.class
C:\java\TestSort.java
C:\java\xdoclet
sort by size: C:\java\hjar
C:\java\jar
C:\java\lib
C:\java\lib2
C:\java\onlyfun
C:\java\src
C:\java\xdoclet
C:\java\1.txt
C:\java\native.bat
C:\java\jsf.bat
C:\java\struts.bat
C:\java\class.bat
C:\java\FileUtils.class
C:\java\hib.bat
C:\java\messages.properties
C:\java\FileUtils$CompratorBySize.class
C:\java\FileUtils$CompratorByLastModified.class
C:\java\bean.xml
C:\java\Programmer.class
C:\java\messages_zh_TW.properties
C:\java\messages_zh_TW1.properties
C:\java\build.xml
C:\java\TestSort.class
C:\java\TestSort.java
sort by last modified: C:\java\lib
C:\java\jar
C:\java\hjar
C:\java\onlyfun
C:\java\1.txt
C:\java\hib.bat
C:\java\src
C:\java\xdoclet
C:\java\build.xml
C:\java\lib2
C:\java\bean.xml
C:\java\class.bat
C:\java\struts.bat
C:\java\messages.properties
C:\java\messages_zh_TW1.properties
C:\java\messages_zh_TW.properties
C:\java\jsf.bat
C:\java\native.bat
C:\java\TestSort.java
C:\java\FileUtils.class
C:\java\FileUtils$CompratorBySize.class
C:\java\FileUtils$CompratorByLastModified.class
C:\java\Programmer.class
C:\java\TestSort.class
C:\java>
分享到：
相关推荐
9. **Java集合框架与数组的关系**：虽然数组是基础，但Java集合框架提供了更灵活的数据结构，如ArrayList和LinkedList，它们在某些场景下比数组更具优势。 10. **性能考虑**：数组在内存分配上是静态的，一旦创建，...
在压缩包文件"ArrayAlgo"中，可能包含了各种数组操作和排序算法的示例代码，这对于深入理解和掌握这些概念非常有帮助。通过阅读和运行这些代码，你可以直观地了解这些算法的工作原理，并进行进一步的优化和扩展。
在编程领域，尤其是Java语言中，数组和集合是处理数据的两种基本方式。数组（Array）是同类型数据的有序集合，而集合（Collection）则是更加灵活的数据结构，可以存储任意类型的对象。Java为这两种数据存储方式提供...
在Java编程中，对象数组排序是一项常见的任务，特别是在处理复杂数据结构时。当我们需要根据对象的多个属性进行排序时，情况会变得稍微复杂。本文将深入探讨如何在Java中实现这个功能，结合给出的标签“源码”和...
本实验中我们学习了 Java 语言中的数组和集合操作，掌握了 Java 中的数组声明、初始化、索引访问、遍历等操作，并使用冒泡排序算法将数组元素排序。同时，我们还学习了 Java 中的输入输出操作和异常处理。
2. **数组排序方法**： - **冒泡排序**：通过不断交换相邻两个元素来实现排序，效率较低，适用于小规模数据。 - **选择排序**：每次找出未排序部分的最小（大）值，放在已排序部分的末尾，适合数据量较小的情况。 ...
Java集合框架中的`Arrays`类提供了对数组排序的方法，如`Arrays.sort()`，可用于整型、字符型等基本类型的数组，也可通过自定义比较器对对象数组进行排序。 八、数组与集合框架的关系 虽然数组是Java的基础，但集合...
在"7-数组与方法(上)"和"8-数组与方法(下)"的文件中，可能详细讲解了数组的使用方法，包括如何定义、初始化、遍历、修改、查找、排序二维数组，以及如何将数组作为方法参数等实践技巧。通过学习这些内容，开发者能够...
在Java编程中，大作业通常涉及实际应用中的问题解决，这次的任务是利用数组实现一个队列排序，并且能够动态地插入新的元素。这个任务主要涵盖了两个核心知识点：数组的使用和排序算法。下面将详细解释这两个方面。 ...
总结来说，从n个数组中取出所有排列组合的Java实现涉及到递归算法、回溯法以及数据结构的操作。理解这些概念并能够熟练运用是成为一名优秀程序员的关键。通过这个例子，我们可以看到如何利用Java的灵活性和表达力来...
下面，我们将深入探讨Java对`double`数组排序的实现方法以及代码中的关键细节。 首先，让我们看一下提供的代码片段。这是一个简单的冒泡排序算法，用于对`double`数组进行升序排列。冒泡排序是一种基础排序算法，它...
例如，一个简单的数组排序方法： ```java public class ArrayHelp { public static <T extends Comparable<T>> void sort(T[] array) { Arrays.sort(array); } } ``` 4. **ClassLoadUtil.java**： 这个...
对数组进行排序是常见的需求之一，Java提供了多种排序算法，如冒泡排序、选择排序等。另外，还可以使用`Arrays.sort()`方法来进行排序： ```java int[] arr = {5, 3, 1, 4, 2}; Arrays.sort(arr); ``` #### 七、...
以下是关于Java集合与数组的相同点和不同点的详细说明： 相同点： 1. 容器：无论是数组还是集合，它们都是容器，即它们都提供了一个存储数据的结构。它们都可以用来保存一组对象，使得我们能够以统一的方式处理这些...
`Collections.sort()`方法是Java集合框架提供的一个便捷工具，用于对List接口的实现类进行排序。如果ArrayList中的元素是基本类型（如int、double等）的包装类或者是实现了Comparable接口的对象，那么可以直接使用...
3. **数组排序**：Java中的`Arrays.sort()`方法可以对一维数组进行升序排序，对于自定义类型，需要提供比较器。 4. **计算平均值**：通过累加所有成绩并除以学生人数来计算平均分。 5. **数组复制**：`Arrays....
* sort()，对不同类型的数组排序 * binarySearch()，在不同类型的数组中用二分查找算法搜索特定值 * fill(int[] a, int fromIndex, int toIndex, int val)用一个指定的值填充数组 集合 * 数组与集合的比较 * ...
在Java编程语言中，"Java的常用包"和"数组的复制与排序"是学习的基础且重要的部分。这里，我们主要探讨的是Java的核心库包以及如何处理数组，特别是复制和排序的操作。 首先，让我们深入了解Java的常用包。Java标准...
Java中的数组是编程中最基本的数据结构之一，它允许存储同类型的数据集合。在这个文档中，主要涉及了Java数组的声明、创建、初始化、赋值、输出、累加和计算、最大值查找以及冒泡排序等核心概念。 1. **数组的声明...
- **数组操作函数**：Java的`Arrays`类提供了许多实用方法，如`sort()`排序数组，`equals()`比较数组内容，`copyOf()`复制数组等。 - **集合框架**：`ArrayList`和`LinkedList`等集合类可以动态增长，提供了更多的...