持有对象--Collection和Iterator

Leefs 2019-12-11 AM 1435℃ 0条

# 持有对象--Collection和Iterator

### 前言

本篇讲述《Java编程思想》第11.12节，Collection和Iterator

### 一、概述

在进行本节之前，先对Collection和Iterator进行单独的介绍，温习一下

#### 1. Collection

Collection接口是List、Set和Queue接口的父接口，该接口定义的方法可以操作List、Set和Queue集合

![Collection和Iterator01.jpg][1]

Collection和Queue、List、Set关系图

#### 2. Iterator

Iterator(迭代器)是一个接口，它的作用就是遍历容器的所有元素。

```
Iterator iter = list.iterator();
```

iterator是为了实现对Java容器（collection）进行遍历功能的一个接口。

在iterator实现了Iterator接口后，相当于把一个Collection容器的所有对象，做成一个线性表（List）,而iterator本身是一个指针，开始时位于第一个元素之前。

**Iterator方法**

| 方法               | 方法说明                                                     |
| ------------------ | ------------------------------------------------------------ |
| Boolean hasNext(); | 判断 iterator 内是否存在下1个元素，如果存在，返回true，否则返回false。（注意，这时上面的那个指针位置不变） |
| Object next();     | 返回 iterator 内下1个元素，同时上面的指针向后移动一位。<br/>故，如果不断地循环执行next()方法，就可以遍历容器内所有的元素了。 |
| void remove();     | 删除 iterator 内指针的前1个元素，前提是至少执行过1次next();<br/>(这个方法不建议使用，建议使用容器本身的romove 方法) |

#### 3. Iterator和Collection的关系

Iterator模式是用于遍历集合类的标准访问方法。它可以把访问逻辑从不同类型的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。

例如，如果没有使用Iterator，遍历一个数组的方法是使用索引：

```
for(int i=0; i<array.size(); i++) { ... get(i) ... }
```

而访问一个链表（LinkedList）又必须使用while循环：

```
while((e=e.next())!=null) { ... e.data() ... }
```

以上两种方法客户端都必须事先知道集合的内部结构，访问代码和集合本身是紧耦合，无法将访问逻辑从集合类和客户端代码中分离出来，每一种集合对应一种遍历方法，客户端代码无法复用。

更恐怖的是，如果以后需要把ArrayList更换为LinkedList，则原来的客户端代码必须全部重写。

为解决以上问题，Iterator模式总是用同一种逻辑来遍历集合：

```java
for(Iterator it = c.iterater(); it.hasNext(); ) { ... }
```

奥秘在于客户端自身不维护遍历集合的"指针"，所有的内部状态（如当前元素位置，是否有下一个元素）都由Iterator来维护，而这个Iterator由集合类通过工厂方法生成，因此，它知道如何遍历整个集合。

客户端从不直接和集合类打交道，它总是控制Iterator，向它发送"向前"，"向后"，"取当前元素"的命令，就可以间接遍历整个集合。

首先看看java.util.Iterator接口的定义：

```java
public interface Iterator { boolean hasNext(); Object next(); void remove(); }
```

依赖前两个方法就能完成遍历，典型的代码如下：

```java
for(Iterator it = c.iterator(); it.hasNext(); ) { Object o = it.next(); // 对o的操作... }
```

在JDK1.5中，还对上面的代码在语法上作了简化(但是限于只读，如果需要remove，还是直接使用iterator)：

// Type是具体的类型，如String。 for(Type t : c) { // 对t的操作... }

每一种集合类返回的Iterator具体类型可能不同，Array可能返回ArrayIterator，Set可能返回
SetIterator，Tree可能返回TreeIterator，但是它们都实现了Iterator接口，因此，客户端不关心到底是哪种

Iterator，它只需要获得这个Iterator接口即可，这就是面向对象的威力。

### 二、示例

**下面3个示例重点阐述：`方法与实现的解耦`，也就是将队列与消费队列的方法连接在一起耦合度最小的方式。**

标准 C++ 类库中并没有其容器的任何公共基类———容器之间的所有共性都是通过迭代器达成的。而Java中，将两种方法绑定到了一起，因为实现公共基类Collection就意味着需要提供iterator()方法：

如下所示，两个版本的display()方法都可以使用Map或Collection的子类型来工作，而且Collection接口和Iterator都可以将display()方法与底层容器的特定实现解耦。

