对象排序 — java 7 collection详解（三）

最新推荐文章于 2025-04-07 11:58:30 发布
转载 最新推荐文章于 2025-04-07 11:58:30 发布 · 862 阅读 · 0
文章标签：

#对象 #java #java 7

本文详细介绍了Java中对象排序的方法，包括equals与hashCode的作用与实现、Comparable接口与Comparator接口的使用及注意事项。

转载自：http://peiquan.blog.51cto.com/7518552/1293970

 承接着前两篇collection讲解，这一次继续谈一下在collection里的对象排序。在谈对象排序排序之前，先来了解一下，在java里是如何判断两个对象是相等（同）的。

一、基础补充

    在根类Object里提供里两个方法hasCode（）和equal（）方法，如果两个对象相等，则hasCode的返回值应一致，equal（）应该返回true。现在来看一下java API，了解一下这两个方法的定义：

    hasCode（）：返回该对象的哈希码值。支持此方法是为了提高哈希表的性能。

    hasCode的常规协定是：

  • 在 Java 应用程序执行期间，如果对象进行equals比较时没有被修改任何信息，那么同一对象多次调用 hashCode方法，必须一致地返回相同的整数。同一程序的两次运行，该整数无需保持一致。
  • 如果根据 equals(Object) 方法判断出两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode 方法都必须生成相同的整数结果。
  • 如果根据 equals(java.lang.Object) 方法，两个对象不相等，那么对这两个对象中的任一对象上调用 hashCode方法不 要求一定生成不同的整数结果。但是，应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。

    equals（object obj）：指示某个对象obj是否与此对象“相等”。

    equals方法需要遵循一下规则：

  • 自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。
  • 对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。
  • 传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么x.equals(z) 应返回 true。
  • 一致性：对于任何非空引用值 x 和 y，如果对象进行equals比较时没有被修改任何信息，多次调用 x.equals(y)始终返回 true 或始终返回 false。
  • 对于任何非空引用值 x，x.equals(null) 都应返回 false。

    简单来说就是，对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true（x == y 具有值 true）。 另外，对于hasCode（）和equals（）方法，如果重载了其中一个，一般来说都需要重载另外一个，即两个方法都要重载。

    对于hasCode（）和 equals（）方法，初看之下，可能觉得有点难懂。其实，这两个方法的重写很简单，举个例子：重写Student类的hasCode和equals方法（假设Student类只有两个成员变量，班别和姓名），

public class Student {

	private String grade;
	private String name;
	
	public Student(String grade, String name) {
		super();
		this.grade = grade;
		this.name = name;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((grade == null) ? 0 : grade.hashCode());
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (!(obj instanceof Student))
			return false;
		Student other = (Student) obj;
		if (grade == null) {
			if (other.grade != null)
				return false;
		} else if (!grade.equals(other.grade))
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
	public static void main(String[] args) {
		Student stu1 = new Student("7班", "张三");
		Student stu2 = new Student("7班", "张三");
		Student stu3 = new Student("7班", "李四");
		System.out.println(stu1.equals(stu2));	//true
		System.out.println(stu1.hashCode() == stu2.hashCode());//true
		System.out.println(stu1.equals(stu3));	//false
		System.out.println(stu1 == stu2);		//false
	}
}

    通过Student来看，重写equals方法时，其实就是需要去判断两个对象所携带的信息是否一致。至于hasCode（）方法，可能对prime = 31有点迷茫，为什么要用31呢？？用别的数字行吗？？为此我搜索过相关信息，笼统地说，31是一个魔法数，利于方便地为当前的对象分配内存地址（这个数字不大不小） 减少hash冲突 ，提高查询速度等。

   同样注意到是：System.out.println(stu1 == stu2);在这里引入这个判断输出，只是想指出：equals（）方法判断的是对象所包含的的数据是否一致，而==判断是否为同一个对象的应用，详情可以查看这里。

  温馨提示：对于eclipse和netbeans都提供了比较完善的关于equals和hasCode的重写方法，以eclipse为例，可以按快捷键ctrl+shift+S，接着选择重写equals()和hasCode（）方法。

二、Comparable接口

