# Grafische Darstellung eines Stacks in einer JTextArea



## Silas770 (28. Sep 2015)

Hi,
wir sollen in der Schule mithilfe von Stacks einen bzw. mehrere Bücherstapel realisieren. Die Stack-Klasse wurde uns vorgegeben und darf nicht verändert werden. Das Ganze soll über eine GUI laufen und der Bücherstapel soll grafisch ausgegeben werden.

Ich habe insgesamt 4 Klassen. Einmal die vorgegebene Stack-Klasse, eine Klasse für das GUI, eine für das Buch und eine für die Bücherstapel, in der die Stacks für die Bücher generiert werden.

Ich hab soweit alles fertig bis auf die grafische Ausgabe. Dies soll über eine JTextArea pro Stack funktionieren. Dort habe ich aber das Problem, dass ich gerne eine Kopie der Stacks erstellen würde und dann in einer while Schleife immer die Daten von .top() in die JTextArea ausgeben lassen und anschließend .pop() auf die Kopien anwenden würde. Allerdings wird, wenn ich .pop() auf die Kopie anwende gleichzeitig auch .pop() auf den Stack, von dem die Kopie stammt, ausgeführt.

Wie kann ich das umgehen? Oder was habe ich falsch gemacht?


Stack-Klasse (vom Schulministerium so vorgegeben):


Spoiler





```
/**
* <p>
* Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2017
* </p>
* <p>
* Generische Klasse Stack<ContentType>
* </p>
* <p>
* ...
* </p>
*
* @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule, Materialien zum schulinternen Lehrplan Informatik SII
* @version Generisch_02 2014-02-21
*/
public class Stack<ContentType> {

  /* --------- Anfang der privaten inneren Klasse -------------- */

  private class StackNode {

    private ContentType content = null;
    private StackNode nextNode = null;

    /**
     * Ein neues Objekt vom Typ StackNode<ContentType> wird erschaffen. <br />
     * Der Inhalt wird per Parameter gesetzt. Der Verweis ist leer.
     *
     * @param pContent der Inhalt des Knotens
     */
    public StackNode(ContentType pContent) {
      content = pContent;
      nextNode = null;
    }

    /**
     * Der Verweis wird auf das Objekt, das als Parameter uebergeben wird,
     * gesetzt.
     *
     * @param pNext der Nachfolger des Knotens
     */
    public void setNext(StackNode pNext) {
      nextNode = pNext;
    }

    /**
     *
     * @return das Objekt, auf das der aktuelle Verweis zeigt
     */
    public StackNode getNext() {
      return nextNode;
    }

    /**
     * @return das Inhaltsobjekt vom Typ ContentType
     */
    public ContentType getContent() {
      return content;
    }
  }

  /* ----------- Ende der privaten inneren Klasse -------------- */

  private StackNode head;

  /**
   * Ein leerer Stapel wird erzeugt. Objekte, die in diesem Stapel verwaltet
   * werden, muessen vom Typ ContentType sein.
   */
  public Stack() {
    head = null;
  }

  /**
   * Die Anfrage liefert den Wert true, wenn der Stapel keine Objekte
   * enthaelt, sonst liefert sie den Wert false.
   *
   * @return true, falls der Stapel leer ist, sonst false
   */
  public boolean isEmpty() {
    return (head == null);
  }

  /**
   * Das Objekt pContentType wird oben auf den Stapel gelegt. Falls
   * pContentType gleich null ist, bleibt der Stapel unveraendert.
   *
   * @param pContent
   *        das einzufuegende Objekt vom Typ ContentType
   */
  public void push(ContentType pContent) {
    if (pContent != null) {
      StackNode node = new StackNode(pContent);
      node.setNext(head);
      head = node;
    }
  }

  /**
   * Das zuletzt eingefuegte Objekt wird von dem Stapel entfernt. Falls der
   * Stapel leer ist, bleibt er unveraendert.
   */
  public void pop() {
    if (!isEmpty()) {
      head = head.getNext();
    }
  }

  /**
   * Die Anfrage liefert das oberste Stapelobjekt. Der Stapel bleibt
   * unveraendert. Falls der Stapel leer ist, wird null zurueckgegeben.
   *
   * @return das oberste Stackelement vom Typ ContentType oder null, falls
   *         der Stack leer ist
   */
  public ContentType top() {
    if (!this.isEmpty()) {
      return head.getContent();
    } else {
      return null;
    }
  }
}
```




Ein Teil der Bücherstapel-Klasse:


Spoiler





```
// Attributdeklaration und Definition im Konstruktor
private Stack<Buch> bs1;
    private Stack<Buch> bs2;

    /**
     * Constructor for objects of class Buecherstapel
     */
    public Buecherstapel()
    {
        bs1 = new Stack<Buch>();
        bs2 = new Stack<Buch>();
    }

// Rückgabe-Methode einer der Stacks
public Stack<Buch> getStack(String stapel){
        Stack<Buch> dummy = null;
        if(stapel.equals("1")){
            dummy = bs1;
        }
        else if(stapel.equals("2")){
            dummy = bs2;
        }
        return dummy;
    }
```




Update-Methode zur grafischen Darstellung der Stacks in den JTextAreas:


Spoiler





```
public void updateGUI(){
        stapel1Area.setText("");
        stapel2Area.setText("");

        Stack<Buch> dummyStack1 = buchstapel1.getStack("1");
        while(dummyStack1.top() != null){
            String name = dummyStack1.top().getName();
            int nummer = dummyStack1.top().getNr();

            stapel1Area.append("Buchname: " + name + " , Buchnummer: " + nummer);
        
            dummyStack1.pop();
        }

        Stack<Buch> dummyStack2 = buchstapel1.getStack("2");
        while(dummyStack2.top() != null){
            String name = dummyStack2.top().getName();
            int nummer = dummyStack2.top().getNr();

            stapel2Area.append("Buchname: " + name + " , Buchnummer: " + nummer);

            dummyStack2.pop();
        }
    }
```





Ich würde mich über eure Hilfe freuen. 

mfg Silas770


----------

