Java中的`ArrayList`是基于数组实现的动态数组，它提供了比标准数组更多的灵活性，特别是在大小方面。`ArrayList`的底层原理主要依赖于以下几个关键点：
1. 数组：`ArrayList`内部维护了一个数组，这个数组用于存储集合中的元素。数组的特点是提供了快速随机访问的能力，即通过索引可以直接访问元素。
2. 动态扩容：`ArrayList`会根据需要自动扩容。当数组中的元素达到一定数量时，`ArrayList`会创建一个新的、更大的数组，并将现有元素复制到这个新数组中。这个过程称为“扩容”。扩容通常发生在以下情况：
   - 当尝试向已满的`ArrayList`中添加新元素时。
   - 当调用`ensureCapacityInternal()`方法显式地要求`ArrayList`保证有足够的容量时。
3. 索引访问：`ArrayList`支持基于索引的访问，这意味着可以快速地通过索引来获取或修改数组中的元素。索引访问的时间复杂度是O(1)。
4. 迭代器：`ArrayList`提供了迭代器（Iterator），用于遍历集合中的元素。迭代器是fail-fast的，这意味着如果在迭代过程中集合结构被修改，迭代器会立即抛出`ConcurrentModificationException`。
5. 容量和大小：`ArrayList`有两个重要的概念：容量（capacity）和大小（size）。容量指的是数组的长度，而大小指的是集合中实际包含的元素数量。`ArrayList`的容量可以大于其大小，这样可以减少扩容操作的次数。
6. 空数组：在创建`ArrayList`时，如果没有指定初始容量，`ArrayList`会默认创建一个空数组。这个空数组的大小取决于`ArrayList`的内部类`ElementData`的构造函数。在 Java 8 中，如果没有指定初始容量，会使用默认的容量大小，通常是10。
下面是一个简单的`ArrayList`的内部实现示例：
```java
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892154L;
    // 默认容量大小
    private static final int DEFAULT_CAPACITY = 10;
    // 实际存储元素的数组
    transient Object[] elementData; // non-private to simplify nested class access
    // 数组的大小
    private int size;
    // 构造函数，根据需要创建数组
    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);
        }
    }
    // 无参构造函数，使用默认容量
    public ArrayList() {
        this.elementData = EMPTY_ELEMENTDATA;
    }
    // 确保容量足够
    private void ensureCapacityInternal(int minCapacity) {
        // 如果当前容量小于所需容量，则进行扩容
        if (elementData == 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);
    }
    // 扩容方法，增加容量
    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);

       ```
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE : MAX_ARRAY_SIZE;
    }
    // 添加元素到数组末尾
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    // 其他方法，如add(int, E)，get(int)，set(int, E)，remove(int)等
    // ...
}
```
在上面的代码中，`grow`方法是扩容的核心，它会将数组的大小增加一倍，或者增加到`minCapacity`指定的最小容量，以二者中的较大值为准。如果数组大小超过了`Integer.MAX_VALUE`，则会抛出`OutOfMemoryError`。
`ArrayList`的这些行为使得它在处理大小变化较频繁的集合时效率较高，因为它避免了频繁地创建和销毁数组。然而，在大量添加元素的情况下，扩容操作可能会导致性能下降，因为每次扩容都需要复制现有元素到新的数组中。
总的来说，`ArrayList`是一个灵活、方便的集合类，它提供了快速的随机访问和动态扩容的能力，是Java集合框架中的一个重要组件。