    Comparable定义了类对象的排序方式，compareTo（）方法定义了排序的逻辑，默认是按照类的自然排序逻辑来排序。如下表，总结了一些常用类的默认排序方式：

Class

默认的排序方式

Class

默认的排序方式

Byte

升序（按照数字由小到大）

Float

升序

Character

升序

BigInteger

升序

Long

升序

BigDecimal

升序

Integer

升序

Boolean

Boolean.FALSE < Boolean.TRUE

Short

升序

File

默认使用系统路径的排序方式

Double

升序

String

字典排序

Date

按照日期先后排序

  

   上表所有类都实现了Comparable接口，都可以使用Collections.sort()和Arrays.sort()进行排序，如下所示：

   Collections.sort(list) ；Arrays.sort(array)；

    注意的是，所有待排序的对象都应该是可比较（大小）的，如果对象之间不能相互比较（大小），会抛出ClassCastException。同时排序的元素里不能有null，否则会抛出NullPointerException。给一个简答的例子—将string数组排序输出：

String[] fruits = new String[]{"orange","Apple","pair","watermelon"};
		Arrays.sort(fruits);
		for (String str : fruits) {
			System.out.print(str + " ");
		}


    其输出如下：Apple orange pair watermelon。

    如果需要实现自定义类的排序，则可以选择实现Comparable接口，Comparable接口的代码如下：

public interface Comparable<T> {
    public int compareTo(T o);
}

     在Comparable接口里只定义了compareTo（obj）方法，用来获得此对象与指定对象obj的顺序。如果该对象小于、等于或大于指定对象obj，则分别返回负整数、零或正整数。如果两个对象不能相互比较（大小），此方法会抛出ClassCastException。

    Demo：Student.java演示如何实现Comparable接口，这里按照Id的升序输出，

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

	public Student(int id, int score, String name) {
		super();
		if (name == null) {
			throw new NullPointerException();
		}
		Id = id;
		this.score = score;
		this.name = name;
	}

	//按照Id值得大小，升序输出
	@Override
	public int compareTo(Student stu) {
		return Id > stu.Id ? 1 : (Id < stu.Id ? -1 : 0);
	}

	//为了输出的方便和排版，重写toString方法，只是输出Id的值
	@Override
	public String toString() {
		return String.valueOf(Id);
	}
	
	public static void main(String[] args) {
		Student[] stu = {new Student(102, 60, "张三"),
				new Student(101, 70, "李四"),
				new Student(103, 90, "王五")
		};
		List<Student> stuList = Arrays.asList(stu);
		//未排序前的对象顺序
		System.out.println("未排序前的对象顺序:" + stuList);
		
		//以自然逻辑排序的对象顺序,即Comparable定义的排序逻辑（Id值得大小）
		Collections.sort(stuList);
		System.out.println("自然逻辑排序的对象顺序:" + stuList);
	}
}

    其输出如下：image。

    在Student.java里实现了Student对象按照Id值大小顺序输出对象，类似得可以定义按照成绩或者名字的自然逻辑顺序输出对象，如下：

    return score > stu.score ? 1:(score < stu.score ? -1:0);

    既然谈到排序，我们再深入一点谈实现Comparable接口需要遵守的规则。在java里，倡导所有实现Comparable接口的类都应该保持与equals（）一致的排序顺序（也可以不保持）。什么意思呢？？简单得说，对一个类里的任意两个对象obj1和obj2，obj.compareTo(obj2) == 0 与 obj1.equals(obj2)应该具有相同的boolean值。换一种说法就是，在实现Comparable接口的类里应该重写equals（）方法（伴随着需要重写hasCode（）方法），如上面的Student.java，我们这样重写equals（）与hasCode（）方法：

