Java:比较与排序

最新推荐文章于 2025-05-30 00:50:08 发布
原创 最新推荐文章于 2025-05-30 00:50:08 发布 · 462 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #比较 #排序 #编程 #互联网

本文详细介绍了Java中用于比较和排序的Comparable接口和Comparator接口。Comparable接口用于定义类的自然顺序，Comparator则提供了更灵活的排序算法，可以在需要时指定比较器。文中通过示例展示了如何实现这两个接口，并通过Arrays.sort()、Collections.sort()、TreeSet和TreeMap进行排序测试。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.两种比较接口分析

在“集合框架”中有两种比较接口：Comparable接口和Comparator接口。Comparable是通用的接口，用户可以实现它来完成自己特定的比较，而Comparator可以看成一种算法的实现，在需要容器集合实现比较功能的时候，来指定这个比较器，这可以看成一种设计模式，将算法和数据分离。

前者应该比较固定，和一个具体类相绑定，而后者比较灵活，它可以被用于各个需要比较功能的类使用。

一个类实现了Camparable接口表明这个类的对象之间是可以相互比较的。如果用数学语言描述的话就是这个类的对象组成的集合中存在一个全序。这样，这个类对象组成的集合就可以使用Sort方法排序了。

而Comparator的作用有两个：

1、如果类的设计师没有考虑到Compare的问题而没有实现Comparable接口，可以通过Comparator来实现比较算法进行排序；

2、为了使用不同的排序标准做准备，比如：升序、降序或其他什么序。

2 Comparable接口

public interface Comparable<T> {

    public int compareTo(T o);

}

java.lang. Comparable接口定义类的自然顺序，实现该接口的类就可以按这种方式排序。 

1）int compareTo(Object o): 比较当前实例对象与对象o，如果位于对象o之前，返回负值，如果两个对象在排序中位置相同，则返回0，如果位于对象o后面，则返回正值。

 

2）在 Java 2 SDK版本1.4中有二十四个类实现Comparable接口。下表展示了8种基本类型的自然排序。虽然一些类共享同一种自然排序，但只有相互可比的类才能排序。

类

排序

BigDecimal,BigInteger,Byte,Double, Float,Integer,Long,Short

按数字大小排序

Character

按 Unicode 值的数字大小排序

String

按字符串中字符 Unicode 值排序

利用Comparable接口创建自己的类的排序顺序，只是实现compareTo()方法的问题。通常就是依赖几个数据成员的自然排序。同时类也应该覆盖equals()和hashCode()以确保两个相等的对象返回同一个哈希码。

这个接口的作用：如果数组或者集合中的（类）元素实现了该接口的话,我们就可以调用Collections.sort和Arrays.sort排序，或应用于有序集合TreeSet和TreeMap中。

下面设计一个有序的类Person，它实现Comparable接口，以年龄为第一关键字，姓名为第二关键字升序排序。

Person.java

package com.zj.sort.comparable;

public class Person implements Comparable<Person> {

    private int age;

    private String name;

    public Person(int age, String name) {

       this.age = age;

       this.name = name;

    }

    public int compareTo(Person person) {

       int cop = age - person.getAge();

       if (cop != 0)

           return cop;

       else

           return name.compareTo(person.name);

    }

    public int getAge() {

       return age;

    }

    public String getName() {

       return name;

    }

    public int hashCode() {

       int result = 17;

       result = 37 * result + age;

       result = 37 * result + name.hashCode();

       return result;

    }

    public boolean equals(Object o) {

       if (!(o instanceof Person))

           return false;

       Person person = (Person) o;

       return (age == person.age) && (name.equals(person.name));

    }

    public String toString() {

       return (age + "{" + name + "}");

    }

}

2.1 测试Arrays.sort（）方法

ArraysSortUnit.java

package com.zj.sort.comparable;

import java.util.Arrays;

import com.zj.compare.Person;

public class ArraysSortUnit {

