自定义数组中特殊空值的处理策略：使用占位符对象

public class Product {
    private String name;
    private double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    // 假设Product有getter方法
    public String getName() { return name; }
    public double getPrice() { return price; }

    // 覆盖equals和hashCode方法，确保占位符的唯一性检查
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Product product = (Product) o;
        return Double.compare(product.price, price) == 0 &&
               name.equals(product.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, price);
    }
}

public class ExpandableArray {
    // 定义一个静态的、最终的占位符对象
    // 这是一个特殊的Product实例，用于表示“意图性空位”
    public static final Product INTENTIONAL_EMPTY_SLOT = new Product("@@INTENTIONAL_EMPTY_SLOT@@", -1.0);

    private Product[] elements;
    private int size; // 实际存储的元素数量 (不包括真正的null和占位符)

    public ExpandableArray(int initialCapacity) {
        this.elements = new Product[initialCapacity];
        this.size = 0;
    }

    // ... 其他方法 ...
}

public class ExpandableArray {
    public static final Product INTENTIONAL_EMPTY_SLOT = new Product("@@INTENTIONAL_EMPTY_SLOT@@", -1.0);

    private Product[] elements;
    private int capacity; // 数组的当前容量

    public ExpandableArray(int initialCapacity) {
        this.capacity = initialCapacity;
        this.elements = new Product[capacity];
    }

    // 添加产品到第一个真正的空闲位置（null）
    public void add(Product p) {
        if (p == null) {
            throw new IllegalArgumentException("Cannot add null product. Use replace with INTENTIONAL_EMPTY_SLOT for intentional emptiness.");
        }
        ensureCapacity(); // 确保数组有足够的容量

        for (int i = 0; i < capacity; i++) {
            if (elements[i] == null) { // 寻找真正的空闲位置
                elements[i] = p;
                return;
            }
        }
        // 如果没有找到null，说明所有位置都被占用或被INTENTIONAL_EMPTY_SLOT标记
        // 这通常不应该发生，因为ensureCapacity会保证有空间
        // 如果发生，可能需要进一步的逻辑，例如抛出异常或扩展数组
    }

    // 替换指定索引处的元素
    public void replace(int index, Product p) {
        if (index < 0 || index >= capacity) {
            throw new IndexOutOfBoundsException("Index " + index + " out of bounds for capacity " + capacity);
        }
        // p可以是实际的产品，也可以是占位符INTENTIONAL_EMPTY_SLOT
        // 如果p为null，则抛出异常，强制使用占位符来表达意图性空
        if (p == null) {
             throw new IllegalArgumentException("Cannot replace with null. Use ExpandableArray.INTENTIONAL_EMPTY_SLOT for intentional emptiness.");
        }
        elements[index] = p;
    }

    // 辅助方法：确保数组容量
    private void ensureCapacity() {
        // 实际实现可能更复杂，这里简化
        // 如果需要扩展，创建一个更大的新数组，并将旧元素（包括占位符）复制过去
        // 重要的是，复制时要区分null和INTENTIONAL_EMPTY_SLOT
        boolean hasNullSlot = false;
        for (int i = 0; i < capacity; i++) {
            if (elements[i] == null) {
                hasNullSlot = true;
                break;
            }
        }
        if (!hasNullSlot) {
            // 简单扩容示例
            int newCapacity = capacity * 2;
            Product[] newElements = new Product[newCapacity];
            System.arraycopy(elements, 0, newElements, 0, capacity);
            this.elements = newElements;
            this.capacity = newCapacity;
        }
    }

    // 示例：获取元素，外部调用者可能需要区分真正的null和占位符
    public Product get(int index) {
        if (index < 0 || index >= capacity) {
            throw new IndexOutOfBoundsException();
        }
        // 内部返回占位符，外部需要自行判断
        return elements[index]; 
    }

    // 示例：移除元素，将其标记为INTENTIONAL_EMPTY_SLOT
    public void remove(int index) {
        replace(index, INTENTIONAL_EMPTY_SLOT);
    }

    // 示例：清理某个位置，使其成为真正的null
    public void clear(int index) {
        if (index < 0 || index >= capacity) {
            throw new IndexOutOfBoundsException();
        }
        elements[index] = null;
    }
}

ExpandableArray expArr = new ExpandableArray(3);
Product p1 = new Product("Product A", 10.0);
Product p2 = new Product("Product B", 20.0);

expArr.add(p1); // [p1, null, null]
expArr.add(p2); // [p1, p2, null]

// 意图性地将第一个位置标记为空
expArr.replace(0, ExpandableArray.INTENTIONAL_EMPTY_SLOT); // [INTENTIONAL_EMPTY_SLOT, p2, null]

Product p3 = new Product("Product C", 30.0);
expArr.add(p3); // add方法会跳过INTENTIONAL_EMPTY_SLOT，找到第三个位置的null
// 结果：[INTENTIONAL_EMPTY_SLOT, p2, p3]

// 如果想让第一个位置真正空出来，可以调用clear方法
expArr.clear(0); // [null, p2, p3]

Product p4 = new Product("Product D", 40.0);
expArr.add(p4); // add方法现在会填充第一个位置
// 结果：[p4, p2, p3]