@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + Id;
		result = prime * result + name.hashCode();
		result = prime * result + score;
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (!(obj instanceof Student))
			return false;
		Student other = (Student) obj;
		return (Id == other.Id) && (score == other.score) && (name.equals(other.name));
	}

     这样Student.java的逻辑就算比较完善了，如果你曾经重写过equals和hasCode方法，会发现这里的重写方法里没有考虑到null异常（因为在构造函数里，确保里Student的对象 不会包含null，所有不需要考虑null异常）。温馨提示一下，对于eclipse和netbeans都提供了比较完善的关于equals和hasCode的重写方法，以eclipse为例，可以按快捷键ctrl+shift+S，接着选择重写equals()和hasCode（）方法。

三、Comparator接口

    对于没有实现Comparable接口类，如果需要排序输出对象，同样可以选择提供Comparator的实现，Comparator接口代码如下：

public interface Comparator<T> {
    int compare(T o1, T o2);
}

    在Comparator接口也只是定义里一个compare方法，用来定义对象的排序逻辑，如果对象o1小于、等于或大于对象o2，则分别返回负整数、零或正整数。如果两个对象不能相互比较（大小），此方法会抛出ClassCastException。

   Demo：Student2.java，演示了如何使用Comparator定义输出对象的顺序：

public class Student2 {
	private int Id;
	private int score;
	private String name;

	public Student2(int id, int score, String name) {
		super();
		if (name == null) {
			throw new NullPointerException();
		}
		this.Id = id;
		this.score = score;
		this.name = name;
	}

	//为了输出的方便和排版，重写toString方法，只是输出Id的值
	@Override
	public String toString() {
		return String.valueOf(Id);
	}

	public static class OrderById implements Comparator<Student2>{

		@Override
		public int compare(Student2 stu1, Student2 stu2) {
			return stu1.Id > stu2.Id ? 1:(stu1.Id < stu2.Id ? -1:0);
		}
		
	}
	
	public static void main(String[] args) {
		Student2[] stu = {new Student2(102, 60, "张三"),
				new Student2(101, 70, "李四"),
				new Student2(103, 90, "王五")
		};
		List<Student2> stuList = Arrays.asList(stu);
		//未排序前的对象顺序
		System.out.println("未排序前的对象顺序:" + stuList);
		
		//以Comparator定义的排序输出对象（Id值得大小）
		Collections.sort(stuList,new Student2.OrderById());
		System.out.println("自然逻辑排序的对象顺序:" + stuList);
	}
}

    其输出如下：image。

    相对Comparable的实现，Comparator是在类里通过一个静态类来定义输出对象的排序逻辑（按照Id的大小，升序输出；类似的可以定义score和name的排序逻辑），还有一点不同的是sort（）函数的使用：

    Collections.sort(stuList,new Student2.OrderById());

    其他的实现基本一致，那是否可以认为Comparator与Comparable是等同的呢？？如果只是定义一种排序逻辑，选择Comparator和Comparable都可以，习惯上选择Comparable。可需要多种排序逻辑输出对象的时候，就需要Comparable和Comparator的配合使用。为了更为详细的演示排序，这次同样实现对象的逆序输出，而且以内部类的形式实现Comparator：

Demo：Student.java

public class Student implements Comparable<Student> {

	private int Id;
	private int score;
	private String name;

	public Student(int id, int score, String name) {
		super();
		if (name == null) {
			throw new NullPointerException();
		}
		Id = id;
		this.score = score;
		this.name = name;
	}

	// 为了输出的方便和排版，重写toString方法，只是输出Id的值
	@Override
	public String toString() {
		return String.valueOf(Id);
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + Id;
		result = prime * result + name.hashCode();
		result = prime * result + score;
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (!(obj instanceof Student))
			return false;
		Student other = (Student) obj;
		return (Id == other.Id) && (score == other.score) && (name.equals(other.name));
	}

	// 按照Id值得大小，升序输出
	@Override
	public int compareTo(Student stu) {
		return Id > stu.Id ? 1 : (Id < stu.Id ? -1 : 0);
		// return score > stu.score ? 1:(score < stu.score ? -1:0);
	}

	// 按照分数的高低排序
	static final Comparator<Student> ORDERBYSCORE_ORDER = new Comparator<Student>() {

		@Override
		public int compare(Student stu1, Student stu2) {
			return stu1.score > stu2.score ? 1 : (stu1.score < stu2.score ? -1 : 0);
		}
	};