    public static void main(String[] args) {

       Person[] ps = { new Person(20, "Tom"), new Person(20, "Jeff"),

              new Person(30, "Mary"), new Person(20, "Ada"),

              new Person(40, "Walton"), new Person(61, "Peter"),

              new Person(20, "Bush") };

       System.out.println(Arrays.toString(ps));

       Arrays.sort(ps);

       System.out.println(Arrays.toString(ps));

    }

}

结果：

[20{Tom}, 20{Jeff}, 30{Mary}, 20{Ada}, 40{Walton}, 61{Peter}, 20{Bush}]

[20{Ada}, 20{Bush}, 20{Jeff}, 20{Tom}, 30{Mary}, 40{Walton}, 61{Peter}]

2.2 测试Collections.sort（）方法

CollctionsSortUnit.java

package com.zj.sort.comparable;

import java.util.Arrays;

import java.util.Collections;

import com.zj.compare.Person;

public class CollctionsSortUnit {

    public static void main(String[] args) {

       Person[] ps = { new Person(20, "Tom"), new Person(20, "Jeff"),

              new Person(30, "Mary"), new Person(20, "Ada"),

               new Person(40, "Walton"), new Person(61, "Peter"),

              new Person(20, "Bush") };

       System.out.println(Arrays.toString(ps));

       Collections.sort(Arrays.asList(ps));

       System.out.println(Arrays.toString(ps));

    }

}

结果：

[20{Tom}, 20{Jeff}, 30{Mary}, 20{Ada}, 40{Walton}, 61{Peter}, 20{Bush}]

[20{Ada}, 20{Bush}, 20{Jeff}, 20{Tom}, 30{Mary}, 40{Walton}, 61{Peter}]

2.3 测试TreeSet

TreeSetUnit.java

package com.zj.sort.comparable;

import java.util.TreeSet;

import com.zj.compare.Person;

public class TreeSetUnit {

    public static void main(String[] args) {

       TreeSet<Person> set = new TreeSet<Person>();

       set.add(new Person(20, "Tom"));

       set.add(new Person(20, "Jeff"));

       set.add(new Person(30, "Mary"));

       set.add(new Person(20, "Ada"));

       set.add(new Person(40, "Walton"));

       set.add(new Person(61, "Peter"));

       set.add(new Person(20, "Bush"));

       System.out.println(set);

    }

}

结果：

[20{Ada}, 20{Bush}, 20{Jeff}, 20{Tom}, 30{Mary}, 40{Walton}, 61{Peter}]

2.4 测试TreeMap

TreeMapUnit.java

package com.zj.sort.comparable;

import java.util.TreeMap;

import com.zj.compare.Person;

public class TreeMapUnit {

    public static void main(String[] args) {

       TreeMap<Person, String> map = new TreeMap<Person, String>();

       map.put(new Person(20, "Tom"), "Tom");

       map.put(new Person(20, "Jeff"), "Jeff");

       map.put(new Person(30, "Mary"), "Mary");

       map.put(new Person(20, "Ada"), "Ada");

       map.put(new Person(40, "Walton"), "Walton");

       map.put(new Person(61, "Peter"), "Peter");

       map.put(new Person(20, "Bush"), "Bush");

       System.out.println(map);

    }

}

结果：

{20{Ada}=Ada, 20{Bush}=Bush, 20{Jeff}=Jeff, 20{Tom}=Tom, 30{Mary}=Mary, 40{Walton}=Walton, 61{Peter}=Peter}

3. Comparator接口

public interface Comparator<T> {

    int compare(T o1, T o2);

    boolean equals(Object obj);

}

若一个类不能用于实现java.lang.Comparable，或者不喜欢缺省的Comparable行为并想提供自己的排序顺序(可能多种排序方式)，你可以实现Comparator接口，从而定义一个比较器。

 

1）int compare(Object o1, Object o2): 对两个对象o1和o2进行比较，如果o1位于o2的前面，则返回负值，如果在排序顺序中认为o1和o2是相同的，返回0，如果o1位于o2的后面，则返回正值。

 

