在对象数组中区分意图性空值：哨兵对象模式的应用

ExpandableArray expArr = new ExpandableArray(3); // 初始大小为3
expArr.add(p1); // [p1, null, null]
expArr.add(p2); // [p1, p2, null]
expArr.replace(0, null); // 将第一个元素替换为null，预期结果：[null, p2, null]

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

    // 哨兵对象：表示一个被特意清空的Product位置
    public static final Product INTENTIONAL_NULL_PLACEHOLDER = new Product("INTENTIONAL_NULL_PLACEHOLDER", 0.0);

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

    // 省略getter/setter和其他方法

    @Override
    public String toString() {
        if (this == INTENTIONAL_NULL_PLACEHOLDER) {
            return "[INTENTIONAL_NULL]";
        }
        return "Product{" + "name='" + name + '\'' + ", price=" + price + '}';
    }
}

public class ExpandableArray {
    private Product[] products;
    private int size; // 实际存储的元素数量

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

    /**
     * 添加产品到第一个非意图性空值或普通空值的位置。
     * 如果数组已满，需要扩容。
     */
    public void add(Product p) {
        if (p == null) {
            throw new IllegalArgumentException("Cannot add null product. Use replace with placeholder for intentional nulls.");
        }

        int targetIndex = -1;
        // 查找第一个非哨兵对象且为null的位置
        for (int i = 0; i < products.length; i++) {
            if (products[i] == null) { // 找到一个普通空值
                targetIndex = i;
                break;
            }
        }

        if (targetIndex != -1) {
            products[targetIndex] = p;
            size++;
        } else {
            // 如果没有普通空值，但有哨兵对象，则尝试在哨兵对象后添加
            // 或者简单地在数组末尾添加（如果需要扩容）
            // 这里为了简化，我们假设add总是找第一个真正的null
            // 如果没有null，则扩容并添加
            // 实际应用中，如果需要跳过哨兵，逻辑会更复杂，可能需要遍历所有非哨兵位置
            if (size < products.length) { // 还有空间，但可能被哨兵占据
                 // 这种情况需要重新考虑add的语义，如果add不能覆盖哨兵，
                 // 那么上面的for循环应该检查 !products[i].equals(Product.INTENTIONAL_NULL_PLACEHOLDER)
                 // 这里为了匹配问题描述，add不触碰意图性空值，所以只找null
                 // 如果没有找到null，说明数组已满或只剩哨兵
                 // 如果需要扩容，则在扩容后添加
                resize(); // 扩容
                products[size++] = p;
            } else {
                resize(); // 扩容
                products[size++] = p;
            }
        }
    }

    /**
     * 替换指定索引的产品。
     * 如果传入null，则替换为哨兵对象，表示意图性空值。
     */
    public void replace(int index, Product p) {
        if (index < 0 || index >= products.length) {
            throw new IndexOutOfBoundsException("Index " + index + " out of bounds for length " + products.length);
        }

        if (p == null) {
            // 如果要替换为null，则使用哨兵对象
            products[index] = Product.INTENTIONAL_NULL_PLACEHOLDER;
        } else {
            products[index] = p;
        }
        // 注意：这里没有改变size，因为是替换操作
        // 如果替换前是null，替换后是Product，size可能需要调整
        // 如果替换前是Product，替换后是null(哨兵)，size可能需要调整
        // 具体的size逻辑取决于ExpandableArray的完整设计
        // 为了简化，这里假设size只在add时增加
    }

    // 扩容方法
    private void resize() {
        int newCapacity = products.length == 0 ? 1 : products.length * 2;
        Product[] newProducts = new Product[newCapacity];
        for (int i = 0; i < products.length; i++) {
            newProducts[i] = products[i];
        }
        this.products = newProducts;
    }

    // 获取元素，需要判断是否是哨兵
    public Product get(int index) {
        if (index < 0 || index >= products.length) {
            throw new IndexOutOfBoundsException("Index " + index + " out of bounds.");
        }
        Product item = products[index];
        if (item == Product.INTENTIONAL_NULL_PLACEHOLDER) {
            return null; // 对外表现为null，但内部有区分
        }
        return item;
    }

    // 打印数组内容
    public void printArray() {
        System.out.print("[");
        for (int i = 0; i < products.length; i++) {
            if (products[i] == Product.INTENTIONAL_NULL_PLACEHOLDER) {
                System.out.print("INTENTIONAL_NULL");
            } else {
                System.out.print(products[i]);
            }
            if (i < products.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("]");
    }

    public static void main(String[] args) {
        ExpandableArray expArr = new ExpandableArray(3);
        Product p1 = new Product("Laptop", 1200.0);
        Product p2 = new Product("Mouse", 25.0);
        Product p3 = new Product("Keyboard", 75.0);

        System.out.println("--- Initial State ---");
        expArr.printArray(); // [null, null, null]

        expArr.add(p1);
        System.out.println("--- After add p1 ---");
        expArr.printArray(); // [Product{name='Laptop', price=1200.0}, null, null]

        expArr.add(p2);
        System.out.println("--- After add p2 ---");
        expArr.printArray(); // [Product{name='Laptop', price=1200.0}, Product{name='Mouse', price=25.0}, null]

        expArr.replace(0, null); // 替换为意图性空值
        System.out.println("--- After replace(0, null) ---");
        expArr.printArray(); // [INTENTIONAL_NULL, Product{name='Mouse', price=25.0}, null]

        expArr.add(p3); // 期望添加到索引2
        System.out.println("--- After add p3 ---");
        expArr.printArray(); // [INTENTIONAL_NULL, Product{name='Mouse', price=25.0}, Product{name='Keyboard', price=75.0}]

        // 验证get方法
        System.out.println("--- Get elements ---");
        System.out.println("Element at 0: " + expArr.get(0)); // 应该返回null
        System.out.println("Element at 1: " + expArr.get(1));
        System.out.println("Element at 2: " + expArr.get(2));
    }
}