HashSet和TreeSet有什么区别？

HashSet：
不能保证元素的排列顺序，顺序有可能发生变化
集合元素可以是null,但只能放入一个null
HashSet底层是采用HashMap实现的
HashSet底层是哈希表实现的

TreeSet：
Treeset中的数据是排好序的，不允许放入null值。
TreeSet是通过TreeMap实现的,只不过Set用的只是Map的key。
TreeSet的底层实现是采用二叉树（红-黑树）的数据结构。

参考代码： HashSetTest TreeSetTest TreeSetStudentTest

// Set的使用(不允许有重复的对象),可以是null,但只能放入一个null
public class HashSetTest {
	public static void main(String[] args) {
		HashSet<String> hashSet = new HashSet<String>();
		String a = new String("A");
		String b = new String("B");
		String E = new String("E");
		String F = new String("F");
		String c = new String("B");
		String h = null;
		String i = null;
		hashSet.add(a);
		hashSet.add(b);
		hashSet.add(E);
		hashSet.add(F);
		hashSet.add(h);
		hashSet.add(i);
		System.out.println("hashSet得长度：" + hashSet.size());
		
		// 元素B已经存在，插入时不在插入
		String cz = hashSet.add(c) ? "此对象不存在" : "已经存在";
		System.out.println("测试是否可以添加对象: " + cz);
		
		// 测试其中是否已经包含某个对象
		System.out.println("hashSet中包含A：" + hashSet.contains("A"));
		Iterator<String> iter = hashSet.iterator();
		while (iter.hasNext()) {
			System.out.println("hashSet中的元素：" + iter.next());
		}
		// 测试某个对象是否可以删除
		System.out.println("删除不存在的元素e:" + hashSet.remove("e"));
		System.out.println("删除存在的元素E:" + hashSet.remove("E"));
		System.out.println();
		// 如果你想再次使用iter变量,必须重新更新,重新获取
		iter = hashSet.iterator();
		while (iter.hasNext()) {
			System.out.println("删除存在的元素E后:" + iter.next());
		}
	}
}

// 有序的
public class TreeSetTest {
	
	public static void main(String[] args) {
		TreeSet<String> tree = new TreeSet<String> ();
		tree.add("China");
		tree.add("America");
		tree.add("Japan");
		tree.add("Chinese");
		tree.add("Diio");
		Iterator<String> iter = tree.iterator();
		while (iter.hasNext()) {
			System.out.println(iter.next());
		}
	}
}

/**
 * 测试TreeSet存储自定义对象，并对对象排序的两种方式
 */
public class TreeSetStudentTest {

	public static void main(String[] args) {
		System.out.println("下面是元素实现Comparable接口=====");
		TreeSet<Student> ts = new TreeSet<Student>();
		ts.add(new Student("zhangsan01", 25));
		ts.add(new Student("zhangsan02", 21));
		ts.add(new Student("zhangsan03", 18));
		ts.add(new Student("zhangsan04", 26));
		ts.add(new Student("zhangsan04", 27));
		ts.add(new Student("zhangsan04", 27));
		ts.add(new Student("zhangsan05", 50));

		Iterator<Student> it = ts.iterator();
		while (it.hasNext()) {
			Student stu = (Student) it.next();
			System.out.println("姓名：" + stu.getName() + " 年龄：" + stu.getAge());
		}
		
		
		System.out.println("下面是用自定义比较器类来实现比较的=====");
		TreeSet<Student> tsc = new TreeSet<Student>(new MyCompare());
		tsc.add(new Student("zhangsan01", 25));
		tsc.add(new Student("zhangsan02", 21));
		tsc.add(new Student("zhangsan03", 18));
		tsc.add(new Student("zhangsan04", 26));
		tsc.add(new Student("zhangsan04", 27));
		tsc.add(new Student("zhangsan04", 27));
		tsc.add(new Student("zhangsan05", 50));
		
		Iterator<Student> itc = tsc.iterator();
		while (itc.hasNext()) {
			Student stu = (Student) itc.next();
			System.out.println("姓名：" + stu.getName() + " 年龄：" + stu.getAge());
		}

	}

}

