HashSet,TreeSet

HashSet与TreeSet都实现了Set接口，但是它们有一些小区别：

看个程序先：

import java.util.HashSet;
import java.util.Iterator;
import java.util.TreeSet;

public class SetTest
{
        public static void main(String[] args)
        {
            HashSet<String> set = new HashSet<String>();
            
            set.add("a");
            set.add("b");
            set.add("c");
            set.add("b");
            
            String s = new String("e");
            String s1 = new String("e");
            
            set.add(s1);
            set.add(s);
            
            System.out.println(set);
            
            SetTest test = new SetTest();
            
            SetTest test1 = new SetTest();
            
            System.out.println(test.hashCode());
            
            System.out.println(test1.hashCode());
            
            Iterator<String> iter = set.iterator();
            
            while(iter.hasNext())
            {
                String value = (String) iter.next();
                
                System.out.print(value+",");
            }
            
            TreeSet<String> tree = new TreeSet<String>();
            
            tree.add("D");
            tree.add("A");
            tree.add("C");
            tree.add("E");
            
            System.out.println("\n"+tree);
        }
}
程序运行结果如下：

[e, b, c, a]
31275026
9192299
e,b,c,a,
[A, C, D, E]

可以看出，实现了Set接口的HashSet和TreeSet它们对于字符串都不会允许有重复的值存在（不同于实现了List接口的那些类，如：ArrayList,LinkedList），即使这些字符串的引用不同，换句话说，不允许有具有相同HashCode的对象存在于HashSet或TreeSet中。那么对于Object类型的参数来说，字符串的这种判断方式并不适用，即使这些Object类型中所有的变量值和变量类型都一样，如果，真的要忽视引用地址的不同，那么可以重写equeals方法和hashCode方法，但是API不推荐我们修改equeals方法。不同的是HashSet中的值存放不是定序的，而TreeSet中的值是有序的。

另外一个程序：

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

public class CompareTest
{
    
    public static void main(String[] args)
    {
        
        TreeSet<Person> set = new TreeSet<Person>( new MyCompare());
        
         set.add(new Person('C'));
         set.add(new Person('a'));
         set.add(new Person('A'));
         set.add(new Person('B'));
         set.add(new Person('E'));
         set.add(new Person('f'));
    
         System.out.println(set);
        
         for(Iterator< Person> iter = set.iterator();iter.hasNext();)
         {
             String value = iter.next().toString();
            
             System.out.println(value);
            
         }
        
         LinkedList<Integer> link = new LinkedList<Integer>();
        
         link.add(new Integer(5));
         link.add(new Integer(-5));
         link.add(new Integer(-15));
         link.add(new Integer(15));
        
         Comparator< Integer> c = Collections.reverseOrder();//反序方式
        
         Collections.sort(link,c);
        
         for(Iterator< Integer> iter = link.iterator();iter.hasNext();)
         {
             System.out.print(iter.next()+"   ..   ");
         }
        
         Collections.shuffle(link);//乱序
        
         for(Iterator< Integer> iter = link.iterator();iter.hasNext();)
         {
             System.out.print(iter.next()+"/");
         }
        
         System.out.println("\nmax:"+Collections.max(link));
         System.out.println("min:"+Collections.min(link));
    }
}
class MyCompare implements Comparator<Object>
{
    public int compare(Object o1, Object o2)
    {
        String obj1 = o1.toString();
        String obj2 = o2.toString();
        
        return obj2.compareTo(obj1);
    }
}
class Person
{
    char name;
    public Person(char name)
    {
        this.name = name;
    }
    public String toString()
    {
        return String.valueOf(this.name);
    }
}

运行结果如下：

[f, a, E, C, B, A]
f
a
E
C
B
A
15   ..   5   ..   -5   ..   -15   ..   5/15/-15/-5/
max:15
min:-15