黑马程序员--Collection接口下各种子接口和类

Collection接口下各种子接口和类

------- android培训、java培训、期待与您交流！ ----------

1.      Java.util.*;包中Collection接口根接口。

public interface Collection<E> extends Iterable<E> ：Iterable为超级接口。

⑴.  Collection 表示一组对象，这些对象也称为 collection 的元素。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。

集合中存储的都是对象的引用。

⑵．Collection接口定义的方法：

①．               int size()：返回此 collection 中的元素数。如果此 collection 包含多个 Integer.MAX_VALUE（int类型所占位数的最大值，即：2的31次方减1） 元素，则返回 Integer.MAX_VALUE。

              Example：

              ArrayList al = new ArrayList();

              al.add(“java01”);

              al.add(“java02”);

              al.add(“java03”);

              al.add(“java04”);

              sop(“size：”+al.size());

               可以看出：结果为：size：4.

        al中存储的是对象，字符串是String类型的对象。Sise表示ArrayList中存储了4个对象。

②．              boolean contains(Object o)

               如果此 collection 包含指定的元素，则返回 true。更正式地说，当且仅当此 collection 至少包含一个满足 (o==null ? e==null : o.equals(e)) 的元素 e 时才返回 true。

此方法是测试Collection中是否有此元素。

③．              Iterator<E> iterator()

               返回在此 collection 的元素上进行迭代的迭代器。关于元素返回的顺序没有任何保证（除非此 collection 是某个能提供保证顺序的类实例）。

④．boolean add(E o)

        添加对象元素进入容器。add的参数类型是Object，以便以接受任意类型的对象。

⑤．boolean remove(Object o)

               从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。更正式地说，如果此 collection 包含一个或多个满足(o==null ? e==null : o.equals(e)) 的元素 e，则移除这样的元素。如果此 collection 包含指定的元素（或者此 collection 随调用的结果而发生改变），则返回 true。

⑥．boolean containsAll(Collection<?> c)

               如果此 collection 包含指定 collection 中的所有元素，则返回 true。

⑦．boolean addAll(Collection<? extends E> c)

               将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。如果在进行此操作的同时修改指定的 collection，那么此操作行为是不明确的。（这意味着如果指定的 collection 是此 collection，并且此 collection 为非空，那么此调用的行为是不明确的。）

⑧．boolean removeAll(Collection<?> c)

        移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。此调用返回后，collection 中将不包含任何与指定 collection 相同的元素。

        Example:

        al.removeAll(al2);

⑨．boolean retainAll(Collection<?> c)

        仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。换句话说，移除此 collection 中未包含在指定 collection 中的所有元素。【求交集】。

        Example:

al.retainAll(al2);

⑩．void clear()

        移除此 collection 中的所有元素（可选操作）。此方法返回后，除非抛出一个异常，否则 collection 将为空。即：

        Size：0

        Sop(al);结果为空：即【】。

⑪．booleanequals(Object o)

        比较此 collection 与指定对象是否相等。

⑫．int hashCode()

        返回此 collection 的哈希码值。当 Collection 接口没有为 Object.hashCode 方法的常规协定添加任何约束时，为了满足Object.hashCode 方法的常规协定，程序员应该注意任何重写 Object.equals 方法的类必须重写 Object.hashCode 方法。需要特别指出的是，c1.equals(c2) 暗示着 c1.hashCode()==c2.hashCode()。

2.     Collection子接口List接口

public interfaceList<E> extends Collection<E>：Collection的子接口。

⑴．有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

⑵．与 set 不同，列表通常允许重复的元素。更正式地说，列表通常允许满足 e1.equals(e2) 的元素对 e1 和 e2，并且如果列表本身允许 null 元素的话，通常它们允许多个null 元素。难免有人希望通过在用户尝试插入重复元素时抛出运行时异常的方法来禁止重复的列表，但我们希望这种用法越少越好。

⑶．List 接口在 iterator、add、remove、equals 和 hashCode 方法的协定上加了一些其他约定，超过了 Collection 接口中指定的约定。为方便起见，这里也包括了其他继承方法的声明：

①．Iterator<E> iterator()

