Очень нужен совет!

import java.util.Iterator;
public class Listeseq<E> implements Iterable<E>{
 
    
    private int elementzahl;
        
    private E[] element;
    
    private int max;
    
public Listeseq() {
        this(16);
        
        }
 
    
    @SuppressWarnings("unchecked")
    public Listeseq(int max) {  
        this.max = max;
        this.elementzahl = 0;
        this.element = (E[]) new Object[max+1];
 
public int gibLaenge() {
        return elementzahl;
    }
    
public void fuegeEin(E x, int p) //metod vstavki v spisok
        if (p<1 || p>elementzahl+1) throw new IndexOutOfBoundsException;
        
        
        if (p <= elementzahl){ 
            for (int pos=elementzahl; pos>=p; pos--){//ot bolshego k menshemu - DECREMENT
                element[pos+1] = element[pos];
            }
        }
        element[p] = x;
        elementzahl++;
        
        if(elementzahl==max){
        max=max*2;
         
            element[elementzahl++] = x;
        }
    }
 
public void ersetze(E x, int p){//metod zameni objektov
        if(p<1 || p>elementzahl) throw new IndexOutOfBoundsException;
        
                element[p] = x;
                }
 
public void haengeAn(E x){//metod dobavleniya objekta v konec spiska
                
        if(elementzahl==max){ 
 
        max=max*2;} // ili aendereGroesse(max*2); ???
 
        element[elementzahl+1]=x;
        
            elementzahl++;
            }
        
protected void aendereGroesse( int neueGroesse){//i metod zameni razmernosti u massiva kotoriy u menya ne poluchilsya
          
        
        //esli novaya velichina budet menshe staroi->elementi poteryani
        if(neueGroesse < elementzahl)throw new IllegalArgumentException("Ungueltige Position");
            
        
        Listeseq<E> listeNeu = new Listeseq<E>(neueGroesse);
        
        for(int i=1 ; i<=elementzahl; i++){
            listeNeu.fuegeEin(element[i], i);//pochemu eto ne rabotaet???
            
        }
        
    }
 
}

public static void main(String [] args){
 
    Listeseq<Integer> Spisok = new Listeseq<Integer>();
    
    Spisok.fuegeEin(4, 1);
    Spisok.fuegeEin(1231,2);
    Spisok.fuegeEin(8, 3);
    Spisok.fuegeEin(5, 4);
    Spisok.fuegeEin(7, 5);
    Spisok.fuegeEin(33,6);
    Spisok.fuegeEin(12,7);
    Spisok.fuegeEin(5552, 8);
    
 
 
    Spisok.aendereGroesse(30);
    
 
    for(int i=1; i<=8 ; i++){//esli predel sdelat do 9, to Exception
        Spisok.haengeAn(i);
    }
    for(Integer num : Spisok){
        System.out.println(num);
    }
    System.out.println("Dlina: "+Spisok.gibLaenge());
    
    
 
}
}

package helfer;
 
import java.util.Iterator;
 
/** Eine sequentielle Liste mit Elementen vom Typ E */
public class Listeseq<E> implements Iterable<E>{
    /** Die Anzahl Schluessel in der Liste */
    private int elementzahl;
    
    /** Die Schluessel der Liste, als Array */
    private E[] element;
    
    /** Die (aktuell) maximale Laenge der Liste. Wir nennen diese Zahl auch
     * die Kapazitaet der Liste.*/ 
    private int max;
    
    /**
     * Erlaubt es, mit einer For-Each-Schleife ueber die Schluessel in der 
     * Liste zu iterieren. 
     */
    public class ListenIterator implements Iterator<E> {
        /**
         * Erzeugt einen neuen Iterator.
         * @param liste Die Liste, ueber die Iteriert werden soll
         * @param zeiger Die Startposition in der Liste
         */
        public ListenIterator(Listeseq<E> liste, int zeiger){
            this.liste = liste;
            this.zeiger = zeiger;
        }
        
        /** 
         * Liefert <code>true</code> zurueck, wenn der Iterator noch 
         * ein Element weiter gesetzt werden kann und <code>false</code>
         * sonst.
         */
        @Override
        public boolean hasNext() {
            return zeiger < liste.elementzahl;
        }
 
        /** 
         * Setzt den Iterator ein Element weiter und liefert das
         * so erreichte Element zurueck.
         */
        @Override
        public E next() {
            zeiger++;
            return liste.zugriff(zeiger);
        }
 
        /** 
         * Entfernt das Element, auf das der Iterator aktuell zeigt,
         * aus der Liste. Setzt den Iterator anschließend eine Position
         * zurueck, damit kein Element uebersprungen wird.
         */
        @Override
        public void remove() {
            liste.entferne(zeiger);         
            zeiger--;
        }
        
        /** Die Liste, auf der der Iterator operiert */
        private Listeseq<E> liste;
        
        /** Die aktuelle Position des Iterators */
        private int zeiger;
    }
    
