Set集合详解

转自：http://www.cnblogs.com/chenpi/p/5497125.html#_label0

使用Set集合的主要原因是因为Set集合里面没有重复的元素。

Set集合有三个常见的实现类：HashSet，TreeSet，LinkedHashSet。

简单的说，如果你关注性能，应该使用HashSet；

如果你需要一个有序的Set集合，应该使用TreeSet；

如果你需要一个Set集合保存了原始的元素插入顺序，应该使用LinkedHashSet。

Set接口

Set接口继承Collection接口。Set集合不允许里面存在重复元素，每个元素都必须是唯一的。你只需要往Set集合简单的添加元素，重复元素会被自动移除

HashSet，TreeSet，LinkedHashSet对比

  HashSet是基于散列表实现的，元素没有顺序；add、remove、contains方法的时间复杂度为O(1)。(contains为false时，就直接往集合里存)

  TreeSet是基于树实现的（红黑树），元素是有序的；add、remove、contains方法的时间复杂度为O(log (n))(contains为false时，插入前需要重新排序)。

因为元素是有序的，它提供了若干个相关方法如first(), last(), headSet(), tailSet()等；

  LinkedHashSet介于HashSet和TreeSet之间，是基于哈希表和链表实现的，支持元素的插入顺序；基本方法的时间复杂度为O(1)；

TreeSet例子

TreeSet<Integer>tree=newTreeSet<Integer>();

tree.add(12);
tree.add(63);
tree.add(34);
tree.add(45);
Iterator<Integer> iterator = tree.iterator();
System.out.print("Tree set data: ");
while (iterator.hasNext()) {
    System.out.print(iterator.next() + " ");
}

结果：Tree setdata:12 34 45 63

现在，我们换个元素类型，在进行插入，首先定义一个Dog类，如下
class Dog {

   intsize;

   publicDog(int s) {

       size=s;

   }

   public String toString() {

       return size+ "";

   }

}

public class Q17 {

   public static void main(String[] args) {

       TreeSet<Dog>dset= newTreeSet<Dog>();

       dset.add(newDog(2));

       dset.add(newDog(1));

       dset.add(newDog(3));

       Iterator<Dog>iterator=dset.iterator();

       while(iterator.hasNext()){

           System.out.print(iterator.next()+"");

       }

   }

}

报错:
Exceptioninthread"main"java.lang.ClassCastException: simplejava.Dog cannotbecasttojava.lang.Comparable

因为TreeSet是有序的，Dog类需要实现java.lang.Comparable接口的compareTo()，如下：

class Dog implements Comparable{

   int size;

   public Dog(int s) {

       size=s;

   }

   public String toString() {

       returnsize+ "";

   }

   @Override

   public int compareTo(Dog o) {

   return size - o.size;

   }

}

输出：1 2 3

HashSet例子排序

HashSet<Dog> dset = newHashSet<Dog>();

dset.add(new Dog(2));

dset.add(new Dog(1));

dset.add(new Dog(3));

dset.add(new Dog(5));

dset.add(new Dog(4));

Iterator<Dog>iterator = dset.iterator();

while(iterator.hasNext()) {

      System.out.print(iterator.next() + " ");

}

结果：5 3 2 1 4

排序：HashSet排序
Set<Object> set = new HashSet<Object>();  
        set.add("aaa");
        set.add("ccc");
        set.add("bbb");
System.out.println(sortByValue(set));
//set转ArrayList,利用sort排序
public static Set<Object> sortByValue(Set<Object> set){
    List<Object> setList= new ArrayList<Object>(set);
    Collections.sort(setList,new Comparator<Object>(){
        public int compare(Objecto1,Object o2) {
            return o1.toString().compareTo(o2.toString());
        }
    });
    set = new LinkedHashSet<Object>(setList);//这里注意使用LinkedHashSet(TreeSet存还要排序)
    return set;
}

LinkedHashSet例子

LinkedHashSet<Dog>dset = newLinkedHashSet<Dog>();

dset.add(new Dog(2));

dset.add(new Dog(1));

dset.add(new Dog(3));

dset.add(new Dog(5));

dset.add(new Dog(4));

Iterator<Dog>iterator= dset.iterator();

while(iterator.hasNext()) {

   System.out.print(iterator.next()+" ");

}

结果：2 1 35 4

性能测试(add方法)

Random r= newRandom();

HashSet<Dog>hashSet = new HashSet<Dog>();

TreeSet<Dog>treeSet = new TreeSet<Dog>();

LinkedHashSet<Dog>linkedSet= new LinkedHashSet<Dog>();

// start time

long startTime = System.nanoTime();

for (inti = 0; i < 1000; i++){

int x =r.nextInt(1000 - 10) + 10;

hashSet.add(new Dog(x));

}

// end time

 

long endTime = System.nanoTime();

long duration =endTime - startTime;

System.out.println("HashSet:" + duration);

// start time

startTime= System.nanoTime();

for (inti = 0; i < 1000; i++){

int x =r.nextInt(1000 - 10) + 10;

treeSet.add(new Dog(x));

}

// end time

endTime= System.nanoTime();

duration = endTime - startTime;

System.out.println("TreeSet:" + duration);

// start time

startTime= System.nanoTime();

for (inti = 0; i < 1000; i++){

int x =r.nextInt(1000 - 10) + 10;

linkedSet.add(new Dog(x));

}

// end time

endTime= System.nanoTime();

duration = endTime - startTime;

System.out.println("LinkedHashSet:" + duration);

结果是：HashSet最好，TreeSet最差

 

/**一、是迭代遍历：*/
Set<String> set = new HashSet<String>();
Iterator<String> it = set.iterator();
while (it.hasNext()) {
  String str = it.next();
  //it.remove();
  System.out.println(str);
}
/** "只有" 用iterator遍历时才可以进行删除元素*/

/**二、for循环遍历：*/
for (String str : set) {
      System.out.println(str);
}
/**优点还体现在泛型 假如 set中存放的是Object*/
Set<Object> set = new HashSet<Object>();
/**for循环遍历：*/
for (Object obj: set) {
   if(obj instanceof Integer){
       int aa= (Integer)obj;
   }else if(obj instanceof String){
       String aa = (String)obj
   }
          ........
}