返回以正确顺序在列表的元素上进行迭代的迭代器。

迭代器是一个对象，它的工作是遍历并选择序列中的对象,它能够用来遍历STL容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址。

迭代器通常被称为“轻量级”对象：创建它的代价小。因此，经常可以见到对迭代器有些奇怪的限制。
Java 的Iterator 就是迭代器受限制的例子，它只能用来： 
1）使用方法 iterator()要求容器返回一个 Iterator。第一次调用Iterator 的next()方法时，它返回序列的第一个元素。 
2）使用next()获得序列中的下一个元素。 
3）使用hasNext()检查序列中是否还有元素。 
4）使用remove()将上一次返回的元素从迭代器中移除

 

②．boolean add(E o)

向列表的尾部追加指定的元素（可选操作）。

③．int hashCode()

返回列表的哈希码值。列表的哈希码定义为以下计算的结果：

  hashCode = 1;

  Iterator i = list.iterator();

  while (i.hasNext()) {

      Object obj = i.next();

      hashCode = 31*hashCode + (obj==null ? 0 :obj.hashCode());

  }

 

这确保了 list1.equals(list2) 意味着对于任何两个列表 list1 和 list2 而言，可实现 list1.hashCode()==list2.hashCode()，正如Object.hashCode 的常规协定所要求的。

               ④．E get(int index)

                      返回列表中指定位置的元素。

               ⑤．E set(int index,E element)

             用指定元素替换列表中指定位置的元素（可选操作）。

         ⑥．void add(int index, E element)

在列表的指定位置插入指定元素（可选操作）。将当前处于该位置的元素（如果有的话）和所有后续元素向右移动（在其索引中加 1）。

            ⑦．ListIterator<E> listIterator()

            返回列表中元素的列表迭代器（以正确的顺序）。

            ⑧．ListIterator<E> listIterator(int index)

返回列表中元素的列表迭代器（以正确的顺序），从列表的指定位置【index】开始。指定的索引指出会由 next 方法的初始调用所返回的首个元素。previous 方法的初始调用会返回索引比指定索引少 1 的元素。

                     ⑨．List<E> subList(int fromIndex,int toIndex)

返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。（如果 fromIndex 和 toIndex 相等，则返回的列表为空）。返回的列表由此列表支持，因此返回列表中的非结构性更改将反映在此列表中，反之亦然。返回的列表支持此列表支持的所有可选列表操作

3.      Collection子接口set接口

public interfaceSet<E> extends Collection<E>

⑴．一个不包含重复元素的 collection。更正式地说，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。正如其名称所暗示的，此接口模仿了数学上的 set 抽象。

⑵．在所有构造方法以及 add、equals 和 hashCode 方法的协定上，Set 接口还加入了其他规定，这些规定超出了从 Collection 接口所继承的内容。出于方便考虑，它还包括了其他继承方法的声明（这些声明的规范已经专门针对 Set 接口进行了修改，但是没有包含任何其他的规定）。

①. Iterator<E> iterator()

        返回在此 set 中的元素上进行迭代的迭代器。返回的元素没有特定的顺序（除非此 set 是某个提供顺序保证的类的实例）。

②．booleanadd(E o)

        如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。更正式地说，如果此 set 没有包含满足下列条件的元素 e，则向 set 中添加指定的元素 o：(o==null ? e==null :o.equals(e))。如果此 set 已经包含指定的元素，则该调用不改变此 set 并返回 false。结合构造方法上的限制，这就可以确保 set 永远不包含重复的元素。

③.int hashCode()

返回 set 的哈希码值。一个 set 的哈希码定义为此 set 中所有元素的哈希码和，其中 null 元素的哈希码定义为零。这就确保对于任意两个set s1 和 s2 而言，s1.equals(s2) 就意味着 s1.hashCode()==s2.hashCode()，正如 Object.hashCode 的常规协定所要求的那样。

4.      java.util.*;中的Iterator接口

⑴. public interface Iterator<E>

对集合进行迭代的迭代器。迭代器代替了 Java Collections Framework 中的 Enumeration。迭代器与枚举有两点不同：

• 迭代器允许调用方利用定义良好的语义在迭代期间从迭代器所指向的集合移除元素。
• 方法名称得到了改进。

