TreeSet集合两种排序方式

在使用TreeSet集合时，存在两种排序：

1、  自然排序。 存储的元素自身必须实现Comparable接口，并重写接口中的compareTo方法

2、  比较器排序(强制排序) 。 使用Comparator对象强制对要存储的元素进行排序。需要在创建TreeSet集合时，要构造函数中指定比较器对象

            

让我们首先看看TreeSet集合的自然排序方式。看一个例子：

案例：使用TreeSet集合存储Person对象，按照Person对象中的年龄进行排序

核心要点：让存储的元素对象Person，实现java.lang.Comparable接口，并重写该接口中的compareTo方法

1）定义一个Person类

<pre name="code" class="java">package com.review.demo2;
//实现Comparable接口，重写接口中的compareTo方法
public class Person implements Comparable {
		private String name;
		private int age;
		@Override
		public int compareTo(Object o) {
			//判断传递的是否为Person类型
			if (! (o instanceof Person)) throw new RuntimeException("类型不匹配！");
				Person p = (Person)o;
				return this.age-p.age;
		}
		@Override
		public String toString() {
			return "Person [name=" + name + ", age=" + 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 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;
			Person other = (Person) 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;
		}
		public Person(String name, int age) {
			super();
			this.name = name;
			this.age = age;
		}
	
}

2）

<span style="color:#33ccff;">package com.review.demo2;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class TreeSetDemo{
	public static void main(String[] args) {
		
		Set set = new TreeSet();
		set.add(new Person("张三",12));
		set.add(new Person("李四",20));
		set.add(new Person("王五",10));
		set.add(new Person("赵六",40));
		//遍历set结合
		for (Iterator it = set.iterator(); it.hasNext();) {
			Person p = (Person) it.next();
			System.out.println(p);
		}
	}
}</span>

下面为输出结果：

Person [name=王五, age=10]
Person [name=张三, age=12]
Person [name=李四, age=20]
Person [name=赵六, age=40]

从上面结果可以看出，的确实现了按照年龄排序！

看完了TreeSet集合的自然排序，再看看比较器排序(强制排序)

也许你会有疑问，我们有了自然排序了，为什么还需要比较器排序呢，

为什么已经存在了自然排序方式，还需要比较器排序做什么呢？

      在某些要存储的元素中，元素本身不具备自然排序方式，会考虑使用比较     器对象

      要存储的元素本身已经具备自然排序了，但是因为一些原因，需要使用其它的规则排序而又不能重写自然排序的方法。

例：String类，本身具备Comparable接口，并重写了compareTo方法，但是因为String类属于final，所以不能再次重写String类中的compareTo方法

案例：使用比较器对象实现按Person对象中的姓名进行排序

<span style="color:#33ccff;">package com.review.demo2;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

//创建一个实现比较器接口的实现类
class MyComparator implements Comparator{
	public int compare(Object obj1,Object obj2){
		//判断传递的参数书否为Person类型
		if(!(obj1 instanceof Person&& obj2 instanceof Person)) throw new ClassCastException("类型不匹配！");
		Person   p1  = (Person)obj1;
		Person   p2  = (Person)obj2;
		return p1.getName().compareTo(p2.getName());
	}
}
public class TreeSetDemo3 {
	/**
	 * 案例：使用比较器对象实现按Person对象中的姓名进行排序
	 */
	public static void main(String[] args) {
		// 创建TreeSet集合对象，并在构造函数中指定比较器对象
		TreeSet set = new TreeSet(new MyComparator());
		
		set.add(new Person("zhangsan",20));
		set.add(new Person("lisi,28));
		set.add(new Person("wangwu",22));
		set.add(new Person("zhaoliu",120));
		
		//遍历输出集合元素
		for (Iterator it = set.iterator(); it.hasNext();) {
			Person p = (Person) it.next();
			System.out.println(p);
		}
	}

}
</span>

运行结果：

Person [name=lisi, age=28]
Person [name=wangwu, age=22]
Person [name=zhangsan, age=20]
Person [name=zhaoliu, age=120]

可以看出通过比较器排序，真的实现了对Person对象按照姓名排序