Java容器类接口:Iterator,Collection,Map

Iterator

Iterator被称为迭代器，是一个对象，它的工作是遍历并选择序列中的对象，可以实现以下一些操作：

• 使用方法iterator()要求容器返回一个Iterator,Iterator将返回序列的第一个元素；
• 使用next()获取序列中的下一个元素；
• 使用hasNext()检查序列中是否有元素；
• 使用remove()将迭代器最近返回的元素删除；

Iterator只能向前移动，ListIterator是一个更加强大的Iterator的子类，它只能用于各种List类的访问，ListIterator可以双向移动，它能产生当前迭代器指向的列表中元素的前一个和后一个元素的索引，并且可以使用set()方法替换它访问过的最后一个元素。

Iterator在JDK中是一个接口，在JDK8中它的子接口包含

ListIterator<E>,

PrimitiveIterator<T,T_CONS>,

PrimitiveIterator.OfDouble,

PrimitiveIterator.OfInt,

PrimitiveIterator.OfLong,

XMLEventReader

Iterator定义如下：

public interface Iterator<E> {

boolean hasNext(); //如果有元素可以迭代则返回true

E next(); //返回迭代的下一个元素

void remove(); //从迭代器指向的Collection中移除迭代器返回的最后一个元素

}

Iterator使用实例：

import java.util.ArrayList;
import java.util.Iterator;

public class IteratorTest {
    public static void play(Iterator<String> it) {
        while(it.hasNext()) {
            System.out.println(it.next());
        }
    }

    public static void main(String[] args) {
        ArrayList<String> ss = new ArrayList<String>();
        for(int i = 0; i < 7; i++) {
            ss.add("i:" + i);
        }
        play(ss.iterator());
    }
}

ListIterator允许按任意一方向遍历列表，迭代期间修改列表，并获得迭代器在列表中的位置。ListIterator没有当前元素，它的光标位置始终位于调用previous所返回的元素和调用next所返回元素之间。

ListIterator实现如下：

public interface ListIterator<E> extends Iterator<E> {

boolean hasNext(); //正向遍历列表时如果迭代器有多个元素，返回true

E next(); //返回列表中的下一个元素，可以重复使用迭代列表

boolean hasPrevious(); //反向遍历列表时如果迭代器有多个元素，返回true

E previous(); //返回列表中的上一个元素

int nextIndex(); //返回对next后续调用返回的索引

int previousIndex(); //返回对previous调用返回的索引

void remove(); //从列表中移除由next或previous返回的最后一个元素

void set(E e); //用指定元素替换next或previous返回的最后一个元素

void add(E e); //将指定元素插入列表

}

ListIterator使用实例：

import java.util.LinkedList;
import java.util.ListIterator;

public class ListIteratorTest {
    public static void play(ListIterator<String> it) {
        while(it.hasNext()) {
            System.out.print(it.next() + " " + it.nextIndex() + "|");
        }
        it.set("xxxxxxx");
        it.add("yyyyyyy");
        System.out.println();
        System.out.println(it.previous() + " " + it.next());
        while(it.hasPrevious()) {
            System.out.print(it.previous() + " " + it.previousIndex() + "|");
        }
    }

    public static void main(String[] args) {
        LinkedList<String> ls = new LinkedList<String>();
        for (int i = 0; i < 5; i++) {
            ls.add("aaaaaaa");
        }
        play(ls.listIterator());
    }
}

Collection

Collection是描述所有序列容器的共性根接口，使用接口可以创建富有通用性的代码，可以通过接口而非具体的实现来编写代码，如果编写的方法接受一个Collection，则该方法接受任何用于实现了Collection的类。

Collection接口继承自Iterable，在JDK8中它的子接口包含

BeanContext,

BeanContextServices,

BlockingDeque<E>,

BlockingQueue<E>,

Deque<E>,

List<E>,

NavigableSet<E>,

Queue<E>,

Set<E>,

SortedSet<E>,

TransferQueue<E>

Collection的定义如下

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

int size(); //返回Collection中的元素数

boolean isEmpty(); //如果Collection不包含元素返回true

boolean contains(Object o); //如果Collection包含指定的元素返回true

Iterator<E> iterator(); //返回此Collection的迭代器

Object[] toArray(); //返回此Collection所有元素组成的数组

<T> T[] toArray(T[] a); //返回此Collection所有元素组成的数组

boolean add(E e); //确保此Collection包含指定的元素

boolean remove(Object o); //从此Collection中移除指定的元素

boolean containsAll(Collection<?> c); //如果包含指定Collection中的元素返回true

boolean addAll(Collection<? extends E> c); //至指定的Collectio中的元素加入

boolean removeAll(Collection<?> c); //移除指定Collection的元素

boolean retainAll(Collection<?> c); //只保留指定的Collection中的元素

void clear(); //移除Collection中的所有元素

boolean equals(Object o); //比较与指定对象是否相等

int hashCode(); //返回此Collection的哈希值

}

类AbstractCollection提供了Collection接口最基本的实现，最大程度的减少了实现Collection接口的工作。如果需要实现一个新的不可修改的Collection，则只需要扩展AbstractCollection即可，需要提供iterator()和size()方法的实现(iterator方法返回的迭代器必须实现hasNext和next)，如果要实现一个可修改的Collection，则必须重写add方法，iterator方法返回的迭代器还必须实现remove方法。

Collection具体实现可以在之后的List，Set，Queue中见到。

Map

Map：Map<K, V> 在Java中提供键值映射的接口，K代表此映射所维护的键的类型，V代表此映射值的类型。一个映射不能包含重复的键，每个键最多只能映射到一个值。Map提供了三种Collection的视图，键集合，值集合以及键值映射关系集合。

Map<K, V>的子接口包含

Bindings,

ConcurrentMap<K,V>,

ConcurrentNavigableMap<K,V>,

LogicalMessageContext,

MessageContext,

NavigableMap<K,V>,

SOAPMessageContext,

SortedMap<K,V>

Map<K, V>的定义如下，Map<K, V>中包含一个嵌套的接口表示映射的键值对

public interface Map<K,V> {

int size(); //返回此映射中的键-值映射关系数

boolean isEmpty(); //如果此映射未包含键-值映射关系，则返回 true

boolean containsKey(Object key); //如果此映射包含指定键的映射关系，则返回 true

boolean containsValue(Object value); //如果此映射将一个或多个键映射到指定值，则返回 true

V get(Object key); //返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null

V put(K key, V value); //将指定的值与此映射中的指定键关联

V remove(Object key); //如果存在一个键的映射关系，则将其从此映射中移除

void putAll(Map<? extends K, ? extends V> m); //从指定映射中将所有映射关系复制到此映射中

void clear(); //从此映射中移除所有映射关系

Set<K> keySet(); //返回此映射中包含的键的 Set 视图

Collection<V> values(); //返回此映射中包含的值的 Collection 视图

Set<Map.Entry<K, V>> entrySet(); //返回此映射中包含的映射关系的 Set 视图

interface Entry<K,V> {

K getKey();

V getValue();

V setValue(V value);

boolean equals(Object o);

int hashCode();

}

boolean equals(Object o); //比较指定的对象与此映射是否相等

int hashCode(); //返回此映射的哈希码值

}

Map<K, V>的使用实例

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapTest {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("a", "AA");
        map.put("b", "BB");
        map.put("c", "CC");

        Set set = map.entrySet();
        Iterator it = set.iterator();
        while(it.hasNext()) {
            Map.Entry<String, String> me = (Map.Entry<String, String>)it.next();
            System.out.println(me.getKey() + " " + me.getValue());
        }
    }
}