JAVA中的ArrayList构造

Posted 2023-03-19

public static void fullPermutation(ArrayList<Character> list,ArrayList<Character> result)
/*
if(list.size()==0)
for(int i=0;i<result.size();i++)
System.out.print(result.get(i));

System.out.print("\r\n");
return;

*/

for(int i=0;i<list.size();i++)
ArrayList<Character> tlist=new ArrayList<Character>(list);
ArrayList<Character> nlist=new ArrayList<Character>(result);
nlist.add(tlist.get(i));
tlist.remove(i);
fullPermutation(tlist,nlist);


为什么出错；貌似是这样构造就是错的。

参考技术A 作用域的问题，你每循环一次，都声明一个对象，然后循环执行完了就释放掉，最后，你准备干什么呢？追问

字母全排列。但是我在递归呀

追答

你在递归，但是你有结束递归的方法吗？

java.util之一：ArrayList

ArrayList是java中的线性结构的一种表示方法，在java中使用频率非常高，下面来一步一步分析其底层的实现。（JDK1.8）

一、构造函数

ArrayList的构造函数有三个，分别如下，

我们最常使用的的无参的构造函数，那么无参的构造函数是如何定义的那，

public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

从上面看到无参构造函数，实际上是把elementData赋予了默认容量的一个数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA；

 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

那么有参数的构造函数那，

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，如果大于0则使用此值生成Object数组。如果等于0则和无参构造函数是一样的。如果小于0则抛出异常。在实际开发中强烈建议使用带参数的构造函数（为什么下面说）。
最后一个构造函数如下，

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;
        }
    }

从上面的代码中可以看出，把集合类c调用toArray方法，返回其数组赋给elementData，然后对elementData进行判断如果长度不为0，这判断elementData的类型是否为Object，如果不是则使用Object进行替换，统一处理成Obejct的类型，因为在java中所有的类的父类都是Object。
二、成员变量

在ArrayList中主要的成员变量有elementData和size，elementData代表底层ArrayList的存储结构，即ArrayList是用数组来保存数据的；size指的是ArrayList中元素的个数（和elementData的长度区分开）。其他的成员变量像默认的初始容量为10。ArrayList在使用无参构造函数的时候分配内存的时候采用了懒加载的模式，即使用new ArrayList的时候底层不会分配空间，在真正向ArrayList中放元素的时候才会真正初始化数组长度。

三、常用方法

1、set/add

set和add方法的不同之处在于set方法会返回被覆盖的值，而add则不会

set(int index,E element)

在index处插入元素element，其具体实现如下

public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

从上面的代码中可以看出，首先需要判断index是否合法，

 private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

也就是说如果index大于ArrayList中元素的个数，则抛出异常，这里有个疑问ArrayList是使用数组存储，默认长度是10，那么向ArrayList中添加一个元素后其数组的长度为10，ArrayList中的元素为1，为什么不允许index大于size插入那。
在判断完index不大于size后，把要插入的元素放在数组中下标为index的位置，返回之前的元素。

add(E e)

向ArrayList中插入元素e返回boolean类型，表示是否插入成功。

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

可以看到首先要确保数组的容量，

private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

判断elementData是否为空数组，如果是空数组返回初始容量和size+1两个数中大的那个，这里应该返回初始容量10。
下个方法是，

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

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

如果minCapacity大于数组的长度则进行扩容，

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);
    }

上面代码的意思是计算原数组的大小并且加上其右移1位（原大小的1.5倍）记为newCapacity。把要扩容到的大小和newCapacity比较，取两者中比较大的那个作为数组的容量。把原先的数组中的元素拷贝到新的数组中。
在回头来看add方法中的elementData[size++] = e;由于已经对数组进行了扩容，则可以把e放在size+1的位置上，返回true。

下面看add(int index,E e)

在index处插入e元素，

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++;
    }

验证index的合法性

private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

然后确定底层数组的容量，判断是否需要扩容，如果不需要则把e插入到index的位置，这里不是使用的循环移动插入，而是进行了数组的分部分拷贝，把index前的元素和index后的元素进行拷贝，最后把e插入在index处，这种方式比循环移动插入要快（使用底层的拷贝技术）。

2、get方法

根据index取得ArrayList中的元素，

public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }

判断给定的index的值比较和size的大小，如果超过了size则抛出异常，否则返回其index处的值。
3、contains(Object o)方法

判断o是否在ArrayList中，由于ArrayList使用数组存储元素，所以它是允许存重复值的，而contains方法返回的则是o第一次出现的位置。

public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

可以看到ArrayList中允许存null值，且可以存多个。
如果o不是null，则从头开始循环直到第一个为o的元素出现，返回其下标否则返回-1，最后根据indexOf的值大于0的返回true，否则false。

4、remove(int index)/remove(Object o)

从ArrayList中删除元素，可以按照索引和元素进行删除。按照元素删除仅会删除给定元素第一个的位置，其余不会删除。

remove(int index)

public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

首先依然是判断删除位置是否合法。如果合法则取得要删除索引位置的元素值（返回），因为要删除那么必然会进行数组的移动，即把删除位置后的数组向前移动，这里使用的是数组的拷贝。
remove(Object o)

按照元素进行删除，删除ArrayList中的第一个为o的元素，

public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

这里仍然把null的情况单独处理，我们看不为null的情况的删除，使用size遍历整个数组，在数组中找到等于给定元素的下标，调用fastMove方法按照下标删除，只会把o第一次出现的位置上的元素删除，即重复的不会删除。

private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

上面还是按照下标进行删除。

未完待续。