Java自定义一个变长数组的思路与代码

首先我们来讲一下如何自定义一个变长数组。

思路

实现一个变长数组需要将数据存储在连续的内存空间中，并能够对数组的大小进行动态调整。具体实现中，我们需要考虑以下几点：

1. 数组的存储：数组需要存储在内存空间中，可以使用Java中的数组或对象来存储。
2. 数组的大小：数组大小的动态调整可以通过重新分配内存空间实现。
3. 数组的操作：支持向数组中插入、删除、修改元素，以及获取指定位置的元素。

基于以上的思路，我们可以实现一个基本的变长数组。

代码

以下是一个示例代码，用于实现简单的变长数组，我们可以根据自己的需求来进行改进和优化。

public class DynamicArray<T> {
    private T[] array;
    private int size;
    private int capacity;

    public DynamicArray(int capacity) {
        this.array = (T[]) new Object[capacity];
        this.size = 0;
        this.capacity = capacity;
    }

    public DynamicArray() {
        this(10);
    }

    public int size() {
        return this.size;
    }

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

    public T get(int index) {
        if(index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index out of bound.");
        }
        return array[index];
    }

    public void set(int index, T value) {
        if(index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index out of bound.");
        }
        array[index] = value;
    }

    public void add(T value) {
        if(size == capacity) {
            resizeArray(capacity * 2);
        }
        array[size] = value;
        size++;
    }

    public void delete(int index) {
        if(index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index out of bound.");
        }
        for(int i = index; i < size - 1; i++) {
            array[i] = array[i + 1];
        }
        size--;
        if(size <= capacity / 4) {
            resizeArray(capacity / 2);
        }
    }

    private void resizeArray(int newCapacity) {
        T[] newArray = (T[]) new Object[newCapacity];
        for(int i = 0; i < size; i++) {
            newArray[i] = array[i];
        }
        array = newArray;
        capacity = newCapacity;
    }

    public static void main(String[] args) {
        DynamicArray<Integer> array = new DynamicArray<>();
        array.add(1);
        array.add(2);
        array.add(3);
        array.add(4);
        array.add(5);
        System.out.println(array.get(3));   // 输出4
        array.set(0, 0);
        System.out.println(array.get(0));   // 输出0
        array.delete(2);
        System.out.println(array.size());   // 输出4
    }
}

上述代码中，我们定义了一个DynamicArray类，其中array数组用于存储元素，size表示当前数组大小，capacity表示数组容量。类中包含了一些基本的操作，如获取数组大小、判断是否为空、获取和设置指定位置的元素、向数组中添加元素、删除指定位置的元素。在数组大小达到容量时，会自动调整数组的容量。

示例说明

假设我们需要实现一个学生管理系统，其中需要存储所有学生的学号、姓名、年龄、性别等信息。我们可以使用自定义的变长数组来存储这些信息，代码如下：

public class Student {
    private int id;
    private String name;
    private int age;
    private String gender;

    public Student(int id, String name, int age, String gender) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    // getter and setter methods ...

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                '}';
    }
}

public class StudentManager {
    private DynamicArray<Student> students;

    public StudentManager() {
        students = new DynamicArray<>();
    }

    public void addStudent(Student student) {
        students.add(student);
    }

    public void deleteStudent(int index) {
        students.delete(index);
    }

    public Student getStudent(int index) {
        return students.get(index);
    }

    public void setStudent(int index, Student student) {
        students.set(index, student);
    }

    public void printAllStudents() {
        for(int i = 0; i < students.size(); i++) {
            System.out.println(students.get(i));
        }
    }

    public static void main(String[] args) {
        StudentManager manager = new StudentManager();
        manager.addStudent(new Student(1, "Tom", 18, "male"));
        manager.addStudent(new Student(2, "Lucy", 17, "female"));
        manager.addStudent(new Student(3, "Jack", 19, "male"));
        manager.addStudent(new Student(4, "Lily", 20, "female"));
        manager.printAllStudents();
    }
}

在上述示例中，我们通过定义一个Student类来存储每个学生的信息，然后使用自定义的变长数组DynamicArray来存储所有学生的信息。StudentManager类则封装了对学生信息的添加、获取、删除和修改等操作，并提供了一个printAllStudents()方法来输出所有学生的信息。

除此之外，我们也可以将上面的示例代码中的泛型<T>改为具体的类型，比如<Student>来实现一个专门存储学生信息的变长数组。