Java_比较和排序

对象的排序

当需要排序的集合或数组不是单纯的数字类型的时候，通常可以使用Comparator或Comparable，以简单的方式实现对象排序或自定义排序。

Comparator和Comparable的区别如下：

• Comparable用在对象本身，说明这个对象是可以被比较的，也就是说可以被排序的。（String和Integer之所以可以比较大小，是因为它们都实现了Comparable接口，并实现了compareTo()方法）。

• Comparator用在对象外面，相当于定义了一套排序算法来排序。

下面通过具体的例子来理解Comparator和Comparable的区别：

Comparable

package com.tianjf;

import java.util.Arrays;

public class User implements Comparable<Object> {

	private String id;
	private int age;

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

	public int getAge() {
		return age;
	}

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

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	@Override
	public int compareTo(Object o) {
		return this.age - ((User) o).getAge();
	}

	/**
	 * 测试方法
	 */
	public static void main(String[] args) {
		User[] users = new User[] { new User("a", 30), new User("b", 20) };
		Arrays.sort(users);
		for (int i = 0; i < users.length; i++) {
			User user = users[i];
			System.out.println(user.getId() + " " + user.getAge());
		}
	}
}

Comparator

package com.tianjf;

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

public class MyComparator implements Comparator<Object> {

	@Override
	public int compare(Object o1, Object o2) {
		return toInt(o1) - toInt(o2);
	}

	private int toInt(Object o) {
		String str = (String) o;
		str = str.replaceAll("一", "1");
		str = str.replaceAll("二", "2");
		str = str.replaceAll("三", "3");
		return Integer.parseInt(str);
	}

	/**
	 * 测试方法
	 */
	public static void main(String[] args) {
		String[] array = new String[] { "一", "三", "二" };
		Arrays.sort(array, new MyComparator());
		for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]);
		}
	}
}

复写equals()的时候一定要复写hashcode()吗？

答案是：不一定。

一般情况下不需要复写hashcode()方法，当用到某些集合（HashSet、LinkedHashSet、HashMap、LinkedHashMap）的时候，一定要复写hashcode()方法，因为这些集合用到了哈希算法，哈希算法一定要用到hashcode()。有关哈希算法可以参考http://blog.csdn.net/tianjf0514/article/details/7709588。

顺便说一下复写equals方法的时候的注意点：

1. 自反性：对于任何一个非空引用x，x.equals(x)应该返回true
2. 对称性：对于任何引用x和y，如果x.equals(y)返回true，那么y.equals(x)也应该返回true
3. 传递性：对于任何引用x、y和z，如果x.equals(y)返回true，y.equals(z)返回true，那么x.equals(z)也应该返回true
4. 一致性：如果x和y引用的对象没有发生变化，那么反复调用x.equals(y)应该返回同样的结果
5. 非空性：对于任何非空引用x，x.equals(null)应该返回false

不要忽视这些规定，如果违反了它们，你会发现你的程序将会表现不正常，甚至崩溃，而且很难找到失败的根源。没有哪个类是孤立的，一个类的实例通常会被频繁地传递给另一个类的实例，有许多类，包括所有的集合类，都依赖于传递给它们的对象是否遵守了equals约定。

下面举一个复写equals()方法的例子：

public boolean equals(Object obj) {
	boolean result = false;

	if (obj == null) {
		result = false;
	}

	if (this == obj) {
		result = true;
	}

	if (obj instanceof Student) {
		Student stu = (Student) obj;
		if (stu.getName().equals(this.name) && stu.getAge() == (this.age)) {
			result = true;
		}
	} else {
		result = false;
	}
	return result;
}