2）与Comparable相似，0返回值不表示元素相等。一个0返回值只是表示两个对象排在同一位置。由Comparator用户决定如何处理。

 

3）boolean equals(Object obj): 指示对象obj是否和比较器相等。该方法覆写Object的equals()方法，检查的是Comparator实现的等同性，不是处于比较状态下的对象。你想提升自己吗？欢迎加入java技术交流659270626

下面设计一个定义完整equals方法和hashCode方法的类Person。

Person.java

package com.zj.sort.comparator;

public class Person {

    private String firstName;

    private String lastName;

    private int age;

    public Person(int age, String firstName, String lastName) {

       this.age = age;

       this.firstName = firstName;

       this.lastName = lastName;

    }

    public int getAge() {

       return age;

    }

    public String getFirstName() {

       return firstName;

    }

    public String getLastName() {

       return lastName;

    }

    public int hashCode() {

       int result = 17;

       result = 37 * result + age;

       result = 37 * result + firstName.hashCode();

       result = 37 * result + lastName.hashCode();

       return result;

    }

    public boolean equals(Object o) {

       if (!(o instanceof Person))

           return false;

       Person p = (Person) o;

       return (age == p.age) && (firstName.equals(p.firstName))

              && (lastName.equals(p.lastName));

    }

    public String toString() {

       return (age + "{" + firstName + " " + lastName + "}");

    }

}

下面设计两个比较器。

FirstNameComparator.java

package com.zj.sort.comparator;

import java.util.Comparator;

//实现按FirstName优先排序

public class FirstNameComparator implements Comparator<Person> {

    public int compare(Person person, Person anotherPerson) {

       String lastName1 = person.getLastName().toUpperCase();

       String firstName1 = person.getFirstName().toUpperCase();

       String lastName2 = anotherPerson.getLastName().toUpperCase();

       String firstName2 = anotherPerson.getFirstName().toUpperCase();

       if (firstName1.equals(firstName2))

           return lastName1.compareTo(lastName2);

       else

           return firstName1.compareTo(firstName2);

    }

}

LastNameComparator.java

package com.zj.sort.comparator;

import java.util.Comparator;

//实现按LastName优先排序

public class LastNameComparator implements Comparator<Person> {

    public int compare(Person person, Person anotherPerson) {

       String lastName1 = person.getLastName().toUpperCase();

       String firstName1 = person.getFirstName().toUpperCase();

       String lastName2 = anotherPerson.getLastName().toUpperCase();

       String firstName2 = anotherPerson.getFirstName().toUpperCase();

       if (lastName1.equals(lastName2))

           return firstName1.compareTo(firstName2);

       else

           return lastName1.compareTo(lastName2);

    }

}

下面通过上述两个比较器，调用Collections.sort和Arrays.sort排序，以及将其应用于有序集合TreeSet和TreeMap中。

3.1 测试Arrays.sort（）方法

ArraysSortUnit.java

package com.zj.sort.comparator;

import java.util.Arrays;

public class ArraysSortUnit {

    public static void main(String[] args) {

       Person[] ps = { new Person(20, "Tom", "A"),

              new Person(20, "Jeff", "A"), new Person(30, "Mary", "A"),

              new Person(20, "Ada", "B"), new Person(40, "Walton","B"),

              new Person(61, "Peter", "B"), new Person(20, "Bush","B") };

       System.out.println(Arrays.toString(ps));

       Arrays.sort(ps,new FirstNameComparator());

       System.out.println(Arrays.toString(ps));

       Arrays.sort(ps,new LastNameComparator());

       System.out.println(Arrays.toString(ps));

    }

}

结果：

[20{Tom A}, 20{Jeff A}, 30{Mary A}, 20{Ada B}, 40{Walton B}, 61{Peter B}, 20{Bush B}]

[20{Ada B}, 20{Bush B}, 20{Jeff A}, 30{Mary A}, 61{Peter B}, 20{Tom A}, 40{Walton B}]

[20{Jeff A}, 30{Mary A}, 20{Tom A}, 20{Ada B}, 20{Bush B}, 61{Peter B}, 40{Walton B}]

