实现一个类似ArrayList的数据结构

```java
import java.util.Arrays;
import java.util.Iterator;
import java.util.NoSuchElementException;
 
public class MyArrayList<E> implements Iterable<E> {
    private static final int DEFAULT_CAPACITY = 10;
    private Object[] elements;
    private int size;
 
    public MyArrayList() {
        elements = new Object[DEFAULT_CAPACITY];
        size = 0;
    }
 
    public MyArrayList(int initialCapacity) {
        if (initialCapacity < 0) {
            throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
        }
        elements = new Object[initialCapacity];
        size = 0;
    }
 
    public int size() {
        return size;
    }
 
    public boolean isEmpty() {
        return size == 0;
    }
 
    public void add(E e) {
        if (size == elements.length) {
            ensureCapacity(size + 1);
        }
        elements[size++] = e;
    }
 
    @SuppressWarnings("unchecked")
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        return (E) elements[index];
    }
 
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        @SuppressWarnings("unchecked")
        E oldValue = (E) elements[index];
        int numMoved = size - index - 1;
        if (numMoved > 0) {
            System.arraycopy(elements, index + 1, elements, index, numMoved);
        }
        elements[--size] = null; // Let gc do its work
        return oldValue;
    }
 
    private void ensureCapacity(int minCapacity) {
        int oldCapacity = elements.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1); // grow by 50%
        if (newCapacity < minCapacity) {
            newCapacity = minCapacity;
        }
        elements = Arrays.copyOf(elements, newCapacity);
    }
 
    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            private int cursor = 0;
 
            @Override
            public boolean hasNext() {
                return cursor != size;
            }
 
            @SuppressWarnings("unchecked")
            @Override
            public E next() {
                int i = cursor;
                if (i >= size) {
                    throw new NoSuchElementException();
                }
                cursor = i + 1;
                return (E) elements[i];
            }
        };
    }
 
    public static void main(String[] args) {
        MyArrayList<String> list = new MyArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");
 
        System.out.println("Elements in the list:");
        for (String fruit : list) {
            System.out.println(fruit);
        }
 
        System.out.println("Removing element at index 1: " + list.remove(1));
        System.out.println("Size of list after removal: " + list.size());
 
        System.out.println("Elements in the list after removal:");
        for (String fruit : list) {
            System.out.println(fruit);
        }
    }
}
```