```java
public class InterfaceVsIterator {
    //当你要实现一个Collection的外部类时可能非常困难，因此使用Iterator就会变得非常吸引人
    public static void display(Iterator<Pet> it){
        while(it.hasNext()){
            Pet p = it.next();
            System.out.print(p.id()+":"+p+" ");
        }
        System.out.println();
    }
    //Collection是Iterable类型，因此，可以使用foreach结构；使用此种方法的Collection通常是已有类
    public static void display(Collection<Pet> pets){
        for(Pet p : pets){
            System.out.print(p.id()+":"+p+" ");
        }
        System.out.println();
    }
    public static void main(String[] args) {
        List<Pet> petList = Pets.arrayList(8);
        Set<Pet> petSet = new HashSet<Pet>(petList);
        Map<String,Pet> petMap = new LinkedHashMap<String,Pet>();
        String[] names = ("Ralph,Eric,Robin,Lacey,Britney,Sam,Spot,Fluffy").split(",");
        for(int i=0;i<names.length;i++){
            petMap.put(names[i],petList.get(i));
        }
        display(petList);
        display(petSet);
        display(petList.iterator());
        display(petSet.iterator());
        System.out.println(petMap);;
        System.out.println(petMap.keySet());
        display(petMap.values());
        display(petMap.values().iterator());
    }
}
```

> 运行结果

```java
0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 
0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 
0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 
0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 
{Ralph=Rat, Eric=Manx, Robin=Cymric, Lacey=Mutt, Britney=Pug, Sam=Cymric, Spot=Pug, Fluffy=Manx}
[Ralph, Eric, Robin, Lacey, Britney, Sam, Spot, Fluffy]
0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 
0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 
```

当你要实现一个不是Collection的外部类时,由于让它去实现Collection接口可能非常困难,因此使用Iterator就会变得非常吸引人,实现Collection就必须实现iterator(),并且只拿iterator()与继承AbstaractCollection相比花费的代价略微减小

```java
private Pet[] pets = Pets.createArray(8);
public int size() { return pets.length; }
public Iterator<Pet> iterator() {
    return new Iterator<Pet>() {
        private int index = 0;
        public boolean hasNext() {
            return index < pets.length;
        }
        public Pet next() { return pets[index++]; }
        public void remove() { // Not implemented //remove()方法时一个可选操作,可以不实现
            throw new UnsupportedOperationException();
        }
    };
}    
public static void main(String[] args) {
    CollectionSequence c = new CollectionSequence();
    InterfaceVsIterator.display(c);//ColectionSequence通过继承抽象Collection实现了功能
    InterfaceVsIterator.display(c.iterator());
}
```

> 运行结果

```
0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 
0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 
```

如果你的类已经继承类其他的类,那么你就不能再继承`AbstractCollection`了,再这种情况下,要实现Collection就必须实现该接口中的所有方法。

此时,继承并提供创建迭代器的能力就会显得容易的多了,生成Iterator是将队列与消费队列的方法连接再一起耦合度最小的方式,并且与实现Collection相比,它在序列类上所施加的约束也少的多

```java
class PetSequence{
    protected Pet[] pets = Pets.createArray(8);
}
public class NonCollectionSequence extends PetSequence{
    public Iterator<Pet> iterator() {
        return new Iterator<Pet>() {
            private int index = 0;
            public boolean hasNext() {
                return index < pets.length;
            }
            public Pet next() { return pets[index++]; }
            public void remove() { // Not implemented
                throw new UnsupportedOperationException();
            }
        };
    }
    public static void main(String[] args) {
        NonCollectionSequence nc = new NonCollectionSequence();
        InterfaceVsIterator.display(nc.iterator()); //NonCollectionSequence通过实现Iterator匿名类实现了Iterator
    }
}
```

> 运行结果

```java
0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 
```

生成Iterator是将队列与消费队列的方法连接在一起耦合度最小的方式，并且与实现Collection相比，它在序列类上所施加的约束也少得多。

*附：[参考文章链接](http://panxiaoxiao270557.blog.163.com/blog/static/137497445201351735734160/)*

[1]: https://lilinchao.com/usr/uploads/2019/12/409464460.jpg

标签: Java, Java编程思想, JavaSE, 持有对象

非特殊说明，本博所有文章均为博主原创。

如若转载，请注明出处：https://lilinchao.com/archives/277.html

上一篇持有对象--PriorityQueue

下一篇【转载】Java实现多级菜单（递归）

持有对象--Collection和Iterator

评论啦~

栏目分类

标签云

友情链接申请

持有对象--Collection和Iterator

 评论啦~

 栏目分类

标签云

友情链接申请

评论啦~

栏目分类

标签云

友情链接申请