自定义泛型ListArray插入T类型对象的测试断言问题

嘿，我来帮你搞定这个自定义泛型ListArray的断言问题！你遇到的插入元素后断言不相等的情况，大概率是泛型数组的类型处理、元素存储逻辑，或者断言比较方式出了问题——毕竟咱们是手动基于数组实现泛型，不像Java自带容器帮咱们封装好了细节。

常见问题原因&修复方案 #

1. 泛型数组的类型转换处理不当

Java泛型是编译期擦除机制，没法直接创建T[]类型的数组，所以很多人会用Object[]作为底层存储，但如果取出元素时没正确强转成T，就会导致类型不匹配，甚至断言时出现奇怪的结果。

修复方式：
确保你的get方法正确将Object强转为T，同时add方法只接受T类型的元素，保证存储的都是合法的T实例：

public T get(int index) {
    // 先做索引合法性检查
    if (index < 0 || index >= size) {
        throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
    }
    // 这里的强转是安全的，因为add方法只允许存入T类型
    return (T) elements[index];
}

public void add(T element) {
    // 可选：扩容逻辑，避免数组满了无法插入
    if (size >= elements.length) {
        elements = Arrays.copyOf(elements, elements.length * 2);
    }
    // 先赋值，再自增size，顺序别搞反！
    elements[size] = element;
    size++;
}

2. add方法的size操作顺序错误

如果你的add方法是先size++再赋值，那第一个元素会被存在index=1的位置，而你断言index=0的元素，自然会拿到null，导致断言失败。

修复方式：
一定要先给elements[size]赋值，再执行size++，就像上面代码里写的那样。

3. 断言时错误使用==而非equals

对于字符串、自定义对象这类引用类型，==比较的是对象的内存地址，而不是内容。比如你用new String("test")插入，再用==和常量字符串比较，肯定会失败。

修复方式：
优先用equals方法进行内容比较：

// 正确的断言方式
assert listArray.get(0).equals("yourExpectedValue");

4. 自定义对象未重写equals和hashCode

如果你的T是自定义对象，默认的equals方法会比较内存地址，哪怕两个对象内容完全一样，也会返回false，导致断言失败。

修复方式：
给自定义对象重写equals和hashCode方法，比如：

class User {
    private String name;
    private int age;

    // 构造器、getter、setter

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age && Objects.equals(name, user.name);
    }

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

5. 直接访问底层Object[]数组断言

如果你测试时直接访问类的私有elements数组（比如listArray.elements[0]），拿到的是Object类型，和T类型比较时可能出现类型不兼容或者引用比较的问题，一定要用对外暴露的get方法取元素。

完整可运行的示例实现 #

这里给你一个完整的正确实现，你可以参考：

import java.util.Arrays;
import java.util.Objects;

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

    // 无参构造，默认容量10
    public ListArray() {
        this(10);
    }

    // 指定初始容量的构造器
    public ListArray(int initialCapacity) {
        if (initialCapacity < 0) {
            throw new IllegalArgumentException("初始容量不能为负数: " + initialCapacity);
        }
        elements = new Object[initialCapacity];
        size = 0;
    }

    // 添加元素
    public void add(T element) {
        ensureCapacity();
        elements[size] = element;
        size++;
    }

    // 获取指定索引的元素
    public T get(int index) {
        checkIndexValidity(index);
        return (T) elements[index];
    }

    // 获取当前元素数量
    public int size() {
        return size;
    }

    // 数组扩容逻辑
    private void ensureCapacity() {
        if (size == elements.length) {
            // 扩容为原容量的2倍
            elements = Arrays.copyOf(elements, elements.length * 2);
        }
    }

    // 索引合法性检查
    private void checkIndexValidity(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException(String.format("索引: %d, 当前元素数量: %d", index, size));
        }
    }
}

对应的测试代码：

public class ListArrayTest {
    public static void main(String[] args) {
        // 测试字符串类型
        ListArray<String> stringList = new ListArray<>();
        stringList.add("Hello");
        stringList.add("Stack Overflow");
        assert stringList.get(0).equals("Hello") : "第一个元素应该是Hello";
        assert stringList.size() == 2 : "元素数量应该是2";

        // 测试自定义对象类型
        ListArray<User> userList = new ListArray<>();
        User alice = new User("Alice", 25);
        userList.add(alice);
        User retrievedUser = userList.get(0);
        assert retrievedUser.equals(alice) : "取出的用户应该和原对象匹配";
        assert retrievedUser.getAge() == 25 : "用户年龄应该是25";

        System.out.println("所有测试通过！");
    }

    static class User {
        private String name;
        private int age;

        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            User user = (User) o;
            return age == user.age && Objects.equals(name, user.name);
        }

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

最后总结一下 #

排查这类问题的核心思路是：

• 确保泛型元素的存储和取出都做了正确的类型处理
• 检查数组操作的索引逻辑，避免错位
• 针对引用类型使用正确的比较方式
• 自定义对象务必重写equals方法

内容的提问来源于stack exchange，提问作者Ricardo DM