public class SammlungGanzerZahlen
{
    private int [] zahlen; // Arrayvariable fuer ein Array ganzer Zahlen.

    private int anzahlElemente;//Die Anzahl der im Array gespeicherten Zahlen

    /**
     * Bequemlichkeitskonstruktor fuer Objekte der Klasse SammlungGanzerZahlen
     */
    public SammlungGanzerZahlen()
    {
        zahlen = new int [10];
        anzahlElemente = 0;
        // Erzeugt ein leeres Array ganzer Zahlen. Groesse nach Ermessen des Programmierers festgelegt.

    }

    /**
     * Konstruktor f�r Objekte der Klasse SammlungGanzerZahlen der angegebenen Kapazitaet (= maximale
     * Zahl speicherbarer Zahlen).
     */
    public SammlungGanzerZahlen (int kapazitaet)
    {
        zahlen = new int [kapazitaet];
        anzahlElemente = 0;
        // Erzeugt ein leeres Array ganzer Zahlen. Groesse entspreched des Parameters kapaziaet.

    }

    /**
     * Gibt die Anzahl der gespeicherten Zahlen zurueck.
     * @return Die Anzahl der aktuell gespeicherten Zahlen.
     */
    public int gibAnzahl()
    {
        return anzahlElemente; //Gibt die Anzahl der gespeicherten Daten wieder
    }

    /**
     * Gibt alle gespeicherten Zahlen im Konsolenfenster aus. Zahlen werden in einer Liste ausgegeben,
     * einzelne Zahlen durch Komma und Leerzeichen getrennt. Sofern mehr als 10 Zahlen im Speicher sind,
     * beginnt nach jeweils 10 Zahlen eine neue Zeile.
     */
    public void zeigeZahlen()
    {
        int index = 0; //Index als 0 initialisieren
        int ausgabe = 0; //Ausgabe als 0 initialisieren
        while(index < zahlen.length) //Wird solange durchlaufen bis der Index kleiner als die größe des Arrays ist
        {
            while(ausgabe < 10 && index < zahlen.length) // Wird solange durchlaufen wie die Ausgabe kleiner als 10 ist, damit nach 10 Zeichen ein Zeilenumbruch entshet
            {
                System.out.print(zahlen[index] + ", "); //Gibt die Zahl aus die an Stelle des Index gespeicher ist
                ausgabe++; //Setzt die Ausgabe um eines nach oben
                index++; // Erhöht den Index um eins.
            }
            System.out.println(); // Zeilenumbruch
            ausgabe = 0; // Damit wieder 10 Zeichen in einer Zeile ausgegeben werden wird dieser Wert wieder auf 0 gesetzt
        }
    }

    /**
     * Fuegt eine Zahl hinzu. Zahl wird hinter den bereits gespeicherten Zahlen abgelegt.
     * Falls der Vorgang nicht moeglich ist, wird eine Fehlermeldung ausgegeben.
     * @param neueZahl Die Zahl, die hinzugefuegt wird.
     * @return gibt true zurueck, falls Hinzufuegen erfolgtreich, false sonst.
     */
    public boolean hinzufuegen (int neueZahl)
    {
        if(anzahlElemente >= zahlen.length)
        {
            return false; //Gibt False zurück wenn die Anzahl der Elemente größer,gleich der Größe des Arrays ist
        }
        else
        {
            zahlen[anzahlElemente] = neueZahl; // Die Anzahl der Elemente gibt die Zahl ab 1 wieder, daher wird im nächsten freien Wert die neue Zahl gespeichert
            anzahlElemente++; // Anzahl der Elemente um eines erhöhen
            return true; // True ausgeben wenn es funktioniert hat
        }
    }

    /**
     * Gibt die Zahl des angegebenen Indexes zurueck.
     * @param index Der Index der gewuenschten Zahl.
     * @return Die Zahl zum Index index. Falls eine Fehler auftritt wird eine Fehlermeldung
     *         ausgegeben und die Zahl 9999 zurueckgegeben.
     */
    public int gibZahl(int index)
    {
        if(index >= zahlen.length || index < 0 || index >= anzahlElemente)
        {
            return 9999; //Gibt 9999 zurück wenn die gesuchte Zahl kleiner als der Index ist, größer als die maximale Größe des Arrays oder größer als die Anzahl der gespeicherten Werte ist
        }
        else
        {
            return zahlen[index]; //Gibt die Zahl am Wert des Index zurück
        }

    }

