示例比较HashSet,LinkedHashSet,TreeSet

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;

public class T01{

private static class Ob implements Comparable<Ob>{
private int idx = 0;

public Ob(int idx){
this.idx = idx;
}

public int getIdx(){
return idx;
}

public void setIdx(int idx){
this.idx = idx;
}

@Override
public int hashCode(){
final int prime = 31;
int result = 1;
result = prime * result + idx;
return result;
}

@Override
public boolean equals(Object obj){
if(this == obj) return true;
if(obj == null) return false;
if(getClass() != obj.getClass()) return false;
Ob other = (Ob)obj;
if(idx != other.idx) return false;
return true;
}

@Override
public int compareTo(Ob o){
return o.getIdx();
}

@Override
public String toString(){
return "Ob[" + idx + "]";
}

}

/**
*
* @param args void
*/
public static void main(String[] args){
//treeset 有序去重,内部是二叉树实现，string默认实现了java.lang.Comparable接口
TreeSet s = new TreeSet();
s.add("b");
s.add("ab");
s.add("a");
s.add("c");
s.add("c");
s.add("c");
s.add("d");
s.add("e");
System.out.println("s: "+s);

//linkedhashset 有序去重，内部hash
LinkedHashSet<Integer> d = new LinkedHashSet<Integer>();
d.add(1);
d.add(3);
d.add(2);
d.add(2);
d.add(2);
d.add(4);
d.add(5);
System.out.println("d: "+d);

//treeset 内部对象要求实现java.lang.Comparable接口
TreeSet k = new TreeSet();
k.add(new Ob(1));
k.add(new Ob(3));
k.add(new Ob(5));
k.add(new Ob(4));
k.add(new Ob(2));
k.add(new Ob(2));
k.add(new Ob(2));
k.add(new Ob(6));
System.out.println("k: "+k);

//HashSet 无序去重，内部hash
HashSet x = new HashSet();
x.add(new Ob(1));
x.add(new Ob(3));
x.add(new Ob(5));
x.add(new Ob(4));
x.add(new Ob(2));
x.add(new Ob(6));
System.out.println("x: "+x);

//LinkedHashSet 有序去重，内部hash
LinkedHashSet x1 = new LinkedHashSet();
x1.add(new Ob(1));
x1.add(new Ob(3));
x1.add(new Ob(5));
x1.add(new Ob(4));
x1.add(new Ob(2));
x1.add(new Ob(6));
System.out.println("x1: "+x1);

//HashSet 加数字，默认按数字排序
HashSet y = new HashSet();
y.add(2);
y.add(1);
y.add(4);
y.add(3);
y.add(5);
y.add(5);
y.add(6);
System.out.println("y: "+y);

//HashSet 加对象，无序去重
HashSet z = new HashSet();
z.add("a");
z.add("c");
z.add("b");
z.add("b");
z.add("e");
z.add("e");
z.add("e");
z.add("d");
z.add("f");
System.out.println("z: "+z);

//LinkedHashSet 加对象，有序去重
LinkedHashSet o = new LinkedHashSet();
o.add("a");
o.add("c");
o.add("b");
o.add("b");
o.add("e");
o.add("e");
o.add("e");
o.add("f");
o.add("d");
System.out.println("o: "+o);

//		运行结果:
//		s: [a, ab, b, c, d, e]
//		d: [1, 3, 2, 4, 5]
//		k: [Ob[1], Ob[3], Ob[5], Ob[4], Ob[2], Ob[2], Ob[2], Ob[6]]
//		x: [Ob[3], Ob[4], Ob[1], Ob[2], Ob[5], Ob[6]]
//		x1: [Ob[1], Ob[3], Ob[5], Ob[4], Ob[2], Ob[6]]
//		y: [1, 2, 3, 4, 5, 6]
//		z: [f, d, e, b, c, a]
//		o: [a, c, b, e, f, d]

}
}