Listとゆかいなクラスたち

# はじめに
[前の記事](https://qiita.com/taumax/items/2af451a2c331e8ded892)でコメントを頂いたのでちょっと書いてみようという気になったことを書いてみます。
Java の List 関連のクラスについて、普段仕事をしている中で他人のソースコードを見ていると、意識している人は少ないのかなぁ・・・と思っていることについてです。

# List 配下のクラスと当記事の記載対象
List インタフェースを実装したクラスには[ここ](https://docs.oracle.com/javase/jp/8/docs/api/java/util/List.html)の「既知のすべての実装クラス」に記載されている通り、いろいろなものがあります。
その中でも比較的有名（？）な以下3クラスについて書いてみようと思います。
・ArrayList
・LinkedList
・Arrays$ArrayList
（これら以外については私は使ったことないのでよく知らない）

# ArrayList
## initialCapacity
ArrayList はみなさんよく使うクラスなのでご存知だと思いますが、initialCapacity を意識したことはありますか？
ArrayList のインスタンスを生成するときに一番見る書き方はこれでしょう。

```Capacity.java
List<?> list = new ArrayList<>()
```

一方で、こんな形でインスタンス生成できることはご存知でしょうか？

```Capacity.java
List<?> list = new ArrayList<>(100)
```

コンストラクタの引数に int の 100 を指定しています。この100が initialCapacity です。ArrayList に初期設定する要素数を指定しています。引数を指定しなかった場合はどうなるのか？ArrayList のソースを見てみましょう。

```java:ArrayList.class（一部を抜粋：コンストラクタ1）
    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};


    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
```

何やら空の配列を elementData に格納しています。これだけだとよくわからないですね。次に add() メソッドの中身を見てみます。

```java:ArrayList.class（一部を抜粋：add周辺）

    /**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return <tt>true</tt> (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;

    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }
```

add() 直後に ensureCapacityInternal() メソッドを呼び出しています。ensureCapacityInternal() の中では minCapacity を設定した上で ensureExplicitCapacity() メソッドを呼び出しています。コンストラクタで initialCapacity を設定しなかった場合、先に見たとおり elementData には DEFAULTCAPACITY_EMPTY_ELEMENTDATA（空の配列）が設定されているので if文の条件を満たし、「minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity)」が行われます。結果、minCapacity に 10 (DEFAULT_CAPACITY) が設定され、それを ensureExplicitCapacity() に渡しています。
ensureExplicitCapacity() は配列の容量を確保しに行くメソッドです。つまり ArrayList のコンストラクタに引数を設定しなかった場合、ArrayList に格納される要素は要素数10個の配列で管理されることになります。
じゃあ、initialCapacity を指定した方のコンストラクタはどうなっているのか？

```java:ArrayList.class（一部を抜粋3）
    /**
     * Constructs an empty list with the specified initial capacity.
     *
     * @param  initialCapacity  the initial capacity of the list
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative
     */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
```

0以外の整数を指定した場合は空の配列ではなく、指定した要素数分の配列を生成しています。add()したときの挙動は、ensureCapacityInternal() メソッドのif文の中を通らないだけで基本的には同じです。

## initialCapacity を指定する意味は？
initialCapacity を指定することに何の意味があるのでしょうか？それは initialCapacity で指定した数を超えた要素を追加した際の挙動を見るとわかります。
実装部分はこれです（ensureCapacityInternal() の続き）。

```java:ArrayList.java（抜粋）
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    /**
     * Increases the capacity to ensure that it can hold at least the
     * number of elements specified by the minimum capacity argument.
     *
     * @param minCapacity the desired minimum capacity
     */
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
```

ensureExplicitCapacity() メソッドの中で、条件を満たした場合に grow() メソッドを呼び出しています。grow() メソッドの`int newCapacity = oldCapacity + (oldCapacity >> 1);`のところがポイントで、要素を追加したことで initialCapacity で確保した要素数を超えた場合は容量を1.5倍しています（端数切捨て）。
※">>"はシフト演算です。[こちら](https://www.javadrive.jp/start/ope/index9.html)参照
では、initialCapacity に10を設定した ArrayList に対して、ループしながら1個ずつ、合計100個の要素を追加した場合、elementData の要素数はどのように変化していくのでしょうか？

初期値：10
11個目の要素を追加：10*1.5=15
16個目の要素を追加：15*1.5=22
23個目の要素を追加：22*1.5=33
34個目の要素を追加：33*1.5=49
50個目の要素を追加：49*1.5=73
74個目の要素を追加：73*1.5=109
ここでやっと100個の要素を追加することができました。

## initialCapacity の設定による性能の違い
この動きって、何かオーバーヘッド発生しそうですよね？どれほどのものなのでしょうか？
10万件のデータをループしながらadd()したときの実行時間を実測してみました。
実測に使ったプログラムはこれです。

```java:DefaultListSize.java
import java.util.ArrayList;
import java.util.List;

public class DefaultListSize {
    private static final int CNT = 100000;
    public static void main(String... args) {
        // initialCapacity 指定なし
        List<Integer> defaultList = new ArrayList<>();

        long startDefautl = System.currentTimeMillis();
        for (int i = 0; i < CNT; i++) {
            defaultList.add(i);
        }
        long endDefautl = System.currentTimeMillis();
        System.out.println("実行時間（ミリ秒）:" + (endDefautl - startDefautl));

        // initialCapacity 指定
        List<Integer> list = new ArrayList<>(CNT);
        long start = System.currentTimeMillis();
        for (int i = 0; i < CNT; i++) {
            list.add(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("実行時間（ミリ秒）:" + (end - start));
    }
}
```

```:実行結果
実行時間（ミリ秒）:4
実行時間（ミリ秒）:1
```

initialCapacity を指定しなかった場合は4ミリ秒で、10万を指定した場合は1ミリ秒でした。
因みに1千万を指定した場合、731ミリ秒と258ミリ秒でした。
PCのスペックも関係するので秒数に関しては何とも言えないですが、initialCapacity を指定することで余計な処理がなくなり、その分高速になるということがわかります。
大量データを扱うことがわかっているのであればちゃんと指定したほうが良さそうですね。

# LinkedList
## 特徴
次は LinkedList です。LinkedList は、要素の追加・削除は得意ですが、ランダムアクセスが苦手という特徴があります。ランダムアクセスというのはソースコードレベルで言うと`list.get(i)`のことです。
この特徴の原因は要素管理の仕方にあります。i番目の要素にi-1番目とi+1番目へのリンクを張るという形で管理されています。要素を取得する際は先頭または末尾からリンクをたどり、削除する場合はリンクを付け替えるだけです。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/254168/a4509628-6c01-d3ee-6819-a0e0cf859dde.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/254168/911a4325-5955-f74b-6bc9-ed2a2d954223.png)

ArrayList と比較することで違いが明確になると思います。
ArrayList は index を使用して直接要素を取得することができるのでランダムアクセスが得意です。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/254168/8bcb397f-e9d7-40c4-3976-a3d592b7c266.png)

