Java学习笔记-Day26 Java 比较器、Arrays类、Collections类

 
 

一、比较器

 
Java的比较器分为内部比较器（Comparable接口）和外部比较器（Comparator接口）。

一个类想要支持排序，就必须要实现内部比较器（Comparable接口）或者拥有自定义的外部比较器（Comparator接口）。

如果一个数组或者集合想要实现排序的功能，那么这个数组或者集合所存储的数据的类必须要实现Comparable接口或者拥有自定义的比较器。

数组和集合中存放基本类型和包装类型的数据都能进行排序，是因为其包装类都实现了Comparable接口。
 

1、内部比较器

 
内部比较器（java.lang.Comparable）（Comparable接口< T >）：当需要对某个类的对象进行排序的时候，则需要该类实现comparable接口，并重写comparaTo方法。实现Comparable接口的类的对象数组，可使用Arrays.sort(数组)方法进行排序。实现Comparable接口的类的对象集合，可使用Collections.sort(集合)方法进行排序。
 
步骤：
（1）为 需要排序的类 实现Comparable接口，泛型指定为需要排序的类。

（2）在 需要排序的类 中重写compareTo方法。

（3）在compareTo()方法内定义比较算法，根据大小关系，返回正数、负数或0。

Comparable接口的compareTo方法
 
int compareTo(T o)：将 当前对象 与 指定对象o 比较，以进行排序。 返回一个正整数表示 当前对象 大于 指定对象o ，返回一个0表示 当前对象 等于 指定对象o ，返回一个负整数表示 当前对象 小于 指定对象o 。

如果进行排序的类没有实现Comparable接口，运行时将抛出 ClassCastException。

一个类实现Comparable这个内部比较器后，该类支持排序，然而只能有一种排序逻辑，受到限制。

// Student类实现内部比较器
public class Student implements Comparable<Student> {
	private int id;
	private String name;
	private int age;
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
	@Override
	public int compareTo(Student o) {
		//升序排序
		return this.getId() < o.getId() ? -1 : this.getId() == o.getId() ? 0 : 1;
		//降序排序
		//return o.getId() < this.getId() ? -1 : o.getId() == this.getId() ? 0 : 1;
	}
}

 

2、外部比较器

 
外部比较器（java.util.Comparator）（Comparator接口< T >）：可以是单独一个类的形式，也可以是匿名内部类的形式，然后在类中重写compare方法。可对对象的数组使用Arrays.sort(数组，比较器)方法。实现Comparator接口的一个比较器（类）和一个对象的数组，可使用Arrays.sort(数组，比较器)方法对数组进行排序。实现Comparator接口的一个比较器（类）和一个对象的集合，可使用Collections.sort(集合，比较器)方法对集合进行排序。

步骤：
（1）创建一个实现Comparator接口的类，泛型指定为需要排序的类。

（2）在类中重写compare方法（因为每个类中都有equals方法，所以可以不重写equals方法）。

（3）在compare方法内定义比较算法，根据大小关系，返回正数、负数或0。

Comparator接口的compare方法
 
int compare(T o1,T o2)：比较其两个参数的顺序。 返回一个正整数表示第一个参数大于第二个参数，返回一个0表示第一个参数等于第二个参数，返回一个负整数表示第一个参数小于第二个参数。

Comparator接口的equals方法
 
boolean equals(Object obj) ：值相等返回true，值不相等返回false。

使用外部比较器Comparator，可以灵活为类定义多种比较器，此时类本身不需要实现Comparable接口。

• 以单独一个类的形式存在

//Teacher类的外部比较器
public class IdTeacherComparator implements Comparator<Teacher> {

	@Override
	public int compare(Teacher o1, Teacher o2) {
		return o1.getId() < o2.getId()?-1:o1.getId() == o2.getId()?0:1;
	}
	
}
//Teacher类（需要进行排序的类）
class Teacher {
	int id;
	String name;
	int age;
	@Override
	public String toString() {
		return "Teacher [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
}

• 以匿名内部类的形式存在

	Collections.sort(list,new Comparator<Teacher>() {
		@Override
		public int compare(Teacher o1, Teacher o2) {
			//升序排序
			return o1.getId() < o2.getId()?-1:o1.getId()==o2.getId()?0:1;
			//降序排序
			//return o2.getId() < o1.getId()?-1:o2.getId()==o1.getId()?0:1;
		}
	});

 

二、Arrays类

 
Arrays类（java.util.Arrays）是一个针对数组进行操作的工具类，其中提供了对 对象的数组 进行排序的方法，将自定义类的对象存放到数组时，按照自定义的方式去排序。
 

1、排序方法

 
两个常用的对象数组排序方法如下：

（1）static void sort(Object[] a) ：对数组a进行排序，a中的元素必须实现Comparable接口。

（2）static void sort(T[] a, Comparator c) ：对数组a进行排序，比较逻辑在外部比较器c中定义。
 

三、Collections类

 
Collections（java.util.Collections）是针对集合类的一个帮助类，它提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
 

1、排序方法

 
Collections类也提供了sort()方法对集合内部中的元素按照元素的自然排序方式进行排序。

（1）static > void sort(List list)：根据元素的自然顺序对指定列表按升序进行排序。

（2）static void sort(List list, Comparator c)：根据指定比较器产生的顺序对指定列表进行排序。
 

2、获取集合的线程安全版本的方法

 
集合框架中的新工具大多是非同步的，如果在并发环境中直接访问可能会导致各种问题，而Vector、Hashtable等旧工具还继续保留的主要原因是为了维持向下兼容。因此我们希望能够获取新的集合工具的线程安全版本，而Collections工具类则为我们提供了这方面的支持。

部分方法：

static List synchronizedList(List list)：返回由指定列表支持的同步（线程安全）列表。

static Map synchronizedMap(Map m)：返回由指定地图支持的同步（线程安全）映射。

synchronizedSet(Set s)：返回由指定集合支持的同步（线程安全）集。
 

3、转换的问题

 
如果集合中存储的元素是数字形式的字符串，如果想要以数字的排序方式进行元素的排序，需要在Comparable的compareTo方法中或者Comparator的compare方法中，将字符串通过Integer.parseInt静态方法转换成int类型，再进行比较排序。

public class TestCollections {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add("51");
		list.add("21");
		list.add("9");
		list.add("15");
		list.add("17");
		list.add("10");
		Collections.sort(list, new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				int i1 = Integer.parseInt(o1);
				int i2 = Integer.parseInt(o2);
				return i1 > i2 ? -1 : i1 == i2 ? 0 : 1;
			}
		});
		System.out.println(list);
	}
}