3.2 测试Collections.sort（）方法

CollctionsSortUnit.java

package com.zj.sort.comparator;

import java.util.Arrays;

import java.util.Collections;

public class CollectionsSortUnit {

    public static void main(String[] args) {

       Person[] ps = { new Person(20, "Tom", "A"),

              new Person(20, "Jeff", "A"), new Person(30, "Mary", "A"),

              new Person(20, "Ada", "B"), new Person(40, "Walton","B"),

              new Person(61, "Peter", "B"), new Person(20, "Bush","B") };

       System.out.println(Arrays.toString(ps));

       Collections.sort(Arrays.asList(ps),new FirstNameComparator());

       System.out.println(Arrays.toString(ps));

       Collections.sort(Arrays.asList(ps),new LastNameComparator());

       System.out.println(Arrays.toString(ps));

    }

}

结果：

[20{Tom A}, 20{Jeff A}, 30{Mary A}, 20{Ada B}, 40{Walton B}, 61{Peter B}, 20{Bush B}]

[20{Ada B}, 20{Bush B}, 20{Jeff A}, 30{Mary A}, 61{Peter B}, 20{Tom A}, 40{Walton B}]

[20{Jeff A}, 30{Mary A}, 20{Tom A}, 20{Ada B}, 20{Bush B}, 61{Peter B}, 40{Walton B}]

3.3 测试TreeSet

TreeSetUnit.java

package com.zj.sort.comparator;

import java.util.TreeSet;

public class TreeSetUnit {

    public static void main(String[] args) {

       TreeSet<Person> firstNameSet = new TreeSet<Person>(

              new FirstNameComparator());

       firstNameSet.add(new Person(20, "Tom", "A"));

       firstNameSet.add(new Person(20, "Jeff", "A"));

       firstNameSet.add(new Person(30, "Mary", "A"));

       firstNameSet.add(new Person(20, "Ada", "B"));

       firstNameSet.add(new Person(40, "Walton", "B"));

       firstNameSet.add(new Person(61, "Peter", "B"));

       firstNameSet.add(new Person(20, "Bush", "B"));

       System.out.println(firstNameSet);

       TreeSet<Person> lastNameSet = new TreeSet<Person>(

              new LastNameComparator());

       lastNameSet.addAll(firstNameSet);

       System.out.println(lastNameSet);

    }

}

结果：

[20{Ada B}, 20{Bush B}, 20{Jeff A}, 30{Mary A}, 61{Peter B}, 20{Tom A}, 40{Walton B}]

[20{Jeff A}, 30{Mary A}, 20{Tom A}, 20{Ada B}, 20{Bush B}, 61{Peter B}, 40{Walton B}]

3.4 测试TreeMap

TreeMapUnit.java

package com.zj.sort.comparator;

import java.util.TreeMap;

public class TreeMapUnit {

    public static void main(String[] args) {

       TreeMap<Person, String> firstNameMap = new TreeMap<Person, String>(

              new FirstNameComparator());

       firstNameMap.put(new Person(20, "Tom", "A"), "Tom A");

       firstNameMap.put(new Person(20, "Jeff", "A"), "Jeff A");

       firstNameMap.put(new Person(30, "Mary", "A"), "Mary A");

       firstNameMap.put(new Person(20, "Ada", "B"), "Ada B");

       firstNameMap.put(new Person(40, "Walton", "B"), "Walton B");

       firstNameMap.put(new Person(61, "Peter", "B"), "Peter B");

       firstNameMap.put(new Person(20, "Bush", "B"), "Bush B");

       System.out.println(firstNameMap);

       TreeMap<Person, String> lastNameMap = new TreeMap<Person, String>(

              new LastNameComparator());

       lastNameMap.putAll(firstNameMap);

       System.out.println(lastNameMap);

    }

}

结果：

{20{Ada B}=Ada B, 20{Bush B}=Bush B, 20{Jeff A}=Jeff A, 30{Mary A}=Mary A, 61{Peter B}=Peter B, 20{Tom A}=Tom A, 40{Walton B}=Walton B}

