Set接口以及集合遍历方式

Set接口

Set集合是属于Collection的另一个接口，其集合中的对象不按照特定的方式排序，只是简单的把对象放在集合中，但Set集合中不能包含重复对象。Set集合由Set接口的实现类组成。Set接口继承了Collection接口，因此包含了Collection接口的所有方法。实现了Set接口的主要有HashSet、TreeSet。其二者的区别在于：

• HashSet类实现Set接口，由哈希表支持。它不保证Set的迭代顺序，特别是它不保证该顺序恒久不变。此类允许使用null元素

• TreeSet类不仅实现了Set接口，还实现了java.util.SortedSet接口（注意Collection位于java.lang.Object包），因此，TreeSet类实现的Set集合在遍历集合时按照自然顺序递增排序，也可以按照指定比较比较器递增排序，即可以通过比较器对用TreeSet类实现的Set集合中的对象进行排序。

  自定义实现HashSet：

import java.util.HashMap;

public class MyHashSet {
    /**
     * 自定义自己的HashSet
     * set的不可重复就是利用了map里面键对象的不可重复！
     */
    HashMap<Object, Object> map;
    private static final Object PRESENT = new Object();

    public MyHashSet(){
        map = new HashMap<Object, Object>();
    }

    public int size(){
        return map.size();
    }

    public void add(Object o){
        map.put(o, PRESENT);   //set的不可重复就是利用了map里面键对象的不可重复！
    }

    public static void main(String[] args) {
        MyHashSet s = new MyHashSet();
        s.add("aaa");
        s.add(new String("aaa"));
        System.out.println(s.size());//1
    }
}

Iterator接口（遍历集合中的对象）

迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。Java中的Iterator功能比较简单，并且只能单向移动，所有实现了Collection接口的容器类都有一个iterator方法用以返回一个实现Iterator接口的对象。它只有有三个方法：

  1. boolean hashNext(); //判断是否有元素没有被遍历
  2. Object next(); //返回游标当前位置的元素并将游标移动到下一个位置
  3.  void remove(); //删除游标左边的元素，在执行完next之后该操作只能执行一次。

对于List这种有序集合或许可以通过其他方式来遍历，但是Set集合是无序的，所以其遍历必须要借助Iterator接口。

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

public class Test06 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(13);
        list.add(22);
        list.add(33);

        //通过索引遍历List
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        //通过迭代器遍历List
        for(Iterator iter1 = list.iterator();iter1.hasNext();){
            String str = (String) iter1.next();
            System.out.println(str);
            iter1.remove();
        }

        Set set = new HashSet();
        set.add("1");
        set.add("2");
        set.add("3");
        Iterator it = set.iterator();
        while(it.hasNext()){
            System.out.println((String)it.next());
        }
        System.out.println("=====================");
        //下面的是迭代器的另一种用法
//      for(set.iterator();it.hasNext();){
//          String str = (String)it.next();
//          System.out.println(str);
//      }
    }
}

//迭代器的源码分析
private class Itr implements Iterator<E> {
        int cursor = 0;

        int lastRet = -1;

        public boolean hasNext() {
            return cursor != size();
        }

        public E next() {
            try {
                int i = cursor;
                E next = get(i);
                lastRet = i;
                cursor = i + 1;
                return next;
            } catch (IndexOutOfBoundsException e) {
                checkForComodification();
                throw new NoSuchElementException();
            }
        }

        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();
            try {
                AbstractList.this.remove(lastRet);
                if (lastRet < cursor)
                    cursor--;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }
        }