Construire un vecteur Java à partir de Zéro [fermé]

Longue histoire courte, je suis dans une classe de Comp Sci universitaire, et le professeur veut que nous construisions un vecteur mais à partir de zéro. Sont leurs bons tutoriels sur le Web pour quelque chose comme ça? J'ai fait une recherche Google mais rien n'est vraiment apparu.

MODIFIER

Selon le document que l'enseignant a donné le vecteur doit être capable de faire ce qui suit:

• append (Object element – - ajout de l'élément à la fin du vecteur
• clear (–- faire le vecteur collection vide
• contains (Object element – - vérifie si le vecteur contient l'élément
• elementAt (int index) - accédez à l'élément à l'index donné
• indexOf (Object element) - recherche l'index de l'élément
• insertAt (int index, Object element) – insère l'élément à l'index donné
• isEmpty (–- vérifie si le vecteur est vide
• removeAt (int index) - supprime l'élément à l'index donné
• remove (Object element) - supprime le élément du vecteur
• remplacer(int index, Object element) – remplacer l'élément à l'indice de l'élément donné
• size() – retourne le nombre d'éléments dans le vecteur
• ensureCapacity (int minCapacity) – assurez-vous que le vecteur obtient au moins la capacité donnée
• clone() – renvoie une copie clonée de ce vecteur
• removeRange (int fromIndex, int toIndex) - supprime de ce vecteur tous les éléments dont l'index est compris entre fromIndex, inclus et toIndex, exclusif
• toString() – renvoie une représentation de chaîne de ce vecteur, contenant la représentation de chaîne de chaque élément
• reverse (–- inverse les éléments de ce vecteur
• merge (MyVector vector2) – ajoute tous les éléments de vector2 à la fin de ce vecteur

De plus, la classe doit implémenter Cloneable et être auto-expansive.

C'est Ce que j'ai jusqu'à présent:

package collection;

public class MyVector implements Cloneable {

    protected Object[] items;
    protected int arraySize;
    protected int maxCap;

    public MyVector (int initialCapacity) {
        super();
        if (initialCapacity < 0) {
            throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
        }
        this.items = new Object[initialCapacity];
        this.arraySize = 0;
        this.maxCap = initialCapacity;
    }

    public MyVector() {
        this(10);
    }

    public void append(Object element) {
        int newArraySize = this.arraySize + 1;
        if(this.maxCap == newArraySize) {
            this.items = this.increaseCap(newArraySize);
            this.items[this.arraySize] = element;
            this.arraySize += 1;
            //System.out.println(this.items[this.arraySize);
        } else {
            this.items[this.arraySize] = element;
            this.arraySize +=1;
        }
    }
    @Override
    public String toString() {
        String output = "[";
        //output = this.items[0].toString();
        for(int i = 0; i < this.arraySize; i++) {
            output += this.items[i] + ", ";
        }
        output += "]";
        return output;
    }
    public void clear() {
        for(int i = 0; i < this.arraySize; i++) {
            this.items[i] = null;
            this.arraySize = 0;
        }
    }
    public boolean contains(Object element) {
        boolean doesContain = false;
        for(int i = 0; i < this.arraySize; i++) {
            if(element == this.items[i]) {
                doesContain = true;
                i = this.arraySize;
            }
        }
        return doesContain;
    }
    public Object elementAt(int index) {
        if(this.arraySize >= index) {
            return this.items[index];
        } else {
            Object temp = null;
            System.out.println("No index of " + index);
            return temp; 
        }
    }
    public Object indexOf(Object element) {
        Object index = "No value found";
        for(int i = 0; i < this.arraySize; i++) {
            if(element == this.items[i]) {
                index = i;
                break;        
            } 
        }
        return index;
    }
    public boolean isEmpty() {
        if(this.arraySize == 0) {
            return true;
        }
        return false;
    }
    public void replace(int index, Object element) {
        if(this.arraySize > index) {
            this.items[index] = element;
        } else {
            System.out.println("No element at " + index);
        }
    }
    public int size() {
        return this.arraySize;
    }
    public void reverse() {
        Object[] temp = new Object[this.items.length];
        int j = this.arraySize;
        for(int i = 0; i < this.arraySize; i++) {
            temp[j] = this.items[i];
            j--;
        }
        this.items = temp;
    }
    public void ensureCapacity(int minCapacity) {
        if(minCapacity > this.items.length) {
            this.items = this.increaseCap(minCapacity);
        }
    }
    public Object[] increaseCap(int minCap) {
        Object[] arr1 = new Object[minCap * 2];
        for(int i = 0; i < minCap; i++) {
            arr1[i] = this.items[i];
        }
        this.maxCap = this.maxCap * 2;
        return arr1;
    }
    @Override
    public Object clone() {
        return this.items;
    }
    public boolean checkIndex(int index) {
        boolean check = false;
        if(index < this.arraySize) {
            check = true;
        }
        return check;
    }
    public void removeAt(int index) {
        if(true == this.checkIndex(index)) {
            Object[] temp = new Object[this.arraySize - 1];
            for(int j = 0; j < index; j++) {
                temp[j] = this.items[j];
            }
            for(int j = index + 1; j < this.arraySize; j++) {
                temp[j-1] = this.items[j];
            }
            this.items = temp;
            this.arraySize = this.arraySize - 1;
        }
    }
    public void insertAt(int index, Object element) {
        if (this.checkIndex(index) == true) {
            Object[] temp = new Object[this.arraySize];
            for(int i = index; i < this.arraySize; i++) {
                temp[i+1] = this.items[i];
            }
            this.items[index] = element;
            for (int i = index + 1; i < this.arraySize; i++) {
                this.items[i] = temp[i - 1];
            }
            this.arraySize = this.arraySize - 1;
        }
    }
    public void remove(Object element) {
        for(int i = 0; i < this.items.length; i++) {
            if(this.items[i] == element) {
                this.removeAt(i);
            }
        }
    }
    public void removeRange(int fromIndex, int toIndex) {
        for(int i = fromIndex; i < toIndex; i++) {
            this.removeAt(i);
        }
    }
    public void merge(MyVector vector2) {
        this.ensureCapacity(vector2.size() + this.arraySize);
        for(int i = 0; i < vector2.size(); i++) {
            this.append(vector2);
        }
    }
}