有关不同实现类的List的三种遍历方式的探讨

Posted 2020-11-27 wdzrmpcbit

我们知道，List的类型有ArrayList和LinkedList两种，而曾经的Vector已经被废弃。

而作为最常用的操作之一，List的顺序遍历也有三种方式：借助角标的传统遍历、使用内置迭代器和显式迭代器。

下面，将首先给出两种种不同类型实现的实验结果，之后，将会通过分析JAVA中List的各种实现，来探讨造成实验结果的原因。

 

1.随机数据的生成

package temp;

import java.io.*;
import java.util.Random;

public class Datamaker {
    final static int MAXL = 10;
    final static int MAXN = 30000000;
    
    public static String getRandomString(int length){
        String str="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        Random random=new Random();
        StringBuffer sb=new StringBuffer();
         
        for(int i=0;i<length;i++){
            int number=random.nextInt(62);
            sb.append(str.charAt(number));
        }
         
        return sb.toString();
    }

    public static void main(String[] args) throws IOException {
        String fileName = "src//temp//data.txt";
        BufferedWriter bw = new BufferedWriter(new FileWriter(fileName));
        
        for(int i = 0; i < MAXN; i++)
            bw.write(getRandomString((int) (Math.random() * MAXL) + 1) + "
");
        System.out.println("Generate finish.
");
        
        bw.flush();
        bw.close();
    }

}

如上所示，我们生成3 * 10 ^ 7组测试用例，测试用例中的每行由长度为1到10的随机字符串组成。

实际上，由于字符串的存储速度与List的实现方式无关，为了减少生成数据的时间，于是采用了较短的字符串长度。

生成的数据保存在目录下的Data.txt文件中。

 

2.测试用代码

package temp;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.*;

public class Temp {
    static List<String> S = new ArrayList<>();
    
    public static void printTime(String type, String method, long time) {
        System.out.println(method + " of " + type + " : " + time + "ms");
    }
    
    public static void main(String[] args) throws IOException {
        String fileName = "src//temp//data.txt";
        try(FileReader reader = new FileReader(fileName);
                BufferedReader br = new BufferedReader(reader)
            ) {
                String line;
                while((line = br.readLine()) != null) {
                    S.add(line);
                }
            }
            catch (IOException e) {
                System.out.println("Illegal input file or its path.");
            }
        
        System.out.println("Read finish.");
        
        Iterator<String> it;
        String str;
        long beginTime = 0, endTime = 0;
        
        //Test List begin
        List<String> testList = new ArrayList<>();
        it = S.iterator();
        while(it.hasNext())
            testList.add(it.next());
        
        System.out.println("Copy finish.");
        
        beginTime = System.currentTimeMillis();
        int Size = testList.size();
        for(int i = 0; i < Size; i++) {
            str = testList.get(i);
        }
        endTime = System.currentTimeMillis();
        printTime("          List", "Traversal with scripts", endTime - beginTime);
        
        beginTime = System.currentTimeMillis();
        for(String s : testList) {
            str = s;
        }
        endTime = System.currentTimeMillis();
        printTime("List", "Traversal with implicit iterator", endTime - beginTime);
        
        beginTime = System.currentTimeMillis();
        it = testList.iterator();
        while(it.hasNext()) {
            str = it.next();
        }
        endTime = System.currentTimeMillis();
        printTime("List", "Traversal with explicit iterator", endTime - beginTime);
        //Test List end
    }
}

以上代码以ArrayList实现为例，分别测试三种遍历方式的运行时间，单位为ms。

为了尽量减少无关变量的影响，每个循环中都执行相同的赋值操作，同时均使用相同的Data.txt。

LinkedList实现类的代码与此类似，下不赘述。

 

3.实验结果

ArrayList:
Read finish.
Copy finish.
Traversal with scripts of           List : 96ms
Traversal with implicit iterator of List : 104ms
Traversal with explicit iterator of List : 98ms

LinkedList:
Read finish.
Copy finish.
Traversal with scripts of           List : 10001ms
Traversal with implicit iterator of List : 162ms
Traversal with explicit iterator of List : 151ms

这里由于LinkedList的传统遍历运行时间太长，我就给截断了。

可以看到，在两种实现类中，内置迭代器的运行速度都要快于显式迭代器。

而在ArrayList中，传统遍历速度又优于其他两种遍历方式。

 

4.ArrayList分析

private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = {};
private transient Object[] elementData;
private int size;

public ArrayList(int initialCapacity) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                            initialCapacity);
    this.elementData = new Object[initialCapacity];
}

public void add(int index, E element) {
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                        size - index);
    elementData[index] = element;
    size++;
}

public E get(int index) {
    rangeCheck(index);
    checkForComodification();
    return ArrayList.this.elementData(offset + index);
}

上述为ArrayList的底层实现，可以看到其本质上就是一个数组。

当加入新元素后会产生溢出时，add方法会新建一个大小为原数组的大小的1.5倍的新数组。

所以get方法的实现就及其简单，直接用偏移寻址即可。

 

5.LinkedList分析

private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }

　　 public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
     }


    Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }    
}

由于LinkedList的成员几乎完全由Node来实现，所以直接来分析Node这个类。

可以看到，正如在DS中学过的链表一样，Node的next和prev分别指向该节点的前驱和后继。

而get本质上是遍历一个链表来寻找符合的元素，因此LinkedList的get效率慢到无法忍受，也不足为奇了。

 

6.迭代器分析

private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }
}

迭代器不考虑对象的具体实现，而是使用一系列方法，来达到用户可控的遍历方式。

可以看到，其实现方式与数组类似，所以在ArrayList的测试中，能够达到与直接调用get相近的时间。

 

7.总结

基于上述分析，我们可以得到如下结论：

ArrayList基于动态数组的实现，它长于随机访问元素，但是在中间插入和移除元素时较慢。

LinkedList基于链表实现，在List中间进行插入和删除的代价较低，提供了优化的顺序访问。LinkedList在随机访问方面相对比较慢，但是它的特性集较ArrayList更大。

迭代器的时间开销与get相近，而且对程序员来说可控性更高，所以不失为一个好的选择。