1     /**
 2      * Appends the specified element to the end of this list.
 3      *
 4      * <p>This method is equivalent to {@link #addLast}.
 5      *
 6      * @param e element to be appended to this list
 7      * @return {@code true} (as specified by {@link Collection#add})
 8      */
 9     public boolean add(E e) {
10         linkLast(e);
11         return true;
12     }

 1   /**
 2      * Links e as last element.
 3      */
 4     void linkLast(E e) {
 5         final Node<E> l = last;
 6         final Node<E> newNode = new Node<>(l, e, null);
 7         last = newNode;
 8         if (l == null)
 9             first = newNode;
10         else
11             l.next = newNode;
12         size++;
13         modCount++;
14     }

 1  /**
 2      * Retrieves and removes the head (first element) of this list.
 3      *
 4      * @return the head of this list
 5      * @throws NoSuchElementException if this list is empty
 6      * @since 1.5
 7      */
 8     public E remove() {
 9         return removeFirst();
10     }

 1    /**
 2      * Removes and returns the first element from this list.
 3      *
 4      * @return the first element from this list
 5      * @throws NoSuchElementException if this list is empty
 6      */
 7     public E removeFirst() {
 8         final Node<E> f = first;
 9         if (f == null)
10             throw new NoSuchElementException();
11         return unlinkFirst(f);
12     }

 1   /**
 2      * Unlinks non-null first node f.
 3      */
 4     private E unlinkFirst(Node<E> f) {
 5         // assert f == first && f != null;
 6         final E element = f.item;
 7         final Node<E> next = f.next;
 8         f.item = null;
 9         f.next = null; // help GC
10         first = next;
11         if (next == null)
12             last = null;
13         else
14             next.prev = null;
15         size--;
16         modCount++;
17         return element;
18     }

 1    /* 第一种遍历方式 
 2         for循环的遍历方式
 3    */
 4         for (int i = 0; i < lists.size(); i++) {
 5             System.out.print(lists.get(i));
 6         }
 7  8         
 9         /* 第二种遍历方式 
10           foreach的遍历方式
11         */
12         for (Integer list : lists) {
13             System.out.print(list);
14         }
15 16         
17         /* 第三种遍历方式
18          Iterator的遍历方式
19       */
20         for (Iterator<Integer> list = lists.iterator(); list.hasNext();) {
21             System.out.print(list.next());
22         }

1    /**
2      * Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
3      * default initial capacity (16) and load factor (0.75).
4      */
5     public HashSet() {
6         map = new HashMap<>();
7     }

1   /**
2      * Constructs a new, empty linked hash set with the default initial
3      * capacity (16) and load factor (0.75).
4      */
5     public LinkedHashSet() {
6         super(16, .75f, true);
7     }

 1  /**
 2      * Constructs a new, empty linked hash set.  (This package private
 3      * constructor is only used by LinkedHashSet.) The backing
 4      * HashMap instance is a LinkedHashMap with the specified initial
 5      * capacity and the specified load factor.
 6      *
 7      * @param      initialCapacity   the initial capacity of the hash map
 8      * @param      loadFactor        the load factor of the hash map
 9      * @param      dummy             ignored (distinguishes this
10      *             constructor from other int, float constructor.)
11      * @throws     IllegalArgumentException if the initial capacity is less
12      *             than zero, or if the load factor is nonpositive
13      */
14     HashSet(int initialCapacity, float loadFactor, boolean dummy) {
15         map = new LinkedHashMap<>(initialCapacity, loadFactor);
16     }

 1  /**
 2      * Constructs a new, empty tree set, sorted according to the specified
 3      * comparator.  All elements inserted into the set must be <i>mutually
 4      * comparable</i> by the specified comparator: {@code comparator.compare(e1,
 5      * e2)} must not throw a {@code ClassCastException} for any elements
 6      * {@code e1} and {@code e2} in the set.  If the user attempts to add
 7      * an element to the set that violates this constraint, the
 8      * {@code add} call will throw a {@code ClassCastException}.
 9      *
10      * @param comparator the comparator that will be used to order this set.
11      *        If {@code null}, the {@linkplain Comparable natural
12      *        ordering} of the elements will be used.
13      */
14     public TreeSet(Comparator<? super E> comparator) {
15         this(new TreeMap<>(comparator));
16     }

 1   /**
 2      * Constructs a new, empty tree set, sorted according to the
 3      * natural ordering of its elements.  All elements inserted into
 4      * the set must implement the {@link Comparable} interface.
 5      * Furthermore, all such elements must be <i>mutually
 6      * comparable</i>: {@code e1.compareTo(e2)} must not throw a
 7      * {@code ClassCastException} for any elements {@code e1} and
 8      * {@code e2} in the set.  If the user attempts to add an element
 9      * to the set that violates this constraint (for example, the user
10      * attempts to add a string element to a set whose elements are
11      * integers), the {@code add} call will throw a
12      * {@code ClassCastException}.
13      */
14     public TreeSet() {
15         this(new TreeMap<E,Object>());
16     }