Java 8 ArrayList 初始容量坏了？

Question

Today I was looking in cloning an ArrayList when I ran in a weird problem. I read this answer and tried that. However, I received an ArrayOutOfBounds exception. So I looked a bit more into it, and appearently the ArrayList<>(int size) is not working?
Is this a known problem?

Test class:

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

public class ArrayListTest {
    @Test
    public void test() {
        List<String> lista = new ArrayList<>();
        lista.add("a");
        List<String> listb = new ArrayList<>(lista.size());
        System.out.println("Size of lista: " + lista.size());
        System.out.println("Size of listb: " + listb.size());
    }
}

Troubled class:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.junit.Test;

public class ArrayListTest2 {
    @Test
    public void test() {
        List<String> lista = new ArrayList<>();
        lista.add("a");
        List<String> listb = new ArrayList<>(lista.size());
        Collections.copy(listb, lista);
        System.out.println("Lista: " + lista);
        System.out.println("Listb: " + listb);
    }
}

Which results in:

java.lang.IndexOutOfBoundsException: Source does not fit in dest
at java.util.Collections.copy(Collections.java:556)
at ArrayListTest2.test(ArrayListTest2.java:13)

Any ideas?

Answer 1

This is really a problem with the documentation of Collections.copy() . Its JDK 8 documentation says:

The destination list must be at least as long as the source list. If it is longer, the remaining elements in the destination list are unaffected.

This uses the terms "long" and "longer" which seem to refer to the length of a list. However, if you look at the List specification, there is no definition of length -- there are however definitions for size and, in ArrayList , for capacity . It's unclear whether Collections.copy() is defined in terms of the size or capacity of the lists.

In fact, Collections.copy() should be defined in terms the size of the lists. The JDK 9 specification of Collections.copy() has been modified to read:

The destination list's size must be greater than or equal to the source list's size. If it is greater, the remaining elements in the destination list are unaffected.

The arg to the ArrayList constructor sets its initial capacity , not its size . The size is the number of elements that are currently present in the list. Collections.copy() requires the destination list's size to be greater or euqal to the source's size. That's why you get IndexOutOfBoundsException when you try to copy a list of size 1 into a list of size 0.

Answer 2

If the target List is too small.I will throw IndexOutOfBoundsException.

import java.util.*;

public class CollectionsDemo {
   public static void main(String args[]) {
      // create two lists    
      List<String> srclst = new ArrayList<String>(5);
      List<String> destlst = new ArrayList<String>(10);

      // populate two lists
      srclst.add("a");
      srclst.add("b");
      srclst.add("d");

      destlst.add("e");
      destlst.add("f");
      destlst.add("g");


      // copy into dest list
      Collections.copy(destlst, srclst);            

      System.out.println("Value of source list: "+srclst);
      System.out.println("Value of destination list: "+destlst);
   }    

Answer 3

I think there is a problem with your understanding of the initialCapacity . Like when you initialize an array of primitive that gets filled with 'null' values, nothing as such happens during the initialization of an ArrayList . By setting an initialCapacity of n , all you are doing is letting the compiler know that it should allocate enough memory for n objects. Please note, that even though memory has been allocated, the size of the list is still 0 since there are no elements inside it.

About the copy() . You are trying to copy lista into a list with an initial capacity of lista.size() = 0 . Doesn't something seem amiss there?

This confusion may be warranted to the fact that the documentation simply doesn't mention the word size , yet that is the key factor here.