{20{Jeff A}=Jeff A, 30{Mary A}=Mary A, 20{Tom A}=Tom A, 20{Ada B}=Ada B, 20{Bush B}=Bush B, 61{Peter B}=Peter B, 40{Walton B}=Walton B}

排序——最全的七大排序算法知识汇总
ZhangHahaaha的博客
05-10 642
目录概念什么是排序稳定性排序的分类总览1.插入排序直接插入排序原理代码实现性能分析折半插入排序希尔排序原理代码实现性能分析2.选择排序直接选择排序原理代码实现性能分析堆排序原理代码实现性能分析3.交换排序冒泡排序原理代码实现性能分析快速排序（重要）原理代码实现性能分析4.归并排序归并排序原理代码实现性能分析5.排序总结 概念 排序：一串记录，按照其中的某个或者某些关键字的大小，递增或者递减排列起来的操作。通常意义上的排序都是指原地排序。 什么是排序稳定性 排序稳定性：两个相等的数据，如果经过排序后，排序算法
Java中各个排序算法比较
weixin_59661960的博客
05-23 550
之前我在javase基础中初步了解了一下冒泡排序，现在想根据创建的排序算法总结出它们在各方面的优劣性。 下图为java常见的几种排序： 之前我们在刘老师的数据结构课程上也有学过时间复杂度和空间复杂度的概念，时间复杂度用来描述一个算法的执行时间，空间复杂度则是是对一个算法在运行过程中临时占用存储空间大小的一个度量。 一、交换排序 1、冒泡排序 核心思想是： 1、从第一个元素开始，比较相邻的两个元素。如果第一个比第二个大，则进行交换。 3、轮到下一组相邻元素，执行同样的比较操作，再找下一组，直
Java排序对比
LvLuffy的博客
09-08 442
一、冒泡排序代码：public class BubbleSortClass { public static void main(String[] str) { int[] arr = {20, 6, 14, 10, 7, 19, 8, 9, 11, 18, 16, 13, 15, 5, 1, 4, 12, 2, 3, 17}; int temp;
java中常用排序方法
最新发布
2301_80636823的博客
05-30 1039
时间复杂度：O(N^2)空间复杂度：O(1)稳定性：稳定。
java排序比较_java排序方式对比
weixin_26808439的博客
02-12 185
packagecom.liruilong;importjava.util.ArrayList;importjava.util.Collections;importjava.util.Comparator;importjava.util.List;/*** @Description : 集合排序整理* @Author: Liruilong* @Date: 2019/7/31 22:21*/publi...
java 数组比较排序
snkcxy的博客
12-28 161
java数组比较排序需要实现Comparable接口，并实现其中的compareTo方法，方可用compareTo进行比较或者用Arrays.sort(arrayObj); 进行排序 代码：   /**一个雇员类 实现了比较的接口 * @author CXY * */ public class Employee implements Comparable&lt;Emplo...
比较排序（java）
Zc9741的博客
02-08 305
一、比较排序 1.冒泡排序 算法思想：每次循环将最大/最小的元素顶到最前端，两层for循环 平均时间复杂度：O(n²) 最好时间复杂度：O(n) 空间复杂度：O(1)，仅需常数个辅助空间 稳定性：稳定 代码： public static void main(String[] args) { int[] arr={15,1,6,12,3,7,9,2}; bubbleSort(arr); printArr(arr); } private s
Quicksort-Java:就地快速排序功能
06-12
一个小型 Java 项目，用于实现 Quicksort 的就地版本。 要使用代码，您需要使用快速排序功能。 该函数采用三个参数，一个 T 类项的 List，一个最左边元素索引的 int（通常为 0），以及最右边元素的索引（通常为数组...
堆排序算法详解：基于比较排序法的高效数据排列方法及其Java实现
01-06
文中详细解释了堆的概念及其特性，阐述了堆排序算法的两个关键步骤——建堆（Heapify）与排序，并提供了具体的 Java 实现代码。在建堆阶段，文档介绍了如何把任意无序的数据集合转化成符合堆规则的数据结构。在排序...
java_algorithm:Java算法集合：排序、高级排序、堆和堆排序、二分搜索树、并查表、图的基础、最小生成树、最短路径
04-27
Java_Algorithm（Java算法集合） 学习算法是为了什么？ 1、应对大型IT公司的算法面试题； 2、IDE即对编译算法的封装； 3、搜索引擎中对几千、几亿数据进行优劣排序； 4、游戏对算法的引用是非常丰富的； 5、算法对...
高效排序算法：快速排序Java与Python实现详解
12-23
内容概要：文章详述了快速排序算法的基本概念、分治策略以及具体实现方式，提供Java和Python两个版本的代码样例。快速排序算法能够将一个序列分解成较小和较大的两部分，并通过递归的方式分别对这两部分进行排序，...
Bubble-Sort-Java:Java 上的高效冒泡排序类
06-26
冒泡排序Java Java 上的高效冒泡排序类。 您可以使用 BubbleSort.java，只需添加到您的包中并创建一个对象。 Runner 类仅作为示例。... 返回： 排序数组 int [] 统计数据公共无效统计（） 显示比较和交换的次数
java中的比较排序
肆尾葱的博客
11-17 1549
java中的Comparator和Comparable比较器的用法Comparable和Comparator都是用来实现集合中的排序的，Comparator位于包Java.util下，而Comparable位于包java.lang下，Comparable是一个对象本身就已经支持自比较所需要实现的接口（如 String、Integer 自己就可以完成比较大小操作），是内部定义的排序；而后者在一个独立的
java排序比较_java 常见排序方法比较
weixin_34831191的博客
02-21 308
1.冒泡排序从第一个元素开始依次i与i+1元素相比较，若i元素较大，则交换两元素。这样一趟下来最大的元素就到了队尾,第二趟则从第一个元素比到第n-1个元素,这样倒数第二个元素就是从第一个到n-1个元素里最大的。以此类推，经过n-1趟，要比较n-1+n-2+...+1次，故时间复杂度=n*(n-1)/2,为O(n^2).1 public classSort {2 public void Bu...
java 对比_Java:比较与排序
weixin_35568959的博客
02-20 314
1.两种比较接口分析在“集合框架”中有两种比较接口：Comparable接口和Comparator接口。Comparable是通用的接口，用户可以实现它来完成自己特定的比较，而Comparator可以看成一种算法的实现，在需要容器集合实现比较功能的时候，来指定这个比较器，这可以看成一种设计模式，将算法和数据分离。前者应该比较固定，和一个具体类相绑定，而后者比较灵活，它可以被用于各个需要比较功能的类...
Java编程 —— 常见的比较排序详解
MercuryG的博客
06-23 298
1.1 排序
java - 七大比较排序 - 详解
m0_69119792的博客
09-27 782
本篇介绍了七大比较排序，直接插入排序，希尔排序，冒泡排序，堆排序，选择排序，快速排序，归并排序，一些简单思想+代码实现，如有错误，请在评论区指正，让我们一起交流，共同进步！
Java的比较和排序
tragfarmer的博客
08-21 684
1- Java基本类型和引用类型 2- 什么是栈和堆？ 3- 存储在内存中的原始类型 4- 存储在内存中的引用类型 5- Java中的类型比较 6- 原始类型的比较 7- 引用类型的比较 7.1- 使用==操作符来比较引用类型 7.2- 使用equals(..) 来比较引用类型 7.3- 重写equals(Object)方法 8- 排序字符串数组的例子 9- 对象可以相互比较
Java实现：Shell排序与快速排序详解
"本文介绍了两种常用的Java排序算法：Shell排序和快速排序。这两种算法都是用于对整型数组进行排序，以实现数据的有序排列。" 在编程领域，排序算法是解决问题的关键工具之一，尤其是在处理大量数据时。Java作为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值