如何在集合中区分意图性空值与未初始化槽位

public class ExpandableArray<T> {
    private Object[] elements;
    private int size;

    // 定义一个静态内部类作为占位符
    private static class Placeholder {
        private Placeholder() {} // 私有构造函数，防止外部实例化
        @Override
        public String toString() {
            return "INTENTIONAL_NULL"; // 便于调试
        }
    }

    // 唯一的占位符实例
    public static final Object INTENTIONAL_NULL_PLACEHOLDER = new Placeholder();

    public ExpandableArray(int initialCapacity) {
        if (initialCapacity < 0) {
            throw new IllegalArgumentException("Initial capacity cannot be negative.");
        }
        this.elements = new Object[initialCapacity];
        this.size = 0; // 记录实际存储的元素数量，不包括占位符
    }

    // 添加元素到第一个“真正”的空闲位置
    public void add(T item) {
        if (item == null) {
            throw new IllegalArgumentException("Cannot add null elements directly. Use replace for intentional nulls.");
        }
        ensureCapacity();
        for (int i = 0; i < elements.length; i++) {
            // 查找第一个既不是null也不是占位符的位置
            if (elements[i] == null || elements[i] == INTENTIONAL_NULL_PLACEHOLDER) {
                // 如果是占位符，跳过，寻找真正的空槽
                if (elements[i] == INTENTIONAL_NULL_PLACEHOLDER) {
                    continue; // 跳过有意为空的位置
                }
                elements[i] = item;
                size++;
                return;
            }
        }
        // 如果没有找到空槽，但容量足够，这通常意味着逻辑错误或需要调整查找策略
        // 对于本例，我们假设ensureCapacity会处理好
    }

    // 替换指定索引的元素，允许设置占位符
    public void replace(int index, T item) {
        if (index < 0 || index >= elements.length) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + elements.length);
        }

        // 如果要替换为null，则使用占位符
        if (item == null) {
            // 如果原位置不是占位符且不为null，说明减少了一个实际元素
            if (elements[index] != null && elements[index] != INTENTIONAL_NULL_PLACEHOLDER) {
                size--;
            }
            elements[index] = INTENTIONAL_NULL_PLACEHOLDER;
        } else {
            // 如果原位置是null或占位符，并且现在放入了实际元素，则增加实际元素数量
            if (elements[index] == null || elements[index] == INTENTIONAL_NULL_PLACEHOLDER) {
                size++;
            }
            elements[index] = item;
        }
    }

    // 获取指定索引的元素
    @SuppressWarnings("unchecked")
    public T get(int index) {
        if (index < 0 || index >= elements.length) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + elements.length);
        }
        // 返回null或占位符时，需要外部逻辑判断
        if (elements[index] == INTENTIONAL_NULL_PLACEHOLDER) {
            return null; // 或者抛出特定异常，取决于业务需求
        }
        return (T) elements[index];
    }

    // 确保数组容量的方法（省略具体实现）
    private void ensureCapacity() {
        // 实际实现会检查size是否达到elements.length，如果达到则扩容
        // 为了简化示例，这里不展开
        if (size >= elements.length) {
             // 示例扩容逻辑
            Object[] newElements = new Object[elements.length * 2];
            System.arraycopy(elements, 0, newElements, 0, elements.length);
            elements = newElements;
        }
    }

    public int actualSize() {
        return size; // 返回实际非占位符非null元素的数量
    }

    public void printArray() {
        System.out.print("[");
        for (int i = 0; i < elements.length; i++) {
            if (i > 0) System.out.print(", ");
            if (elements[i] == INTENTIONAL_NULL_PLACEHOLDER) {
                System.out.print("INTENTIONAL_NULL");
            } else {
                System.out.print(elements[i]);
            }
        }
        System.out.println("]");
    }

    public static void main(String[] args) {
        ExpandableArray<String> expArr = new ExpandableArray<>(3);
        System.out.println("Initial: ");
        expArr.printArray(); // [null, null, null]

        expArr.add("p1");
        expArr.add("p2");
        System.out.println("After add p1, p2: ");
        expArr.printArray(); // [p1, p2, null]

        expArr.replace(0, null); // 替换第一个元素为有意为空
        System.out.println("After replace(0, null): ");
        expArr.printArray(); // [INTENTIONAL_NULL, p2, null]

        expArr.add("p3"); // 应该添加到第三个位置 (索引2)
        System.out.println("After add p3: ");
        expArr.printArray(); // [INTENTIONAL_NULL, p2, p3]

        expArr.replace(1, null); // 替换第二个元素为有意为空
        System.out.println("After replace(1, null): ");
        expArr.printArray(); // [INTENTIONAL_NULL, INTENTIONAL_NULL, p3]

        expArr.add("p4"); // 应该扩容并添加到新的空位
        System.out.println("After add p4 (should trigger capacity check): ");
        expArr.printArray(); // [INTENTIONAL_NULL, INTENTIONAL_NULL, p3, p4, null, null] (取决于ensureCapacity实现)

        System.out.println("Actual size: " + expArr.actualSize()); // 应该为2 (p3, p4)
    }
}