class Student implements Comparable<Object> {
	private String name;
	private int age;

	public Student(String name, int age) {
		this.name = name;
		this.age = age;
	}
	
	/**
	 * 年龄和名称都相等的时候
	 */
	@Override  
    public boolean equals(Object obj) {  
        if (this == obj)  
            return true;  
        if (obj == null)  
            return false;  
        if (getClass() != obj.getClass())  
            return false;  
        Student other = (Student) 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;  
    }  
	
	@Override  
    public int hashCode() {
        final int prime = 31;  
        int result = 1;  
        result = prime * result + age;  
        result = prime * result + ((name == null) ? 0 : name.hashCode());  
        System.out.println("hashCode : "+ result);  
        return result;  
    }  

	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;
	}

	public int compareTo(Object obj) {
		if (!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");

		// 先按照年龄，之后看名称
		Student stu = (Student) obj;
		if (this.age > stu.age)
			return 1;
		if (this.age == stu.age)
			return this.name.compareTo(stu.name);
		return -1;
	}
}

// 自定义比较类
class MyCompare implements Comparator<Object>   {  
    public int compare(Object o1,Object o2) {  
        Student s1 = (Student) o1;  
        Student s2 = (Student) o2;  
        // 先按名称，之后看年龄
        int num = s1.getName().compareTo(s2.getName());  
        if( num == 0 )  
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));  
        return num;  
    }  
}  

说明：
HashSet：
当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据 hashCode值来决定该对象在HashSet中存储位置，如果相等，那就不能插入，如果不等，才会调用equals()方法，如果equals结果为true，说明已经存在，就不能再插入，如果为false，可以插入。
简单的说，HashSet集合判断两个元素相等的标准是两个对象通过equals方法比较相等，并且两个对象的hashCode()方法返回值相等。
注意，如果要把一个对象放入HashSet中，重写该对象对应类的equals方法，也应该重写其hashCode()方法。其规则是如果两个对象通过equals方法比较返回true时，其hashCode也应该相同。另外，对象中用作equals比较标准的属性，都应该用来计算 hashCode的值。

TreeSet：
TreeSet是怎么实现有序的，它是按什么规则排序的？
TreeSet的底层实现是采用红-黑树的数据结构，采用这种结构可以从Set中获取有序的序列，但是前提条件是：元素必须实现Comparable接口，该接口中只用一个方法，就是compareTo()方法。当往Set中插入一个新的元素的时候，首先会遍历Set中已经存在的元素，并调用compareTo()方法，根据返回的结果，决定插入位置。进而也就保证了元素的顺序。
TreeSet是SortedSet接口的唯一实现类，TreeSet可以确保集合元素处于排序状态。TreeSet支持两种排序方式，自然排序 和定制排序，其中自然排序为默认的排序方式。向TreeSet中加入的应该是同一个类的对象。
TreeSet判断两个对象不相等的方式是两个对象通过equals方法返回false，或者通过CompareTo方法比较没有返回0
自然排序
自然排序使用要排序元素的CompareTo（Object obj）方法来比较元素之间大小关系，然后将元素按照升序排列。
Java提供了一个Comparable接口，该接口里定义了一个compareTo(Object obj)方法，该方法返回一个整数值，实现了该接口的对象就可以比较大小。
obj1.compareTo(obj2)方法如果返回0，则说明被比较的两个对象相等，如果返回一个正数，则表明obj1大于obj2，如果是 负数，则表明obj1小于obj2。
如果我们将两个对象的equals方法总是返回true，则这两个对象的compareTo方法返回应该返回0
定制排序
自然排序是根据集合元素的大小，以升序排列，如果要定制排序，应该使用Comparator接口，实现 int compare(T o1,T o2)方法。