	// 按姓名的字典顺序排序
	static final Comparator<Student> ORDERBYNAME_ORDER = new Comparator<Student>() {

		@Override
		public int compare(Student stu1, Student stu2) {
			return stu1.name.compareTo(stu2.name);
		}
	};

	public static void main(String[] args) {
		Student[] stu = { new Student(102, 60, "张三"), 
				new Student(101, 70, "李四"),
				new Student(103, 90, "王五") };
		
		List<Student> stuList = Arrays.asList(stu);
		// 未排序前的对象顺序
		System.out.println("未排序前的对象顺序:" + stuList);

		// 以自然逻辑排序的对象顺序，Comparable定义的逻辑
		Collections.sort(stuList);
		System.out.println("自然逻辑排序的对象顺序:" + stuList);

		// 降序排序输出对象
		Collections.sort(stuList, Collections.reverseOrder());
		System.out.println("降序排序输出对象:" + stuList);

		// 使用Comparator顺序输出对象，OederByScore
		Collections.sort(stuList, ORDERBYSCORE_ORDER);
		System.out.println("OederByScore顺序输出对象" + stuList);

		// 使用另一个Comparator顺序输出对象，OederByName
		Collections.sort(stuList, ORDERBYNAME_ORDER);
		System.out.println("OederByName顺序输出对象" + stuList);
	}
}


    其输出如下：

未排序前的对象顺序:[102, 101, 103] 
自然逻辑排序的对象顺序:[101, 102, 103] 
降序排序输出对象:[103, 102, 101] 
OederByScore顺序输出对象[102, 101, 103] 
OederByName顺序输出对象[102, 101, 103]

    如上代码，可以实现了多种排序逻辑的对象输出，同时注意到逆序输出的方式：

    Collections.sort(stuList, Collections.reverseOrder());

    最后提一下的是，在Demo Student里，都是使用Collections.sort()方法来输出对象的，同样地也可以使用Arrays.sort()方法来输出对象，类似的Arrays.sort（）也有两种重载形式：

    Arrays.sort(array);

    Arrays.sort(array,Comparator);

    其用法和Student提到的方法一致。



