Java集合在达到大小时自动重新分配

我不确定我是否使用了正确的术语，但我很好奇，在Java中，当集合满了时，它是如何决定增加多少集合的大小的？我试过搜索，但没有找到任何有用的东西

所以，如果我有

List l = new ArrayList(1);
l.add("1");
l.add("2");

列表l=新阵列列表（1）；
l、 添加（“1”）；
l、 添加（“2”）；

它如何决定增加列表的大小？它是否总是一个设定值？如果是，该值是多少？如果比特集的信息不同，我也会对它感兴趣

谢谢，如果我需要澄清，请告诉我
 通常容量加倍（或乘以常数）。这样可以确保插入新元素所需的时间大约为O（n）（与n的大小无关）。
它调用
ensureCapacity
：

/**
 * Increases the capacity of this <tt>ArrayList</tt> instance, if
 * necessary, to ensure that it can hold at least the number of elements
 * specified by the minimum capacity argument.
 *
 * @param   minCapacity   the desired minimum capacity
 */
public void ensureCapacity(int minCapacity) {
    modCount++;
    int oldCapacity = elementData.length;
    if (minCapacity > oldCapacity) {
        Object oldData[] = elementData;
        int newCapacity = (oldCapacity * 3) / 2 + 1;
        if (newCapacity < minCapacity)
            newCapacity = minCapacity;
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
}

/**
*如果需要，请增加此ArrayList实例的容量
*必要时，确保它至少可以容纳元素的数量
*由最小容量参数指定。
*
*@param minCapacity所需的最小容量
*/
公共空间容量（国际最小容量）{
modCount++；
int oldCapacity=elementData.length；
如果（最小容量>旧容量）{
对象oldData[]=elementData；
int newCapacity=（旧容量*3）/2+1；
if（新容量<最小容量）
新容量=最小容量；
//minCapacity通常接近大小，因此这是一个胜利：
elementData=Arrays.copyOf（elementData，newCapacity）；
}
}

因此，正如您所看到的，
newCapacity
是
（oldCapacity*3）/2+1
ArrayList的源代码包含一些线索：

/**
 * 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) {
ensureCapacity(size + 1);  // Increments modCount!!
elementData[size++] = e;
return true;
}


/**
 * Increases the capacity of this <tt>ArrayList</tt> instance, if
 * necessary, to ensure that it can hold at least the number of elements
 * specified by the minimum capacity argument.
 *
 * @param   minCapacity   the desired minimum capacity
 */
public void ensureCapacity(int minCapacity) {
modCount++;
int oldCapacity = elementData.length;
if (minCapacity > oldCapacity) {
    Object oldData[] = elementData;
    int newCapacity = (oldCapacity * 3)/2 + 1;
        if (newCapacity < minCapacity)
    newCapacity = minCapacity;
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
}
}

/**
*将指定的元素追加到此列表的末尾。
*
*要附加到此列表的@param e元素
*@return true（由{@link Collection#add}指定）
*/
公共布尔加法（E）{
ensureCapacity（大小+1）；//递增modCount！！
elementData[size++]=e；
返回true；
}
/**
*如果需要，请增加此ArrayList实例的容量
*必要时，确保它至少可以容纳元素的数量
*由最小容量参数指定。
*
*@param minCapacity所需的最小容量
*/
公共空间容量（国际最小容量）{
modCount++；
int oldCapacity=elementData.length；
如果（最小容量>旧容量）{
对象oldData[]=elementData；
int newCapacity=（旧容量*3）/2+1；
if（新容量<最小容量）
新容量=最小容量；
//minCapacity通常接近大小，因此这是一个胜利：
elementData=Arrays.copyOf（elementData，newCapacity）；
}
}

此行：
int newCapacity=（旧容量*3）/2+1显示ArrayList的更改量。
ArrayList容量会根据需要增加。当您在其上设置容量时，您正在设置初始容量-您正在向构造函数提供猜测，以便集合具有良好的初始大小。ArrayList！=数组。
它取决于您使用的JDK实现。我发现（在Apache Harmony中使用）：

int增量=大小/2；
如果需要（必需>增量）{
增量=所需；
}
如果（增量<12）{
增量=12；
}

意味着尺寸增加了旧尺寸的一半，最小为12

但是正如我所说的，这是特定于实现的，所以所有JVM都可以用自己的方式处理这个问题。
Java中的ArrayList永远不会满，当它满了时，它的大小会增加，需要向其中添加更多数据

如果您想询问底层实现，我假设ArrayList可以使用数组来包含数据。然后，我认为当ArrayList保存的数组已满时，ArrayList将创建一个大小为两倍的新数组，并将所有元素从旧数组复制到新数组。但这是我的假设，您需要阅读java文档
ArrayList包含一个对象数组，如果大小增加，该数组会增加，以确保数组中的元素可以增加

内部
ArrayList.ensureCapacity（）

如有必要，将此ArrayList实例的容量增加到
确保它至少可以容纳
指定的元素数
最小容量参数

add（ee）
调用
ensureCapacity（）

public-capacity（int-minCapacity）{
modCount++；
int oldCapacity=elementData.length；
如果（最小容量>旧容量）{
对象oldData[]=elementData；
int newCapacity=（旧容量*3）/2+1；
if（新容量<最小容量）
新容量=最小容量；
//minCapacity通常接近大小，因此这是一个胜利：
elementData=Arrays.copyOf（elementData，newCapacity）；
}
}
根据，
除了添加要素具有恒定的摊余时间成本这一事实之外，没有详细说明增长政策

因此，尽管人们发布JDK源代码很好，但在不同版本中可能会有所不同；没有保证的增长因子。
您尝试过阅读代码吗？显然，我没有。谢谢你的回答，其他人。我的假设是错误的。根据其他人的回答，实际大小为（oldCapacity*3）/2+1
int increment = size / 2;
if (required > increment) {
    increment = required;
}
if (increment < 12) {
    increment = 12;
}

public void ensureCapacity(int minCapacity) {
    modCount++;
    int oldCapacity = elementData.length;
    if (minCapacity > oldCapacity) {
        Object oldData[] = elementData;
        int newCapacity = (oldCapacity * 3)/2 + 1;
            if (newCapacity < minCapacity)
        newCapacity = minCapacity;
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
    }
    }