Stack

probiere einmal

Stack<Integer> s = new Stack<Integer>();

Hallo Alex,

Dein Problem hat nichts mit der Klasse Stack zu tun, sondern mit den themen "Java Generics", "java primitive types" und "java autoboxing".

Das sind Themen, in die du dich einlesen musst (sollte in jedem guten Java buch erklaehrt werden, oder du suchst nach den obigen Begriffen in der Suchmaschine deiner Wahl).

Kurz gesagt: Bei der Zeile

stack.push(x);

wurde das primitive object x automatisch in ein Object der Klasse Integer umgewandelt. Datenstrukturen wie der Stack sind nicht in der lage, primitive Datentypen zu fassen.

Und in der Zeile

Stack stack = new Stack();

hast du nicht angegeben, von welchen Typ die Objekte sind, die der Stack enthalten soll.

Stack<Integer> stack = new Stack<Integer>();

loest dieses Problem hier.

Hab gerade eine total komische Erfahrung gemacht, die ich mir absolut nicht erklären kann:
Wenn ich zuerst den Stack deklariere

private Stack<Integer> stack;

und das Objekt dann im Konstruktor erzeuge

stack = new Stack<Integer>();

dann kann ich mittels push() hinzufügen was ich möchte, er wirft immer eine NullPointerException.
Wenn ich allerdings gleich bei der Deklaration schreibe

private Stack<Integer> stack = new Stack<Integer>();

führt er alles so aus wie erwartet. Kann sich das irgendjemand erklären?

Zitat von florian.kisser

Hab gerade eine total komische Erfahrung gemacht, die ich mir absolut nicht erklären kann:
Wenn ich zuerst den Stack deklariere

Code

private Stack<Integer> stack;

und das Objekt dann im Konstruktor erzeuge

Code

stack = new Stack<Integer>();

dann kann ich mittels push() hinzufügen was ich möchte, er wirft immer eine NullPointerException.
Wenn ich allerdings gleich bei der Deklaration schreibe

Code

private Stack<Integer> stack = new Stack<Integer>();

führt er alles so aus wie erwartet. Kann sich das irgendjemand erklären?

Vielleicht hast du 2 Konstruktoren und rufst unabsichtlich den anderen auf, in dem stack nicht initialisiert wird? Zeig uns am besten den Code...

Garantiert kein überladener Konstruktor.

Den Stack habe ich items getauft:

import java.util.*;
import java.lang.*;


public class Upn {
    private Stack<Integer> items = new Stack<Integer>();    // Stack für die Operanden
    private int a, b;    // die beiden zu verarbeitenden Operanden - refresh() liefert neue Operanden
    public boolean stateOK = true;


    public boolean add() {    // Addition
        if (!refresh()) return false;
        push(a + b);
        return true;
    }


    public boolean sub() {    // Subtraktion
        if (!refresh()) return false;
        push(a - b);
        return true;
    }


    public boolean multi() {    // Multiplikation
        if (!refresh()) return false;
        push(a * b);
        return true;
    }


    public boolean div() {    // ganzzahlige Division
        if (!refresh()) return false;
        if (b!=0) {    // keine Division durch 0
            push(a / b);
            return true;
        } else {
            stateOK = false;
            return false;
        }
    }


    public void push(int item) {    // push-Wrapper für den Stack - wandelt int zu java.lang.Integer
        items.push(Integer.valueOf(item));
    }


    private boolean refresh() {    // liest neue Operanden aus
        try {
            b = items.pop().intValue();
            a = items.pop().intValue();
            return true;
        } catch(Exception e) {
            stateOK = false;
            return false;
        }
    }


    public String returnStack() {    // liefert den Stack bzw das Ergebnis als String
        String result = "";


        if (stateOK && !items.empty()) {
            result = items.pop().toString();
            while (!items.empty()) {
                result = items.pop().toString() + " " + result;
            }
        }
        return result;
    }


    public void reset() {    // Zuruecksetzen (loescht den Stack und setzt den Status auf OK)
        items = new Stack<Integer>();
        stateOK = true;
    }


    public static void Upn() {    // Konstruktor


    }
}

So funktionierts, aber probier mal meine kleine Änderung wie beschrieben.

Zitat von florian.kisser

Code

public static void Upn() {    // Konstruktor
}

Das ist halt aber auch kein Konstruktor. Richtig wäre:

public Upn() {
}

Zitat von beefy

Das ist halt aber auch kein Konstruktor. Richtig wäre:

Code

public Upn() {
}

Ups.
Hab vorm postn noch herumprobiert und vergessen das static rückgängig zu machen, aber das void is schon die ganze Zeit da. :shinner: Shame on me, n dummer Fehler. Hab hundermal hingeschaut und es übersehen.

frage: wieso schmeisst du in der memberfunction 'reset' den alten stack weg und allokierst einen neuen speicherbereich?

public void reset() {    // Zuruecksetzen (loescht den Stack und setzt den Status auf OK)
        items = new Stack<Integer>();
        stateOK = true;
    }

angenehmer waers doch, wenn du den stack mit .clear() leeren wuerdest, um ihn in den anfangszustand zu versetzen.

public void reset() {    // Zuruecksetzen (loescht den Stack und setzt den Status auf OK)
        items.clear();
        stateOK = true;
    }

daraus koennte naemlich deine exception resultieren (2 methoden, 2x selber speicher angefordert - garbage collector gibt w.o.).

Also fuer den fehler ist

stack = new Stack<Integer>()

nicht zustaendig, denn den haben wir ja mittlerweile gefunden und beseitigt. Es kann auch nicht zu problemen fuehren, wenn man einfach einen neuen stack erstellt.

stack.clear() ist aber der schoenere weg, da hatt hssemichi schon recht.

Der Fehler is, dass der Konstruktor falsch deklariert war und deshalb nicht aufgerufen worden ist => der Stack war ein null-Objekt => NullPointerException

wegen reset:
Hab eine passende Stack-Funktion gesucht und nicht gefunden. Hab aber übersehen, dass clear vom Vektor vererbt wurde. Außerdem brauche ich reset garnicht; habs einfach nur so geschrieben.

Ich habe hier ein seltsames Problem, ich definiere den Stack in der UPN Klasse

Stack<Integer> st = new Stack<Integer>();

jedoch beim Kompilieren erhalte ich folgende Meldung:

UPN.java:6: cannot find symbol
symbol  : class Stack
location: class UPN
                Stack<Integer> st = new Stack<Integer>();

jemand nen plan wo da der fehler liegen könnte?

import vergessen?

du musst um stack zu benutzen java.util.Stack; oder sowas importieren