在本文中就不介绍基本数据类型之间的比较了，自定义的对象类型进行比较时，java中常见的比较器方法主要是有以下几种。

1、覆写Object类的equals方法

如果一个自定义的对象类中没有覆写equals方法，这是使用equals进行比较两个对象与使用"=="是一样的，都是比较的是两个对象的地址(即两个对象是否为同一个对象)；
如果覆写了equals()方法，则是比较其中的属性值是否相等。下面以People类来举例：

public class People{
	public People(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	private String name;
	private int age;
	//....getter and setter
}

测试：

	@Test
	public void testPeople1() {
		People people=new People("zhangsan",11);
		People people1=new People("zhangsan",11);
		System.out.println(people.equals(people1));
	}
	输出结果为：false

在上述的People类中覆写equals()，如下所示：

public class People {
	
	public People(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		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 (getClass() != obj.getClass())
			return false;
		People other = (People) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

	private String name;
	private int age;
	//....getter and setter
}

测试代码与上述的一致，此时返回的结果就为：true

2、实现Comparable接口

使用Comparable的时候需要在你需要排序的类里边实现该接口，例如我们使用TreeSet来存储数据的时候，对于我们自定义的类就需要实现该接口来说明一下排序的规则，一般类型如String、Integer等则不需要，因为其已经实现了该接口。

public class People implements Comparable<People>{
	
	@Override
	public String toString() {
		return "People [name=" + name + ", age=" + age + "]";
	}

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

	private String name;
	private int age;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

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

	@Override
	public int compareTo(People o) {
		if (this.age>o.age) {
			return 1;
		}else if (this.age<o.age) {
			return -1;
		}else {
			return 0;
		}
	}
}

测试：

	@Test
	public void testPeople() {
		Set<People> set=new TreeSet<>();
		set.add(new People("张三",112));
		set.add(new People("李四", 23));
		for (People people : set) {
			System.out.println(people);
		}
	}

打印结果:

People [name=李四, age=23]
People [name=张三, age=112]

如果是需要倒序的话，只需改变compareTo()的策略即可，如下：

	@Override
	public int compareTo(People o) {
		if (this.age>o.age) {
			return -1;
		}else if (this.age<o.age) {
			return 1;
		}else {
			return 0;
		}
	}

输出结果为：

People [name=张三, age=112]
People [name=李四, age=23]

3、可以单独建立一个对象比较器类，来实现Comparator接口

实现Comparator接口的方法需要单独构建一个比较器类，如下所示：

public class StudentCompator implements Comparator<Student> {

	@Override
	public int compare(Student o1, Student o2) {
		int i=0;
		// 按照年龄正序
		//i=o1.getAge()-o2.getAge();
		// 按照年龄倒序
		i= o2.getAge()-o1.getAge();
		return i;
	}
}

自定义的Student类，代码如下：

public class Student {

	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}	
}

使用：

public class StudentTest {

	@Test
	public void testStudent() {
		Set<Student> set=new TreeSet<>(new StudentCompator());
		set.add(new Student("张三",112));
		set.add(new Student("李四", 23));
		for (Student student : set) {
			System.out.println(student);
		}
	}
}

打印输出结果：

Student [name=张三, age=112]
Student [name=李四, age=23]

方法2和3的主要区别在于，方法2中需要去修改要进行比较的自定义的类中的代码，而方法3则不需要去修改。
参考文章：JAVA comparable的使用方法与实例