    /** Erzeugt eine leere Liste. Die Standardkapazitaet der Liste 
     * betraegt 16.
     *
     * <p>Die Liste verdoppelt ihre Kapazitaet automatisch, sobald 
     * kein Platz fuer neue Element mehr vorhanden ist. Wird weniger als
     * ein Drittel der Kapazitaet benutzt, halbiert die Liste ihre
     * Kapazitaet automatisch.</p> */
    public Listeseq() {
        this(16);
    }
    
    /** <p>Erzeugt eine leere Liste mit Kapazitaet <code>max</code>.</p>
     *
     * <p>Die Liste verdoppelt ihre Kapazitaet automatisch, sobald 
     * kein Platz fuer neue Element mehr vorhanden ist. Wird weniger als
     * ein Drittel der Kapazitaet benutzt, halbiert die Liste ihre
     * Kapazitaet automatisch.</p> */
    @SuppressWarnings("unchecked")
    public Listeseq(int max) {
        this.max = max;
        this.elementzahl = 0;
        this.element = (E[]) new Object[max+1];
    }
    
    
    /** Gibt die Anzahl der Listenelemente zurueck */
    public int gibLaenge() {
        return elementzahl;
    }
    
    /** Sucht nach dem Element <code>x</code> und gibt dessen Position in der 
     * Liste zurueck. Gibt <code>0</code> zurueck, falls das Element nicht 
     * vorhanden ist.
     */
    public int suche(E x) {
        element[0] = x;
        int pos = elementzahl;
        while (!element[pos].equals(x)) pos--;
        return pos;
    }
    
    /** Entfernt das Element an Position <code>p</code> aus der Liste und 
     * verschiebt alle Nachfolger von <code>p</code>um eine Position nach links.*/
    public void entferne(int p) {
        if (p<1 || p>elementzahl) throw new IndexOutOfBoundsException("Ungueltige Position");
        elementzahl--;
        if (p <= elementzahl)
            for (int pos=p; pos<=elementzahl; pos++)
                element[pos] = element[pos+1];
        element[elementzahl+1] = null;
    }
    
    /** Fuegt <code>x</code> an Position <code>p</code> ein und verschiebt die 
     * Elemente an den Positionen <code>p,p+1,...</code> um eine Position nach 
     * rechts. Verdoppelt die Kapazitaet der Liste, wenn die Kapazitaet nicht 
     * ausreicht, um x aufzunehmen.*/
    public void fuegeEin(E x, int p) {
        if (p<1 || p>elementzahl+1) throw new IndexOutOfBoundsException("Ungueltige Position");
        
        // Falls p nicht am Ende der Liste ist, muessen die Elemente verschoben
        // werden
        if (p <= elementzahl){ 
            for (int pos=elementzahl; pos>=p; pos--){
                element[pos+1] = element[pos];
            }
        }
        element[p] = x;
        elementzahl++;
    }
    
    /** Gibt das Element an Position <code>p</code> aus */
    public E zugriff(int p) {
        if (p>elementzahl) throw new IndexOutOfBoundsException("Ungueltige Position");
        return element[p];
    }
    
    /** Haengt die Liste <code>liste</code> an diese Liste an */
    public void verkette(Listeseq<E> liste) {
        if (liste.gibLaenge() > 0){
            int neueLaenge = elementzahl + liste.gibLaenge();
            if(neueLaenge >= max){
                aendereGroesse(2*neueLaenge);
            }
            
            for (int pos=1; pos<=liste.gibLaenge(); pos++){
                element[elementzahl+pos] = liste.zugriff(pos);
            }
        }
        elementzahl += liste.gibLaenge();
    }
    
    /** Ersetzt das Element an Position <code>p</code> durch <code>x</code> */
    public void ersetze(E x, int p){
        if(p > elementzahl) throw new IndexOutOfBoundsException("Ungueltige Position");
 
        // Hier Code fuer Aufgabe 24 a) eintragen.      
    }
    
    /** Haengt ein Element an das Ende der Liste an */
    public void haengeAn(E x){
        // Hier Code fuer Aufgabe 24 a) eintragen.
    }
    
    /** <p>Aendert die Kapazitaet der Liste.</p>
     * 
     * <p>Dazu wird ein neues Array mit der gewuenschten Groesse fuer die 
     * vorhandenen Elemente angelegt und der Inhalt des bisherigen Arrays in das
     * neue Array kopiert. Die Kapazitaet kann vergroessert oder verkleinert 
     * werden.</p>
     * 
     * <p>Die Methode wirft eine <code>IndexOutOfBoundsException</code>, wenn
     * die gewuenschte Kapazitaet nicht ausreicht, um alle Listenelemente zu 
     * speichern.</p>
     *  
     * @param neueGroesse
     */
    @SuppressWarnings("unchecked")
    protected void aendereGroesse(int neueGroesse){
        // Hier Code fuer Aufgabe 24 b) eintragen.
    }
    
    /** Liefert eine String-Repräsentation der Liste */
    @Override 
    public String toString() {
        String ret;
        ret = "Liste:\n";
        for (int i=1; i<=elementzahl; i++){
            ret = ret + " -> " + element[i].toString();
        }
                                                 
        return ret;
    }
 
    /** Erlaubt das Iterieren ueber die Listenelemente */ 
    @Override
    public Iterator<E> iterator() {
        return new ListenIterator(this, 0);
    }
}