如何在自定义ArrayList中实现subList()

在自定义ArrayList中实现subList()方法，可以按照以下步骤进行：

创建一个自定义的ArrayList类，该类需要实现List接口，并继承AbstractList抽象类。
在自定义ArrayList类中添加一个私有内部类SubList，用于表示子列表。
在自定义ArrayList类中添加一个subList()方法，该方法接受起始索引和结束索引作为参数，并返回一个SubList对象。
在SubList类中实现List接口的所有方法，包括add()、remove()、get()、set()等方法。这些方法的实现需要基于原始ArrayList的数据进行操作。
在SubList类中重写size()方法，返回子列表的大小。
在SubList类中重写subList()方法，返回一个新的SubList对象，表示原始子列表的子列表。
在自定义ArrayList类中重写subList()方法，返回一个新的SubList对象，表示原始列表的子列表。

下面是一个示例代码：

import java.util.AbstractList;
import java.util.List;

public class CustomArrayList<E> extends AbstractList<E> {
    private Object[] elements;
    private int size;

    public CustomArrayList() {
        elements = new Object[10];
        size = 0;
    }

    @Override
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
        return (E) elements[index];
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public E set(int index, E element) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
        E oldValue = (E) elements[index];
        elements[index] = element;
        return oldValue;
    }

    @Override
    public void add(int index, E element) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException();
        }
        if (size == elements.length) {
            resize();
        }
        System.arraycopy(elements, index, elements, index + 1, size - index);
        elements[index] = element;
        size++;
    }

    @Override
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
        E oldValue = (E) elements[index];
        int numMoved = size - index - 1;
        if (numMoved > 0) {
            System.arraycopy(elements, index + 1, elements, index, numMoved);
        }
        elements[--size] = null;
        return oldValue;
    }

    private void resize() {
        Object[] newElements = new Object[elements.length * 2];
        System.arraycopy(elements, 0, newElements, 0, size);
        elements = newElements;
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        if (fromIndex < 0 || toIndex > size || fromIndex > toIndex) {
            throw new IndexOutOfBoundsException();
        }
        return new SubList(fromIndex, toIndex);
    }

    private class SubList extends AbstractList<E> {
        private final int offset;
        private final int size;

        SubList(int fromIndex, int toIndex) {
            offset = fromIndex;
            size = toIndex - fromIndex;
        }

        @Override
        public E get(int index) {
            if (index < 0 || index >= size) {
                throw new IndexOutOfBoundsException();
            }
            return (E) elements[offset + index];
        }

        @Override
        public int size() {
            return size;
        }

        @Override
        public E set(int index, E element) {
            if (index < 0 || index >= size) {
                throw new IndexOutOfBoundsException();
            }
            E oldValue = (E) elements[offset + index];
            elements[offset + index] = element;
            return oldValue;
        }

        @Override
        public void add(int index, E element) {
            if (index < 0 || index > size) {
                throw new IndexOutOfBoundsException();
            }
            if (CustomArrayList.this.size == elements.length) {
                resize();
            }
            System.arraycopy(elements, offset + index, elements, offset + index + 1, size - index);
            elements[offset + index] = element;
            CustomArrayList.this.size++;
            size++;
        }

        @Override
        public E remove(int index) {
            if (index < 0 || index >= size) {
                throw new IndexOutOfBoundsException();
            }
            E oldValue = (E) elements[offset + index];
            int numMoved = size - index - 1;
            if (numMoved > 0) {
                System.arraycopy(elements, offset + index + 1, elements, offset + index, numMoved);
            }
            elements[offset + --CustomArrayList.this.size] = null;
            size--;
            return oldValue;
        }

        private void resize() {
            Object[] newElements = new Object[elements.length * 2];
            System.arraycopy(elements, 0, newElements, 0, CustomArrayList.this.size);
            elements = newElements;
        }

        @Override
        public List<E> subList(int fromIndex, int toIndex) {
            if (fromIndex < 0 || toIndex > size || fromIndex > toIndex) {
                throw new IndexOutOfBoundsException();
            }
            return new SubList(offset + fromIndex, offset + toIndex);
        }
    }
}

这样，你就可以在自定义ArrayList中使用subList()方法来获取子列表了。