逆に削除する場合は配列を再構築する必要があるためオーバーヘッドがかかります。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/254168/75118c23-c2e8-4e4c-92ce-059c58600a20.png)





## ランダムアクセスの挙動の違い
この特徴が原因で、ランダムアクセス時の挙動が ArrayList と LinkedList で異なったものになります。
ArrayList の場合、list.get(i) でランダムアクセスしたとしても、要素を即座に取得することができるため、即時応答することができます。
こんなイメージです。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/254168/b2e17e3b-01ec-8ce8-5c1c-414073edbfd7.png)


LinkedList の場合、先頭の要素から順番にたどっていかないと目的の要素を取得することができません。list.get(4)と書いたとしたら1→2→3→4の順にたどってやっと目的の要素にたどり着きます。
こんなイメージです。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/254168/e95c0d09-b028-1305-5baa-67e016173a36.png)

LinkedList は逆順に走査することも可能なので、上記の例でlist.get(7)としたらきっと10→9→8→7の順にたどってくれます。

## 大量データをループした時の性能は？
ここまでだと「ふーん。で？」だと思います。じゃあ、大量データをループさせて`list.get(i)`したらどうでしょうか？
具体的に言うと、以下のようなクラスがあったとして、このメソッドを呼び出す際の引数に大量データを保有する LinkedList を渡されたらどうなるかわかりますか？
ループしながら list.get(i) している点がポイントです。

```java:ListSizeLoop.java
class ListSizeLoop {
    public void listSizeLoop(List<String> list) {
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}
```

