Comparable和Comparator实现自定义排序

参考：https://blog.csdn.net/JQ_AK47/article/details/61203817

 

Comparable接口

只有一个方法  compareTo()

Comparable是一个内部比较器，很多类都会实现这个接口去实现自己默认的排序，如果我们自己定义一个类，需要按照我们自己的定义的方式来进行排序的话，就可以使用Comparable接口，编写自己的compareTo方法，使用Collections工具类的sort方法进行排序

     如果想要使用Collections.sort()方法，需要实现Comparable接口的CompareTo方法

较者(调用compareTo方法者)大于被比较者（也就是compareTo方法接受对象）

compareTo 返回值

1. 正数：比较者（调用comoareTo方法者）大于被比较者（compareTo方法接受对象）
2. 0 ： 比较者等于被比较者
3. 负数：比较者小于被比较者

 

例子：按照用户的年龄排序

1、用户的实体类

package com.tk.compare;

//实现comparable接口  ，并且添加未实现方法  compareTo
public class User implements Comparable<User> {
	public int id;		//学号
	public int age;		//年龄
	
	public User(int id, int age) {
		super();
		this.id = id;
		this.age = age;
	}

	@Override
	public String toString() {
		return "User [id=" + id + ", age=" + age + "]";
	}

	@Override
	public int compareTo(User o) {
		if(this.age == o.age)
			return 0;
		else return this.age > o.age ? 1 : -1;
	}
}

2、测试类

package com.tk.compare;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * 实现Comparable自定义排序测试类
 * @data :2019-5-11下午8:53:53
 * @author :田坤
 */
public class ComparableTest {

	public static void main(String args[]) {
		
		List<User> lu = new ArrayList<>();
		lu.add(new User(111, 80));
		lu.add(new User(120, 90));
		lu.add(new User(135, 75));
		lu.add(new User(108, 89));
		
		System.out.println("排序前:");
		for (User user : lu) {
			System.out.println(user);
		}
		
		Collections.sort(lu);
		System.out.println("排序后：");
		for (User user : lu) {
			System.out.println(user);
		}
		
		
	}
}

排序前:
User [id=111, age=80]
User [id=120, age=90]
User [id=135, age=75]
User [id=108, age=89]
排序后：
User [id=135, age=75]
User [id=111, age=80]
User [id=108, age=89]
User [id=120, age=90]

 

例子：对于String的排序（汉字也可以）

String本身实现了Comparable方法，并且编写了对应的compareTo（）；

package com.tk.compare;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class StringComparableTest {
	
	public static void main(String args[]) {
		List<String> ls = new ArrayList<String>();
		ls.add("bbbb");
		ls.add("cccc");
		ls.add("aaaa");
		ls.add("田坤");
		ls.add("啊啊");
		
		System.out.println("字符串排序前：");
		for (String string : ls) {
			System.out.println(string);
		}
		
		Collections.sort(ls);
		System.out.println("字符串排序后：");
		for (String string : ls) {
			System.out.println(string);
		}
	}
}

字符串排序前：
bbbb
cccc
aaaa
田坤
啊啊
字符串排序后：
aaaa
bbbb
cccc
啊啊
田坤

 

 

Comparator

comparator可以认为是一个外比较器，认为有俩种情况可以使用Comparator接口的方式：

• 一个对象不支持自己和自己比较（没有实现Comparable接口），但是又想对两个对象进行比较；一般同类型对象比较很少实现这个接口。
• 一个对象实现了Comparable接口，但是开发者认为compareTo方法中的比较方式并不是自己想要的那种比较方式。Comparator接口更多是实现这个功能。对特定比较需求提供支持。

int    compare（T o1, T  o2）

Comparator接口里面有一个compare方法，方法有两个参数T o1和T o2，是泛型的表示方式，分别表示待比较的两个对象，方法返回值和Comparable接口一样是int，有三种情况：

    1、o1大于o2，返回1

    2、o1等于o2，返回0

    3、o1小于o3，返回-1

 

例子：以例子一为例：

1、不实现Comparable接口

package com.tk.compare;

/**
 * 实现Comparator自定义排序测试类
 * @data :2019-5-11下午9:25:45
 * @author :田坤
 */
public class Student {

	public int id;
	public String name;
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + "]";
	}
	public Student(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
}

2、编写一个实现了Comparator的类

package com.tk.compare;

import java.util.Comparator;

/**
 * 编写comparator排序的实现
 * @data :2019-5-11下午9:26:55
 * @author :田坤
 */
public class UserComparator implements Comparator<User>{

	@Override
	public int compare(User o1, User o2) {
		if(o1.age == o2.age)
			return 0;
		else return o1.age > o2.age ? 1 : -1;
	}
}

3、测试方法和例子是是一样的；只是Collections.sot（）的参数值发生变化

                 Collections.sort(lu,new UserComparator());