Comparator and Comparable

java.util.concurrent.PriorityBlockingQueue.comparator()
java.util.PriorityQueue.comparator()
java.util.SortedMap.comparator()
java.util.SortedSet.comparator()
java.util.TreeMap.comparator()
java.util.TreeSet.comparator()

在TreeSet和TreeMap中添加的自定义对象必须实现Comparable接口
(自定义对象如果要加入到以上这些集合必须实现Comparable接口
或者在在构造函数中指定Comparator接口
)

排序:互换性,传递性,互换抛异常和equal保持一致(非必要)

 

 

Comparable<User-defined Object T>:
 public int compareTo(T o);

Comparator<User-defined Object T>:
 public int compare(T o1, T o2)
 public int cequal(T o1,T o2)

 

TreeSet(Collection<? extends E> c)

 

================

Comparator和Comparable的区别

  先看一下使用Comparator对User集合实现排序的方式：一个类实现了Camparable接口则表明这个类的对象之间是可

以相互比较的，这个类对象组成的集合就可以直接使用sort方法排序。

Comparator可以看成一种算法的实现，将算法和数据分离，Comparator也可以在下面两种环境下使用：

 

1、类的设计师没有考虑到比较问题而没有实现Comparable，可以通过Comparator来实现排序而不必改变对象本身
2、可以使用多种排序标准，比如升序、降序等

 

在TreeSet和TreeMap中添加的自定义对象必须实现Comparable接口,否则调用任何方法都回出错
或者new的时候加入Comparator实例

对象o必须实现Comparable接口或者加入Comparator实例
Collections.sort( c<o>);

Arrays.sort( o[] );

===================
Arrays:
asList
binarySearch
equals
fill
hashCode
sort
toString

deepEquals(Object[] a1, Object[] a2)
deepHashCode(Object[] a)
deepToString(Object[] a)

 

 

 

package samples;

import java.text.Collator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import java.util.TreeSet;

public class TestCompare {
	public static void main(String[] args) {
		/*
		 * Constructs a new set containing the elements in the specified
		 * collection, sorted according to the elements' natural order
		 * 如果User没有实现Comparable接口,会报错
		 */
		TreeSet<User> ts1 = new TreeSet<User>(User.initUsers());
		System.out.println(ts1.size());

		TreeSet<User> ts2 = new TreeSet<User>(new AgeComparator());
		ts2.add(new User("张三", 25));
		ts2.add(new User("李四", 26));
		ts2.add(new User("王五", 21));
		System.out.println(ts2.size());
		populateSet(ts2);


		/*中文排序JAVA有好的结局方案么?
		 * http://www.iteye.com/topic/81640
		 */
		
		TreeSet<User> ts3 = new TreeSet<User>(new NameComparator());
		ts3.add(new User("张三", 25));
		ts3.add(new User("李四", 26));
		ts3.add(new User("王五", 21));
		System.out.println(ts3.size());
		populateSet(ts3);

		TreeSet<User> ts4 = new TreeSet<User>(new NameComparator2());
		ts4.add(new User("张三", 25));
		ts4.add(new User("李四", 26));
		ts4.add(new User("王五", 21));
		System.out.println(ts4.size());
		populateSet(ts4);
		
		/*
		 * End 中文排序
		 */
		List<User> l = User.initUsers();
		/*
		 * 参见Array List转换,直接写会报错的
		 * User[] users = (User[])(l.toArray());
		 * 
		 * */
		User[] users = new User[l.size()];
		users = (User[])(l.toArray(users));
		
		l.get(0).setAge(100);
		
		/*
		 * 如果User对象没有实现comparable接口,这个方法不能过编译
		 * Collections.sort(l);
		 */
		Collections.sort(l, new AgeComparator());
		populateList(l);
		
		/*
		 * User必须实现Comparable接口,调用这个方法
		 */
		Arrays.sort(users);
		
		for(User u :users){
			System.out.print(u.getName()+" ");
			System.out.print(u.getAge()+" ");
		}
		System.out.println();
		
		
	}

	public static void populateSet(Set<User> s) {
		Iterator<User> iter = s.iterator();
		while (iter.hasNext()) {
			User u = iter.next();
			System.out.print(u.getName() + "  ");
			System.out.print(u.getAge() + "  ");
		}
		System.out.println();
	}
	
	public static void populateList(List<User> l) {
		Iterator<User> iter = l.iterator();
		while (iter.hasNext()) {
			User u = iter.next();
			System.out.print(u.getName() + "  ");
			System.out.print(u.getAge() + "  ");
		}
		System.out.println();
	}
}

/*
 * Comparable<User>
 * 
 * 如果不实现这个接口的话,调用任何TreeSet/TreeMap的方法都会报错 String等等已经实现了这个接口
 */
class User implements Comparable<User> {
	private String name;

	private int age;
	
	//private Date birthday = null ;

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

	/*
	 * return List<User>
	 */
	public static List<User> initUsers() {
		List<User> l = new ArrayList<User>();
		l.add(new User("张三", 25));
		l.add(new User("李四", 26));
		l.add(new User("王五", 21));

		return l;
	}

	/*
	 * 
	 * 导致的结果就是所有的对象都一致 TreeSet,TreeMap来说,根据compareTo来判定是否是同一个对象 或者 Map的key
	 * ts.size();永远是1,不管放入多少对象
	 */
	public int compareTo(User u) {
		return 0;
	}

	public int getAge() {
		return age;
	}

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

	public String getName() {
		return name;
	}

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

}

class AgeComparator implements Comparator<User> {
	public int compare(User u1, User u2) {
		return u1.getAge() - u2.getAge();
	}
}

class NameComparator implements Comparator<User> {
	/*
	 * 
	 * 中文排序错误
	 */
	public int compare(User u1, User u2) {
		/*
		 * String already implemented Comparable Interface
		 */
		return u1.getName().compareTo(u2.getName());
	}
}

/*
 * The Collator class performs locale-sensitive String comparison. You use this
 * class to build searching and sorting routines for natural language text
 */
class NameComparator2 implements Comparator<User> {
	public int compare(User u1, User u2) {

		Collator myCollator = Collator.getInstance(Locale.CHINA);

		return myCollator.compare(u1.getName(), u2.getName());
	}
}