こんな記事を見つけました。まさにこれです。こういう事が起こりえます。
[軽い気持ちでLinkedListを使ったら休出する羽目になった話](https://qiita.com/neko_machi/items/d620c4a8958e74df3550)

## どうすればいいの？
先の記事にもありましたが、list.size() でループするのではなく、拡張for（又は Iterator）を使いましょう。
Listに対して（正確にいうと、Iterable インタフェースを implements しているクラスに対して）拡張forを使うと内部的に Iterator が展開されるようになっています。
Iterator はデザインパターンの一つで、順次処理に特化したインタフェースです。これだけでランダムアクセスを回避できます。
list.size() を使ってループするとこういう事が起こり得るので、明確な理由がない限りは拡張forを使うようにしましょう。

# Arrays$ArrayList
## Arrays$ArrayList は固定長の List
最後は Arrays$ArrayList です。
ArrayList という名前がついていますが、よく知られている`java.util.ArrayList`とは別物です。`java.util.Arrays` クラスの中に ArrayList という名前のインナークラスが存在しており、List インタフェースを implements しています（"$"はインナークラスであることを示すJavaの予約語です）。
これは配列を List に変換したり、インスタンス生成時にあらかじめ要素を指定する場合に便利な List で、固定長を前提にしています。
使い方としては以下のようなイメージになります。

```java:ArraysAsList.java
import java.util.Arrays;
import java.util.List;

public class ArraysAsList {
    public static void main(String... args) {
        String[] strList = new String[3];
        strList[0] = "a";
        strList[1] = "b";
        strList[2] = "c";
        // 配列をListに変換
        List<String> list1 = Arrays.asList(strList);
        for (String str : list1) {
            System.out.println(str);
        }

        // 始めから要素を保有したListを生成
        List<String> list2 = Arrays.asList("d", "e", "f");
        for (String str : list2) {
            System.out.println(str);
        }
    }
}
```

## add() するとどうなるのか？
先ほど固定長を前提にしていると書きましたが、add()するとどうなるのでしょうか？

```java:ArraysAsList2.java
import java.util.Arrays;
import java.util.List;

public class ArraysAsList2 {
    public static void main(String... args) {
        // インスタンス生成後にadd()メソッド呼び出し
        List<String> list = Arrays.asList("d", "e", "f");
        list.add("a");
        for (String str : list) {
            System.out.println(str);
        }
    }
}
```

```:実行結果
Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.AbstractList.add(AbstractList.java:148)
	at java.util.AbstractList.add(AbstractList.java:108)
	at ArraysAsList2.main(ArraysAsList2.java:8)
```

UnsupportedOperationException が発生しました。ちょっと Arrays$ArrayList を見てみましょうか。


```java:Arrays.java
public class Arrays {
    @SafeVarargs
    @SuppressWarnings("varargs")
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

    /**
     * @serial include
     */
    private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
    {
        private static final long serialVersionUID = -2764017481108945198L;
        private final E[] a;

        ArrayList(E[] array) {
            a = Objects.requireNonNull(array);
        }

        @Override
        public int size() {
            return a.length;
        }

        @Override
        public Object[] toArray() {
            return a.clone();
        }

        @Override
        @SuppressWarnings("unchecked")
        public <T> T[] toArray(T[] a) {
            int size = size();
            if (a.length < size)
                return Arrays.copyOf(this.a, size,
                                     (Class<? extends T[]>) a.getClass());
            System.arraycopy(this.a, 0, a, 0, size);
            if (a.length > size)
                a[size] = null;
            return a;
        }

        @Override
        public E get(int index) {
            return a[index];
        }

        @Override
        public E set(int index, E element) {
            E oldValue = a[index];
            a[index] = element;
            return oldValue;
        }

        @Override
        public int indexOf(Object o) {
            E[] a = this.a;
            if (o == null) {
                for (int i = 0; i < a.length; i++)
                    if (a[i] == null)
                        return i;
            } else {
                for (int i = 0; i < a.length; i++)
                    if (o.equals(a[i]))
                        return i;
            }
            return -1;
        }

        @Override
        public boolean contains(Object o) {
            return indexOf(o) != -1;
        }

        @Override
        public Spliterator<E> spliterator() {
            return Spliterators.spliterator(a, Spliterator.ORDERED);
        }

        @Override
        public void forEach(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            for (E e : a) {
                action.accept(e);
            }
        }

        @Override
        public void replaceAll(UnaryOperator<E> operator) {
            Objects.requireNonNull(operator);
            E[] a = this.a;
            for (int i = 0; i < a.length; i++) {
                a[i] = operator.apply(a[i]);
            }
        }

        @Override
        public void sort(Comparator<? super E> c) {
            Arrays.sort(a, c);
        }
    }
}
```

add()メソッドが見当たりません。上位クラスでしょうか？ [AbstractList](https://docs.oracle.com/javase/jp/8/docs/api/java/util/AbstractList.html) を extends しているのでちょっと見てみましょう。



```java:AbstractList.java
    public boolean add(E e) {
        add(size(), e);
        return true;
    }

    /**
     * {@inheritDoc}
     *
     * <p>This implementation always throws an
     * {@code UnsupportedOperationException}.
     *
     * @throws UnsupportedOperationException {@inheritDoc}
     * @throws ClassCastException            {@inheritDoc}
     * @throws NullPointerException          {@inheritDoc}
     * @throws IllegalArgumentException      {@inheritDoc}
     * @throws IndexOutOfBoundsException     {@inheritDoc}
     */
    public void add(int index, E element) {
        throw new UnsupportedOperationException();
    }
```

これですね。問答無用で UnsupportedOperationException を throw しています。
[AbstractList](https://docs.oracle.com/javase/jp/8/docs/api/java/util/AbstractList.html) は他にも ArrayList や Vector、[AbstractSequentialList](https://docs.oracle.com/javase/jp/8/docs/api/java/util/AbstractSequentialList.html) でも extends しています。LinkedList は AbstractSequentialList を extends しているので間接的に AbstractList の配下にいます。
文字で書いてもよくわからないと思いますが、以下の図を見れば AbstractList 配下であることがわかると思います。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/254168/653b77ab-094e-2624-f88d-fec798d068ce.png)

## java.util.ArrayList との違い（実装面）
Arrays$ArrayList 以外で AbstractList を extends しているクラスの例の一つとして、ちょっと ArrayList を覗いてみましょう。

```java:ArrayList.java（add部分を抜粋）
    /**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return <tt>true</tt> (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

    /**
     * Inserts the specified element at the specified position in this
     * list. Shifts the element currently at that position (if any) and
     * any subsequent elements to the right (adds one to their indices).
     *
     * @param index index at which the specified element is to be inserted
     * @param element element to be inserted
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    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++;
    }
```

add() メソッドをオーバーライドしてますね。java.util.ArrayList は AbstractList の add() をオーバーライドしているから UnsupportedOperationException は発生せず、実装された処理が行われます。Arrays$ArrayList は add() メソッドをオーバーライドしていないため、UnsupportedOperationException が発生します。同じ ArrayList という名前がついているのに全然違いますね・・・。
AbstractList は List インタフェースを一部 implements しているものです。必要最低限の実装をすることで具象クラスとして実装が必要な部分を減らしているのですが、set(), add(), remove() に関してはオーバーライドしないと UnsupportedOperationException を throw するようになっています。
Arrays$ArayList は add() だけではなく remove() もオーバーライドしていないため、同じことが起きます。set() はオーバーライドしているので、このメソッドを呼び出すことで既存の要素を別のものに入れ替えることができます。

## 配列を可変長の List に変換したい場合
add() と remove() が呼び出せないので Arrays$ArayList は固定長となっています。もし配列を可変長の List に変換したい場合は以下のようにしましょう。

```java:ArraysAsList3.java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ArraysAsList3 {
    public static void main(String... args) {
        String[] strList = new String[3];
        strList[0] = "a";
        strList[1] = "b";
        strList[2] = "c";
        // ArrayListのコンストラクタを経由して配列をListに変換
        List<String> list = new ArrayList<>(Arrays.asList(strList));
        for (String str : list) {
            System.out.println(str);
        }
    }
}
```

`List<String> list = new ArrayList<>(Arrays.asList(strList));`という記述で、配列 → Arrays$ArrayList → ArrayList の順に変換しています。
ArrayList のコンストラクタには、先に紹介した initialCapacity と別にもう一つ、Collection を受け取るコンストラクタが存在します。このコンストラクタを使うことで、`Arrays$ArrayList` を `java.util.ArrayList` に変換することができます。
AbstractList は AbstractCollection を extends しており、AbstractCollection は Collection を implements しているため、このコンストラクタの引数に Arrays$ArrayList を渡すことができます。
これもさっきの図を見たほうがわかりやすいと思います。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/254168/653b77ab-094e-2624-f88d-fec798d068ce.png)

Collection を受け取る ArrayList のコンストラクタの実装は以下のようになっています。

```java:ArrayList（コンストラクタを一部抜粋）
    /**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @param c the collection whose elements are to be placed into this list
     * @throws NullPointerException if the specified collection is null
     */
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }
```

私がまだ Java を使いはじめて間もない頃、Arrays$ArrayList を `java.util.ArrayList` と同じものだと勘違いしていてかなり混乱したことがあったので記載させて頂きました。

# 終わりに
List について思いついたことをつらつらと書いた感じになってしまいました。「あ、そうだったんだ！？」という気付きが一つでもあったら幸いです。
以上。