非稳定排序推荐使用list(整理)(五)

Set 和 list 最大的区别是Set中元素不可重复（这个重复指的是equals返回值相同），Set中的常用类TreeSet，该类实现了类默认排序为升序的Set集合，会在插入元素过程中按照升序排列（当然根据Comparable接口中的compareTo返回值确定排序的位置），不过这种方法不适合在元素经常变化的场景中使用，来看下边的例子：

普通pojo类，实现Comparable接口，重现compareTo,equals和hashCode

package sort;

public class Person implements Comparable<Person>{
	
	private int height;
	
	public Person(int _age) {
		height = _age;
	}
	
	
	public int getHeight() {
		return height;
	}


	public void setHeight(int height) {
		this.height = height;
	}


	@Override
	public int compareTo(Person o) {
		// TODO Auto-generated method stub
		return height - o.height;
	}


	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + height;
		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 (height != other.height)
			return false;
		return true;
	}
	
}

 测试代码

package sort;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

public class SortTest {
	public static void main(String[] args)throws Exception  {
		SortedSet<Person> set = new TreeSet<Person>();
		//加入集合时进行排序
		set.add(new Person(180));
		set.add(new Person(175));
		
		set.first().setHeight(185);
		//set重排序
		set = new TreeSet<Person>(new ArrayList<Person>(set));
		for(Person p:set) {
			System.out.println(" 身高:"+p.getHeight());
		}
		
		sortList(new Person(190),new Person(180),new Person(175));
	}
	/**
	 * <b>function:</b>list 排序，去重，，泛型等
	 * @param <T>
	 * @param t
	 * @throws Exception
	 */
	public static <T extends Comparable<T>> void sortList(T... t)throws Exception {
		List<T> list = new ArrayList<T>();
		for(T tmp : t) {
			list.add(tmp);
		}
		
		Method method = null;
		for(int i=0,n=list.size();i<n;i++) {
			method = list.get(i).getClass().getMethod("getHeight");
			System.out.println("身高： "+method.invoke(list.get(i)));;
		}
		
		Set<T> set = new HashSet<T>(list);	//Person实现equal 和hashCode
		for(T tmp:set) {
			method = tmp.getClass().getMethod("getHeight");
			System.out.println("set身高： "+method.invoke(tmp));;
		}
	
		Collections.sort(list);			//排序
		for(int i=0,n=list.size();i<n;i++) {
			method = list.get(i).getClass().getMethod("getHeight");
			System.out.println("身高： "+method.invoke(list.get(i)));;
		}
	}
}

 此处补贴出测试结果，读者可以下去做实验。

总结：对于不变量的排序，例如直接量（8个基本类型）、String类型等，推荐使用TreeSet,而对于可变量，则推荐list自行排序。