Java集合框架（下）之Collection.sort()与Comparable,Comparator
黄复贵的博客
07-03 7390
在集合框架的应用中，往往都要进行排序，排序规则多种多样，或者只是简单的字符串大小排序，简单的数字大小排序，但有时根据需求排序规则会比较复杂。这时就需要Collection.sort()的使用技巧了。对数字大小进行排序（Integer）： public void testSortInteger(){ List<Integer> list = new ArrayList<Intege
【JAVA】Collections.sort()方法详解
热门推荐
代码的魅力，根本走不出来
03-11 1万+
是 Java 集合框架（Java Collections Framework）中的一个静态方法，用于对列表（List）中的元素进行排序。此方法利用了 Java 的泛型机制，可以很方便地对各种类型的列表进行排序。源码方法体：参数list：需要排序的列表。列表中的元素必须实现了 Comparable 接口，以便能够比较它们的大小。
java Collections 排序方法
weixin_47248721的博客
08-05 371
public class Demo { public static void main(String[] args) { // 创建集合 List<Integer> list = new ArrayList<Integer>(); // 添加元素 for (int i = 1; i <= 5; i++) { list.add(i); } System.out.println(list);// 结果：[1, 2, 3, 4, 5] // ---
java collection排序
03-07 4292
Collection 排序1.有序和排序的区别。  有序指集合元素保存的顺序按加入的本来顺序保存。  List,LinkedSet,LinkedMap都可以。2.比较算子和自然排序的区别  比较算子 (接口)Comparator,通过实现它能让集合元素按非自然顺序排序。原理就是定义           集合内两元素相互比较的规则。    自然排序 集合里头的对象要自然排序，必须实现 compara
详解Java中的Collection单列集合（从底层到用法超详细解析和细节分析）
q251932440的博客
10-02 1434
在 Java 中，集合框架是开发过程中最常用的数据结构之一，其中 Collection 接口是整个集合框架的基础。Collection 是处理单列数据的接口，它定义了一些通用的操作，允许对一组对象进行操作。今天我们将深入介绍 Java 中的单列集合 Collection 接口，以及它的常见子接口和实现类。
java 中Collection存储器详解及简单实例
08-30
Java中的`Collection`存储器是Java集合框架的核心接口，它代表了一组对象，这些对象也被称为集合。本文将详细介绍`Collection`接口及其主要实现类，并提供简单的实例来帮助理解。 首先，`Collection`接口是所有单列...
java 的Collection接口实例详解
09-02
在Java编程语言中，`Collection`接口是集合框架的顶级接口，它是所有单列集合（single-element collections）的基础。这个接口定义了一组通用的方法，用于操作一组对象。`Collection`接口提供了基本的增、删、查、改...
Java集合排序及java集合类详解(Collection、List、Map、Set)讲解.pdf
02-12
Java集合排序及java集合类详解(Collection、List、Map、Set)讲解 Java集合框架是Java语言中最重要的组件之一，能够正确使用Java集合框架对于Java程序的开发具有无比的好处。本文将详细解释Java集合框架的实现原理、...
Java(Collection_List_Map_Set).rar_java集合类详解
09-24
Java集合框架是Java编程语言中的一个核心组件，它为存储、管理和操作对象提供了一组统一的接口和类。本篇文章将深入探讨Java集合类，包括Collection、List、Map和Set，以及它们之间的关联和排序机制。 首先，让我们...
Java中对对象排序
2301_79842503的博客
07-29 1144
在Java中，对对象进行排序通常可以通过两种方式实现：一种是使用Comparable接口，另一种是使用Comparator接口。这两种方式各有特点，适用于不同的场景。
对象排序（Java）
学习笔记
05-31 315
结构体_对象排序;
java Collection.sort
FTMin的博客
11-27 614
第一种方法，Bean中实现Comparator接口   public class CollectionsClass {          /**       * @param args       */       public static void main(String[] args) {           List list = new ArrayList();  //Be
Java Collection 排序&遍历
皮酱的博客
07-02 285
1. List 遍历 import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Test { public static void main(String[] args) { List<Integer> list = new ArrayList<>(); list.add(9); list.add(
Java集合中用Collections排序
Joseph的博客
06-13 1716
Collections 简介及常用功能 java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下： public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。 public static void shuffle(List<?> list):打乱集合顺序。 public static <T> void sort(List<T&g
Java Collections类排序学习
山塘小鱼儿的博客
01-08 1016
其中Java语言的Collection.sort在JDK1.6使用的是普通的归并排序，归并排序虽然时间复杂度低，但是空间复杂度要求较高，所以从JDK1.7开始就更改为了TimSort算法。Timsort 的时间复杂度是 O(n log n)，与归并排序的时间复杂度相同，那它的优势是啥呢，实际上可以认为TimSort排序算法是归并排序算法的优化版，从它的三个特征就可以看出，第二个特征“混合的”，没错，它不单纯是一种算法，而是融合了归并算法和二分插入排序算法的精髓，因此能够在排序性能上表现优异。
Java8collection.sort_java8的新特性，Collections.sort(排序的List集合)的使用，对list封装Map里面的某个值进行排序...
weixin_34335039的博客
02-13 296
--------------------------对简单list的排序----------------------------------List list = new ArrayList<>();list.add(1);list.add(2);list.add(3);list.add(4);Collections.sort(list)排序前是：1233排序后：4321-------...
Java Collections的sort排序详解
最新发布
分享我的点点滴滴，在成长路上与你同行！
04-07 777
Java Collections的sort排序详解
java中Collection集合元素的排序：自定义Comparator接口作为匿名内部类，重写compare()方法进行排序
weixin_46591816的博客
10-28 1752
集合的排序
Java中文对象排序技术详解与SortedSet源码解析
在Java编程语言中，对象排序是一个常见需求，尤其在处理集合数据时。在Java集合框架中，`SortedSet`接口专门用于有序集合的管理，当涉及到中文字符的排序时，更需要深入了解其背后的机制和实现方式。本知识点将围绕...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值