    /**
     * Loescht die Zahl des angegebenen Indexes. Alle nachfolgenden Zahlen werden nach vorne
     * verschoben, so dass die entstehende Luecke geschlossen wird.
     * @param index Der Index der zu loeschenden Zahl.
     * @return Gibt die geloschte Zahl zurueck. Falls eine Fehler auftritt wird eine Fehlermeldung
     *         ausgegeben und die Zahl 9999 zurueckgegeben.
     */
    public int loescheZahl(int index)
    {
        if(index >= zahlen.length - 1 || index < 0)
        {
            return 9999; // Gibt 9999 zurück wenn an der Stelle kein zu löschender Wert enthalten ist
        }
        else
        {
            int zahl = zahlen[index]; //Speichert die Zahl die gelöscht wird zwischen um sie später zurück zu geben
            for(int i = index + 1; i < anzahlElemente;i++) // Der Index muss um 1 erhöht sein, da er bei 0 anfängt zu speichern, dieser Wert darf nicht größer sein als die Anzahl der Elemente
            {
                zahlen[i-1] = zahlen[i]; // Löscht die Zahl und füllt ggf. entstandene Lücke auf
            }
            anzahlElemente--; //Anzahl der Elemente um 1 verringern
            for(int i = anzahlElemente; i < zahlen.length; i++) //
            {
                zahlen[i] = 0; //Setz Wert an dieser Stelle 0
            }
            return zahl; //Gibt die Zahl die gelöscht wurde aus
        }
    }

    /**
     * Fuegt neue Zahl an der Stelle mit dem angegebenen Index ein. Alle nachfolgenden Zahlen werden
     * gegebenenfalls nach hinten verschoben. Falls eine Luecke entstehen wuerde, wir die Zahl direkt
     * hinter den bereits gespeicherten Zahlern abgelegt. Falls der Index negativ ist, wird die Zahl
     * an den Anfang gestellt.
     * @param neueZahl Die Zahl, die eingefuegt werden soll.
     * @param index Der Index der gewuenschten Stelle.
     * @return Gibt true zurueck, falls der Vorgang erfolgreich war. Falls eine Fehler auftritt wird
     *         eine Fehlermeldung ausgegeben und false zurueckgegeben.
     */
    public boolean fuegeZahlEin(int neueZahl, int index)
    {
        if(index >= zahlen.length && anzahlElemente == zahlen.length)
        {
            System.out.println("error");
            return false;
        }

        if(index > zahlen.length)
        {
            hinzufuegen(neueZahl);
            return true;
        }

        if(index > anzahlElemente)
        {
            hinzufuegen(neueZahl);
            return true;
        }

        if(index <= 0)
        {
            for(int i = anzahlElemente - 1; i >= 0; i--)
            {
                zahlen[i + 1] = zahlen[i];
            }
            zahlen[0] = neueZahl;
            anzahlElemente++;
            return true;
        }

        for(int i = anzahlElemente - 1; i >= index; i--)
        {
            zahlen[i + 1] = zahlen[i];
        }
        zahlen[index] = neueZahl;
        anzahlElemente++;
        return true;
    }

    /**
     * Findet groesste Zahl und gibt diese zurueck.
     * &return groesste Zahl im Array. Gibt 9999 zur�ck, falls es keine groesste Zahl gibt.
     */
    public int gibGroesste()
    {
        if(zahlen.length == 0)
        {
            return 9999;
        }
        else
        {
            int groessteZahl = Integer.MIN_VALUE;
            for(int i = 0; i < anzahlElemente; i++)
            {
                if(zahlen[i] > groessteZahl)
                {
                    groessteZahl = zahlen[i];
                }
            }
            return groessteZahl;
        }
    }

    /**
     * Findet kleinste Zahl und gibt diese zurueck.
     * &return kleinste Zahl im Array. Gibt 9999 zurueck, falls es keine kleinste Zahl gibt.
     */
    public int gibKleinste()
    {
        if(zahlen.length == 0)
        {
            return 9999;
        }
        else
        {
            int kleinsteZahl = Integer.MAX_VALUE;
            for(int i = 0; i < anzahlElemente; i++)
            {
                if(zahlen[i] < kleinsteZahl)
                {
                    kleinsteZahl = zahlen[i];
                }
            }
            return kleinsteZahl;
        }
    }

    /**
     * Kehrt Reihenfolge der Zahlen im Array um. Tauscht die erste Zahl mit der letzten,
     * die zweite mit der vorletzten, usw.
     */
    public void kehreReihenfolgeUm()
    {
        int[] tmp = new int[anzahlElemente];
        int tmp_index = tmp.length - 1;
        for(int i = 0; i < anzahlElemente; i++) {
            tmp[tmp_index] = zahlen[i];
            tmp_index--;
        }
        for(int i = 0; i < anzahlElemente; i++) {
            zahlen[i] = tmp[i];
        }
    }

}