⑵.Iterator接口的实现。

通过API文档发现，Iterator类在AbstractList类中实现的：

①．具体继承情况如下：

java.lang.Object

-------- java.util.AbstractCollection<E>

-------- java.util.AbstractList<E>

②.public Iterator<E> iterator()

返回以正确顺序在此列表的元素上进行迭代的迭代器。

此实现返回 iterator 接口的一个直接实现，具体取决于底层 list 的 size()、get(int) 和 remove(int) 方法。

注意，除非重写该列表的 remove(int) 方法，否则此方法返回的迭代器将抛出一个 UnsupportedOperationException 来响应其 remove 方法。

在面临并发修改时，可以使此实现抛出运行时异常，如 (protected) modCount 字段规范中的描述。

 

 

⑶.Iterator接口方法摘要：

        ①. boolean hasNext()

如果仍有元素可以迭代，则返回 true。（换句话说，如果 next 返回了元素而不是抛出异常，则返回 true）。

              ②. E next()

返回迭代的下一个元素。重复调用此方法直到 hasNext() 方法返回 false，这将精确地一次性返回迭代器指向的集合中的所有元素。

              ③. void remove()

从迭代器指向的集合中移除迭代器返回的最后一个元素（可选操作）。每次调用 next 只能调用一次此方法。如果进行迭代时用调用此方法之外的其他方式修改了该迭代器所指向的集合，则迭代器的行为是不明确的。

④.遍历器用于遍历Collection, Map没有提供public的遍历器，但是其内部定义了几个private遍历器自用。

简单地说，每个AbstratCollection的子类都有一个iterator()方法，这个方法将返回一个对应容器的遍历器。而AbstractList的子类自有一个listIterator()方法（ArrayList等具体类也提供iterator()方法，从源码中可以知道listIterator()实际上来自iterator()！在下面有详细解释）。

⑤.通过研究源码可知，Set的Iterator实际上是从Map的内部Iterator获得的（HashSet从HashMap.KeySet私有内嵌类获得，TreeSet从TreeMap.KeySet私有内嵌类获得），之所以这样实现估计是因为Set和Map有同样的性质：不允许重复值。这里暂时不讨论。

listIterator()在AbstractList类中实现。AbstractList类中有四个内嵌类：Itr, ListItr, RandomAccessSubList和SubList。与Iterator有关的是Itr和ListItr这两个。

Itr和ListItr是两个private内嵌类，Itr的实现如下:

Example:

private class Itr implementsIterator {

         //定义一个游标，标示List中元素Index

           intcursor = 0;

         //lastRet是最近被访问的元素的index，如果该元素被remove()了，设为-1

           intlastRet = -1;

       /**

modCount是该List的被修改次数（指结构上的变化，例如size改变），通常在我们一边遍历一边remove()时会发生。注意modCount是transient的，不能被序列化。

expectedModCount如果不等于modCount，就说明在遍历过程中List结构改变了

*/

int expectedModCount = modCount;

    //hasNext()的实现

       public booleanhasNext() {

           returncursor != size(); 

       }

    //next()的实现

       public Objectnext() {

           try {

                    Object next = get(cursor);

                    checkForComodification();

                    lastRet = cursor++;

                    return next;

           }catch(IndexOutOfBoundsException e) {

                    checkForComodification();

                    throw new NoSuchElementException();

           }

remove()将会抛出UnsupportedOperationException，如果
                     如果某个子类允许remove(int)操作的话，必须override此方法。
*/
AbstractList.this.remove(lastRet); 
                     if (lastRet < cursor)
                         cursor--;
                     lastRet = -1;
                     expectedModCount = modCount;
           } catch(IndexOutOfBoundsException e) {
                     throw new ConcurrentModificationException();
           }
       }
    //检查List是否被修改
       final void checkForComodification() {
           if (modCount != expectedModCount)
                     throw new ConcurrentModificationException();
       }
}
AbstractList.iterator()其实只有一行：return new Itr(); 返回一个Itr实例

 

 

 

 ------- android培训、java培训、期待与您交流！ ----------

详情请查看：http://edu.youkuaiyun.com/heima