Java实现一个顺序表的完整代码

要实现一个顺序表，首先需要定义一个数据结构，用于存储数据，并提供相应的操作方法。以下是一个Java实现顺序表的完整代码的攻略。

定义数据结构

定义一个类ArrayList作为顺序表的数据结构。这个类具有以下属性和方法：

1. size：表示顺序表的元素个数。
2. capacity：表示顺序表的最大容量。
3. elements：表示顺序表的存储空间，即一个数组。
4. ArrayList(int capacity)：构造方法，初始化一个空顺序表，容量为capacity。
5. add(E element)：将元素element添加到顺序表的最后。
6. add(int index, E element)：将元素element添加到指定位置index。
7. remove(int index)：删除指定位置index的元素。
8. get(int index)：获取指定位置index的元素。
9. set(int index, E element)：将指定位置index的元素修改为element。
10. indexOf(E element)：查找元素element在顺序表中的位置，如果不存在返回-1。
11. isEmpty()：判断顺序表是否为空。
12. isFull()：判断顺序表是否已满。

完整代码实现

以下是具体的代码实现：

public class ArrayList<E> {
    private int size;
    private int capacity;
    private Object[] elements;

    public ArrayList(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        this.elements = new Object[capacity];
    }

    public void add(E element) {
        ensureCapacity(size + 1);
        elements[size++] = element;
    }

    public void add(int index, E element) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        ensureCapacity(size + 1);
        System.arraycopy(elements, index, elements, index + 1, size - index);
        elements[index] = element;
        size++;
    }

    public void remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        System.arraycopy(elements, index + 1, elements, index, size - index - 1);
        elements[--size] = null;
    }

    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        return (E) elements[index];
    }

    public void set(int index, E element) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        elements[index] = element;
    }

    public int indexOf(E element) {
        for (int i = 0; i < size; i++) {
            if (elements[i].equals(element)) {
                return i;
            }
        }
        return -1;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public boolean isFull() {
        return size == capacity;
    }

    private void ensureCapacity(int minCapacity) {
        if (minCapacity > capacity) {
            capacity *= 2;
            Object[] newElements = new Object[capacity];
            System.arraycopy(elements, 0, newElements, 0, size);
            elements = newElements;
        }
    }
}

示例说明

以下是两个示例，演示如何使用上面实现的顺序表：

示例一

ArrayList<Integer> list = new ArrayList<>(10);
System.out.println(list.isEmpty()); // 打印结果为true

list.add(1);
list.add(2);
list.add(3);

System.out.println(list); // 打印结果为[1, 2, 3]
System.out.println(list.get(1)); // 打印结果为2

list.set(1, 4);
System.out.println(list); // 打印结果为[1, 4, 3]

list.remove(1);
System.out.println(list); // 打印结果为[1, 3]

System.out.println(list.indexOf(3)); // 打印结果为1

这个示例创建了一个初始容量为10的顺序表，并加入3个元素。随后演示了一些基本操作，包括获取一个元素、修改一个元素、删除一个元素、查找一个元素在列表中的位置。

示例二

以下是另一个示例，展示如何添加自定义类型到顺序表中：

class Person {
    private int id;
    private String name;

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}

ArrayList<Person> persons = new ArrayList<>(10);
persons.add(new Person(1, "Tom"));
persons.add(new Person(2, "Jerry"));
persons.add(1, new Person(3, "Spike"));

System.out.println(persons.get(1).getName()); // 打印结果为Spike

这个示例演示了如何自定义类型加入顺序表中，并在第二个元素后插入一个新的自定义类型。查询返回的是第二个元素，也就是刚刚插入的新元素，这印证了插入操作的正确性。