源码分析一(Iterator、Collection以及List接口)

1：Iterable接口，实现这个接口的类对象可以进行迭代

 package java.lang;
 import java.util.Iterator;
 /**
  * 实现这个接口的类所创建的对象可以进行迭代
  */
 public interface Iterable<T> {

     /**
      * 调用这个方法会返回迭代器，迭代器可以理解为操纵杆，可以操作某个对象
      */
     Iterator<T> iterator();
 }

2：Collection类，它是List以及Set的父类

 package java.util;

 /**
  * 这个接口继承了Iterable接口，那么它的子孙类实例化时就可以迭代输出
  */

 public interface Collection<E> extends Iterable<E> {
     // Query Operations

     /**
      * 获取集合长度
      * 返回这个集合中元素的个数，如果集合中包含元素数量超过整数所能表示的最大值，那么返回这个最大值，
      * 这种超过最大值的情况基本上不存在，如果存在，内存应该早就溢出了。
      */
     int size();

     /**
      * 判断集合是否为空
      * 如果集合中没有任何元素，返回true
      */
     boolean isEmpty();

     /**
      * 判断集合中是否包含某个元素
      * 如果集合中包含指定的元素，返回true,集合中至少包含一个元素，可以为null或者其他元素
      * 比较方式：o==null?e==null:o.equals(e)
      */
     boolean contains(Object o);

     /**
      * 这个方法返回一个迭代器，可以对集合中元素进行遍历
      */
     Iterator<E> iterator();

     /**
      * 将集合转化为数组
      * 返回一个数组，如果集合中元素是有序的，那么返回的数组也是相同的顺序
      * 这个方法为集合和数组之间搭建了互相转换的桥梁
      */
     Object[] toArray();

     /**
      * 此方法返回一个指定类型的数组，如果指定的数组的容量大于集合的容量，那么直接将集合中的
      * 元素放到数组中返回，否则重新创建一个新数组
      */
     <T> T[] toArray(T[] a);

     // Modification Operations

     /**
      * 添加元素到集合中，添加成功返回true，否则返回false
      */
     boolean add(E e);

     /**
      * 从集合中移除某个对象，移除成功返回true，否则返回false
      */
     boolean remove(Object o);

     // Bulk Operations

     /**
      * 判断集合中是否包含指定集合中所有元素，是返回true，否则返回false
      */
     boolean containsAll(Collection<?> c);

     /**
      * 添加指定集合的所有元素到集合中，成功返回true，否则返回false
      */
     boolean addAll(Collection<? extends E> c);

     /**
      * 在当前集合中删除指定集合中包含的元素，成功返回true，否则返回false
      */
     boolean removeAll(Collection<?> c);

     /**
      * 保留指定集合中包含的元素，换句话说就是删除指定集合中没有的元素
      */
     boolean retainAll(Collection<?> c);

     /**
      * 清空集合中所有的元素
      */
     void clear();

     // Comparison and hashing

     /**
      * 比较两个对象是否相等
      */
     boolean equals(Object o);

     /**
      * 获取hashcode的值
      */
     int hashCode();
 }

3：List集合继承了Collection集合

 package java.util;

 public interface List<E> extends Collection<E> {

     int size();

     boolean isEmpty();

     boolean contains(Object o);

     Iterator<E> iterator();

     Object[] toArray();

     <T> T[] toArray(T[] a);

     boolean add(E e);

     boolean remove(Object o);

     boolean containsAll(Collection<?> c);

     boolean addAll(Collection<? extends E> c);
     /**
      * 在指定位置index插入指定集合的元素
      */
     boolean addAll(int index, Collection<? extends E> c);

     boolean removeAll(Collection<?> c);

     boolean retainAll(Collection<?> c);

     void clear();

     boolean equals(Object o);

     int hashCode();

     /**
      * 根据索引index获取指定的元素
      * @param index
      * @return
      */
     E get(int index);

     /**
      * 替换指定位置的元素，返回这个位置的元素
      * @param index
      * @param element
      * @return
      */
     E set(int index, E element);

     /**
      * 在指定位置插入元素，索引处元素依次向右移动
      * @param index
      * @param element
      */
     void add(int index, E element);

     /**
      * 移除指定位置的元素
      * @param index
      * @return
      */
     E remove(int index);

     // Search Operations

     /**
      * 返回集合中第一次出现指定元素的索引，如果没有返回-1
      */
     int indexOf(Object o);

     /**
      * 返回指定元素的索引，从最后一个元素开始查找
      * @param o
      * @return
      */
     int lastIndexOf(Object o);

     // List Iterators

     /**
      * 返回一个list的迭代器
      */
     ListIterator<E> listIterator();

     /**
      * 返回一个list的迭代器，从指定位置开始
      */
     ListIterator<E> listIterator(int index);

     // View

     /**
      * 返回一个子集，从fromIndex开始到toIndex结束
      */
     List<E> subList(int fromIndex, int toIndex);
 }