Objects speichern

wessi86

Mitglied
Guten Abend!
Ich arbeite an einem kleinen Rollenspiel und möchte nun eine Speichern/Laden-Funktion einbauen. Dazu habe ich bei den gewünschten Klassen Serializable implementiert und mir eine Zusatzklasse geschrieben, welche das Speichern/Laden übernehmen soll. Zunächst möchte ich 3 Objekte abspeichern: Den Spieler (Charakter-Level, Stärke, Leben, ...), das Draw-Object (Position des Spielers) und das Maze-Object (2400x1800-Matrix, nach der das Spielfeld gezeichnet wird). Alle drei Objekte sind 'public static' und besitzen getter- und setter-Methoden.

Das Problem: Das Speichern/Laden des Spieler- und Draw-Objects funktioniert einwandfrei, heißt, solange ich mich im gleichen Level befinde, kann ich speichern und Laden. Wenn ich mich allerdings in ein neues Level begebe (die Matrix im Maze-Object wird dynamisch neu generiert) funktioniert es nicht mehr. Spieler und dessen Position werden zwar geladen, allerdings dann in dem neuen Maze platziert (evtl dann auch in einer Wand). Es wird daran liegen, dass das Maze-Objekt nicht richtig gespeichert wird, denn die Datei ist bloß 634 Bytes groß, was für eine 2400x1800-Matrix deutlich zu klein ist (In einem kleinen Testprogramm habe ich eine 2000x2000-Matrix abgespeichert, welche dann 15 Mb groß war). Ich hab schon versucht die Matrix aus der Maze-Klasse direkt abzuspeichern, ging aber auch nicht, da wurde beim Laden sogar ne Exception geworfen und die Datei war nur 4 Bytes groß. Ich poste hier mal die relevanten stellen im code:

Applet-Klasse:
Java:
public static Draw drawMaze = new Draw();

public static Maze maze = new Maze();

public static Playa player;

[...]
//Methoden zum laden und speichern
    public static Maze getMaze() {
        return maze;
    }
    public static Playa getPlayer() {
        return player;
    }
    public static Draw getDraw() {
        return drawMaze;
    }

    public static void setPlayer(Playa p) {
        player = p;
    }
    public static void setMazeO(Maze m) {
        maze = m;
    }
    public static void setDraw(Draw d) {
        drawMaze = d;
    }

    @Override
    public void keyPressed(KeyEvent e) {

         [...]
        //F5
        if (e.getKeyCode() == 116) {
            saveLoad.serialize();
        }
        //F8
        if (e.getKeyCode() == 119) {
            saveLoad.deserialize();
//            setMaze();
        }
    }

saveLoad:
Java:
public static void serialize() {
    try {
      FileOutputStream player = new FileOutputStream("player.dlx");
      FileOutputStream maze = new FileOutputStream("maze.dlx");
      FileOutputStream draw = new FileOutputStream("draw.dlx");


      ObjectOutputStream oPlayer = new ObjectOutputStream(player);
      ObjectOutputStream oMaze = new ObjectOutputStream(maze);
      ObjectOutputStream oDraw = new ObjectOutputStream(draw);

      oPlayer.writeObject(DeluxeRPG.getPlayer());
      oMaze.writeObject(DeluxeRPG.getMaze());
      oDraw.writeObject(DeluxeRPG.getDraw());

      oPlayer.close();
      oMaze.close();
      oDraw.close();

    } catch (IOException e) { System.err.println(e); }
  }

  public static void deserialize() {
    Playa player;
    Maze maze;
    Draw draw;

    try {
      FileInputStream iPlayer = new FileInputStream("player.dlx");
      FileInputStream iMaze = new FileInputStream("maze.dlx");
      FileInputStream iDraw = new FileInputStream("draw.dlx");

      ObjectInputStream oPlayer = new ObjectInputStream(iPlayer);
      ObjectInputStream oMaze = new ObjectInputStream(iMaze);
      ObjectInputStream oDraw = new ObjectInputStream(iDraw);

      player = (Playa) oPlayer.readObject();
      maze = (Maze) oMaze.readObject();
      draw = (Draw) oDraw.readObject();

      oPlayer.close();
      oMaze.close();
      oDraw.close();

      DeluxeRPG.setPlayer(player);
      DeluxeRPG.setMazeO(maze);
      DeluxeRPG.setDraw(draw);

    } catch (IOException e) {
        System.err.println(e);
    } catch (ClassNotFoundException e) {
        System.err.println(e);
    }
  }

Wenn ich noch etwas an Code posten soll, bitte bescheid sagen. Bei Bedarf kann ich auch das komplette Spiel hochladen. Danke schonmal an diejenigen, die bis hierher gelesen haben ;)

mfg, Christian
 

wessi86

Mitglied
Kommt sofort (sitze schon Stunden hier vor:autsch:):
Java:
package Controller;

import Model.Monster;
import java.io.Serializable;
import java.util.Random;

/**Die Klasse, welche die Matrix erzeugt, anhand der das Spielfeld
 * gezeichnet wird.
 * @author Wessi
 */
public class Maze implements Serializable {

    Fight fight = new Fight();
    /**Der Levelcounter.
     *
     */
    private int levelCounter = 1, width = 2400, height = 1800;

    /**Die Matrix, anhand derer das Spielfeld gezeichnet wird.
     *
     */
    public static int[][] maze = new int[2400][1800];

    /**Matrix, in der die Position der 10 Räume gespeichert werden.
     *
     */
    private int[][] rooms = new int[10][4];

    /**Boolean newLevel.
     *
     */
    private boolean newLevel;
    
    /**Monster-Array.
     *
     */
    public static Monster[] monster = new Monster[40];

    /**Die Positionen der vier Eckpunkte des Players.
     *
     */
    private int playerX1 = 1190, playerX2 = 1210, playerY1 = 890, 
                playerY2 = 910;

    public static int[][] getMatrix() {
        return maze;
    }

    public static void setMatrix(int[][] m) {
        maze = m;
    }
    /**Den Levelcounter setzen.
     * @param x Level
     */
    public final void setLevelCounter(int x) {
        levelCounter = x;
    }

    /**X1, X2, Y1, Y2 auf ursprüngliche Werte zurücksetzen.
     *
     */
    public final void resetPlayer() {
        playerX1 = 1190;
        playerX2 = 1210;
        playerY1 = 890;
        playerY2 = 910;
    }

    /**Das Maze mit 0en und einem Rand aus 2en füllen.
     * id 2 = Rand
     * id 0 = Wand
     */
    public final void fillMaze() {
        for (int i = 0; i < width; i++) {
            for (int j = 0; j < height; j++) {
                maze[i][j] = 2;
            }
        }
        for (int i = 1; i < width - 20; i++) {
            for (int j = 1; j < height - 20; j++) {
                maze[i][j] = 0;
            }
        }
    }

    /**Einen Raum erzeugen.
     *
     * @param x1 x-Startposition
     * @param x2 x-Länge
     * @param y1 y-Startposition
     * @param y2 y-Länge
     * id 1 = Raum
     */
    public final void createRoom(final int x1, final int x2, final int y1,
            final int y2) {
        for (int i = x1; i < x1 + x2; i++) {
            for (int j = y1; j < y1 + y2; j++) {
                maze[i][j] = 1;
            }
        }
    }

    /**Zufallswerte für einen Raum erzeugen.
     *
     * @return Raum
     */
    public final int[] singleRoom() {
        int[] room = new int[4];
        room[0] = rndNumber(90, 3);
        room[1] = rndNumber(12, 12);
        room[2] = rndNumber(60, 3);
        room[3] = rndNumber(12, 12);

        return room;
    }

    /**Zufallswert erzeugen.
     *
     * @param x max-wert (min-wert wird noch hinzuaddiert)
     * @param y min-wert
     * @return Zahl
     */
    public static int rndNumber(final int x, final int y) {
        Random rnd = new Random();
        int i = (rnd.nextInt(x)) * 20 + (y * 20);
        return i;
    }

    /**Zufallswert erzeugen.
     *
     * @param x max-wert (min-wert wird noch hinzuaddiert)
     * @param y min-wert
     * @return Zahl
     */
    public final int simpleNumber(final int x, final int y) {
        Random rnd = new Random();
        int i = rnd.nextInt(x) + y;
        return i;
    }

    /**Einen Korridor erzeugen.
     *
     * @param x1 x-Startposition
     * @param x2 x-Länge
     * @param y1 y-Startposition
     * @param y2 y-länge
     * @param z1 x-Breite(?)
     * @param z2 y-Breite(?)
     * id 3 = Korridor
     */
    public final void createCorridor(final int x1, final int x2, final int y1,
            final int y2, final int z1, final int z2) {
        for (int i = 0; i < 3; i++) {
            for (int j = x1; j < x1 + x2; j++) {
                for (int k = y1; k < y1 + y2; k++) {
                    maze[j + (i * z1)][k + (i * z2)] = 3;
                }
            }
        }
    }

    /**Einen Korridor erzeugen.
     *
     * @param x1 x-Startposition
     * @param x2 x-Länge
     * @param y1 y-Startposition
     * @param y2 y-länge
     */
    public final void createSimpleCorridor(final int x1, final int x2,
            final int y1, final int y2) {
        for (int i = x1; i < x1 + x2; i++) {
            for (int j = y1; j < y1 + y2; j++) {
                maze[i][j] = 3;
            }
        }
    }

    /**Maze-Algor1thmus.
     * 1. Anfangsraum erstellen
     * 2. 9 Räume mit zufälliger Größe und zufälliger Position auf Map
     *    verteilen, keine Überschneidungen
     * 3. Räume nach oben verbinden, wenn möglich
     * 4. Räume nach rechts verbinden, auch an Korridore anschließen
     * 5. Nochmals räume nach oben verbinden, diesmal Korridoren anschließen
     * 6. Anfangsraum verbinden
     *
     */
    public final void createRooms() {
        createRoom(1100, 300, 800, 300);
        int nr = 0;
        while (nr < 9) {
            int x1 = singleRoom()[0];
            int x2 = singleRoom()[1];
            int y1 = singleRoom()[2];
            int y2 = singleRoom()[3];
            boolean free = true;

            for (int i = x1 - 20; i < x1 + x2 + 20; i += 20) {
                for (int j = y1 - 20; j < y1 + y2 + 20; j += 20) {
                    if (maze[i][j] == 1) {
                        free = false;
                    }
                }
            }
            if (free) {
                createRoom(x1, x2, y1, y2);
                rooms[nr][0] = x1;
                rooms[nr][1] = x2;
                rooms[nr][2] = y1;
                rooms[nr][3] = y2;
                nr++;
            }
        }

        /**Versuchen Räume zu verbinden
         *
         */
        boolean[][] roomLinked = new boolean[10][3];

        for (int i = 0; i < 10; i++) {
            for (int j = 4; j < 3; j++) {
                roomLinked[i][j] = false;
            }
        }

        for (int i = 0; i < 10; i++) {
            //Verbindung nach oben
            for (int j = rooms[i][0]; j < rooms[i][0] + rooms[i][1]; j += 20) {
                for (int k = rooms[i][2]; k > 0; k -= 20) {

                    if (maze[j][rooms[i][2] - k] == 1) {

                        if (!roomLinked[i][0]) {
                            roomLinked[i][0] = true;
                            createCorridor(j, 20, rooms[i][2] -k, k, 20, 0);
                        }
                    }
                }
            }
           //Verbindung nach rechts
           for (int j = rooms[i][2]; j < (rooms[i][2] + rooms[i][3]); j += 20) {
                for (int k = (rooms[i][0] + rooms[i][1]); k < 2400; k += 20) {
                    if (maze[k][j] == 1 || maze[k][j] == 4) {
                        if (!roomLinked[i][1]) {
                            roomLinked[i][1] = true;
                            createCorridor((rooms[i][0] + rooms[i][1]), k 
                                - (rooms[i][0] + rooms[i][1]), j, 20, 0, 20);
                        }
                    }
                }
            }
            //Verbindung nochmals nach oben, diesmal Gänge mit berücksichtigen
            for (int j = rooms[i][0]; j < rooms[i][0] + rooms[i][1]; j += 20) {
                for (int k = rooms[i][2]; k > 0; k -= 20) {
                    if (maze[j][rooms[i][2] - k] == 4) {
                        if (!roomLinked[i][2]) {
                            roomLinked[i][2] = true;
                            createCorridor(j, 20, rooms[i][2] - k, k, 20, 0);
                        }
                    }
                }
            }
        }

        //Versuchen Anfangsraum zu verlinken
        for (int i = 1400; i < 2200; i += 20) {
            for (int j = 800; j < 1100; j += 20) {
                if (maze[i][j] == 1 || maze[i][j] == 3) {
                    if (!roomLinked[9][0]) {
                        roomLinked[9][0] = true;
                        createSimpleCorridor(1400, i - 1400, j, 40);
                    }
                }
            }
        }

        if (levelCounter < 6) {
            for (int i = rooms[1][0] + 100; i < rooms[1][0] + 200; i++) {
                for (int j = rooms[1][2] + 40; j < rooms[1][2] +140; j++) {
                    maze[i][j] = 7;         // 7 = Fläche der Treppe
                }
            }                                    // 8 = Punkt zum Zeichnen
            maze[rooms[1][0] + 100][rooms[1][2] + 40] = 8;
        }
    }

    /**Das Maze ausgeben.
     *
     * @return Maze
     */
    public final int[][] returnMaze() {
        return maze;
    }

    /**Player in der Matrix nach oben bewegen.
     *
     */
    public final void playerMoveUp() {
            playerY1--;
            playerY2--;
    }

    /**Player in der Matrix nach unten bewegen.
     *
     */
    public final void playerMoveDown() {
            playerY1++;
            playerY2++;
    }

    /**Player in der Matrix nach rechts bewegen.
     *
     */
    public final void playerMoveRight() {
            playerX1++;
            playerX2++;
    }

    /**Player in der Matrix nach links bewegen.
     *
     */
    public final void playerMoveLeft() {
            playerX1--;
            playerX2--;
    }

    public static void setMonster() {
        int nr = 0;
        int x = 0;
        int y = 0;

        while (nr < monster.length) {
            x = rndNumber(118, 1);
            y = rndNumber(88, 1);
            if (maze[x][y] == 1 && maze[x + 20][y] == 1 && maze[x][y + 20] == 1
                     && maze[x + 20][y + 20] == 1) {
                for (int i = x; i < x + 20; i++) {
                    for (int j = y; j < y + 20; j++) {
                        maze[i][j] = nr + 20;
                    }
                }
                if (DeluxeRPG.levelCounter == 1) {
                    monster[nr] = new Monster(x, y, 2, 5, nr + 20);
                } else if (DeluxeRPG.levelCounter == 2) {
                    monster[nr] = new Monster(x, y, 4, 8, nr + 20);
                } else if (DeluxeRPG.levelCounter == 3) {
                    monster[nr] = new Monster(x, y, 6, 12, nr + 20);
                } else if (DeluxeRPG.levelCounter == 4) {
                    monster[nr] = new Monster(x, y, 8, 18, nr + 20);
                } else if (DeluxeRPG.levelCounter == 5) {
                    monster[nr] = new Monster(x, y, 12, 22, nr + 20);
                } else if (DeluxeRPG.levelCounter == 6) {
                    monster[nr] = new Monster(x, y, 14, 28, nr + 20);
                }

                maze[x][y] = nr + 20;
                nr++;
            }
        }
    }
    /**Potion setzen.
     *
     */
    public static void setPotion(int x, int y) {
        for (int i = x; i < 20 + x; i++) {
            for (int j = y; j < 20 + x; j++) {
                maze[i][j] = 10;
            }
        }
    }

    /**Monster geht nach links.
     *
     * @param x
     * @return 
     */
    public int[] monsterLeft(int x) {
        int[] left = new int[20];
        for (int i = 0; i < 20; i++) {
            left[i] = maze[monster[x].getPosX()-1][monster[x].getPosY()+i];
        }
        return left;
    }
    
    public int[] monsterRight(int x) {
        int[] right = new int[20];
        for (int i = 0; i < 20; i++) {
            right[i] = maze[monster[x].getPosX()+21][monster[x].getPosY()+i];
        }
        return right;
    }

    /**Gebiet um den Player nach Monstern scannen und ggf. kämpfen.
     *
     */
    public final void scanPlayerArea() {
        int monsterId = 0;
        for (int i = 0; i < 24; i++) {
            for (int j = 0; j < 24; j++) {
                if (maze[playerX1-2+i][playerY1-2+j] >= 20) {
                    monsterId = maze[playerX1-2+i][playerY1-2+j] - 20;
                    fight.fight(monsterId);
                }
                if (maze[playerX1-2+i][playerY1-2+j] == 10) {
                    
                }
            }
        }
    }
    
    public static void killMonster(int x) {
        for (int i = monster[x].getPosX(); i < monster[x].getPosX() + 20; i++) {
            for (int j = monster[x].getPosY(); j < monster[x].getPosY() +20;
                        j++) {
                maze[i][j] = 1;
        }
        }
    }

    /**Ausgeben, was sich links neben dem Spieler befindet.
     *
     * @return id
     */
    public int[] playerLeft() {
        int[] left = new int[20];

        for (int i = 0; i < 20; i++) {
            left[i] = maze[playerX1-1][playerY1+i];
        }
        return left;
    }

    /**Ausgeben, was sich rechts neben dem Spieler befindet.
     *
     * @return id
     */
    public int[] playerRight() {
        int[] right = new int[20];

        for (int i = 0; i < 20; i++) {
            right[i] = maze[playerX2+1][playerY1+i];
        }
        return right;
    }

    /**Ausgeben, was sich oberhalb des Spielers befindet.
     *
     * @return id
     */
    public int[] playerUp() {
        int[] up = new int[20];

        for (int i = 0; i < 20; i++) {
            up[i] = maze[playerX1+i][playerY1-1];
        }
        return up;
    }

    /**Ausgeben, was sich unterhalbdes Spielers befindet.
     *
     * @return id
     */
    public int[] playerDown() {
        int[] down = new int[20];

        for (int i = 0; i < 20; i++) {
            down[i] = maze[playerX1+i][playerY2+1];
        }
        return down;
    }
}
 

Ariol

Top Contributor
Deine maze-Array ist static. Mach daraus einen normalen Member und schon geht's.

Wenn du unbedingt statisch darauf zugreifen musst: Sieh dir das Singleton-Pattern an.
 

wessi86

Mitglied
Vielen Dank schonmal für die Antwort!
Also die Matrix muss statisch sein, weil ich darauf aus der Fight.java zugreifen muss. Erzeuge ich in der Fight-Klasse ein neues Maze-Objekt, bekomme ich einen "java.lang.StackOverflowError". Ich schau mir mal das Singletone-Pattern an, oder kann ich irgendwie sonst auf die Matrix zugreifen ohne ein neues Maze-Object zu erzeugen oder die Matrix static zu setzen?

mfg, Christian

Edit: In meinem kleinen Testprogramm(s.o.) habe ich die Matrix auch static erzeugt und es hat funktioniert. Hat das Problem etwas mit den Zugriffen auf die Matrix zu tun?

Edit 2: Hab mir das Singleton-Pattern mal angeschaut, weiß jetzt aber nicht genau, wie mir das weiterhilft. Ist das nicht dafür da, dass nur eine Instanz eines Objektes initialisiert werden kann?

Edit 3: Es funktioniert! Ich habe die Matrix jetzt ohne static und die benötigten Funktionen aus der Fight-Klasse rufe ich mittels einer Maze-Variable im Konstruktor mit auf.
 
Zuletzt bearbeitet:
Ähnliche Java Themen
  Titel Forum Antworten Datum
S Arraylist<Object> mit verschiedenen Objects ausgeben Java Basics - Anfänger-Themen 3
S Methoden Multi-Thread und Methoden Objects. Java Basics - Anfänger-Themen 1
G Moving Objects with Threads (implements Runnable) Java Basics - Anfänger-Themen 1
E Senden von Objects an Client. Variablenwerte kommen nicht an Java Basics - Anfänger-Themen 5
H Datentypen Casting objects Java Basics - Anfänger-Themen 29
W Auf Objects zugreifen Java Basics - Anfänger-Themen 17
S Array of objects und ständige Constructor-Aufrufe Java Basics - Anfänger-Themen 4
D Objects-Wie realiesieren. Java Basics - Anfänger-Themen 4
G fehler bei erzeugen eines objects Java Basics - Anfänger-Themen 4
P probleme mit variablen eines Objects Java Basics - Anfänger-Themen 13
T Typsicheres casten eines Objects Java Basics - Anfänger-Themen 5
L array of objects in liste packen Java Basics - Anfänger-Themen 2
R Textfile vs Serialized Objects Java Basics - Anfänger-Themen 4
R Objects, arrays usw. Java Basics - Anfänger-Themen 5
B equals() der Klasse Objects liefert unerwartetes Ergebnis Java Basics - Anfänger-Themen 17
M Länge eines Arrays als Variable speichern möglich? Java Basics - Anfänger-Themen 14
R Liste in Variable speichern Java Basics - Anfänger-Themen 6
onlyxlia Anzahl Random Zahlen mit Scanner abfragen und in Array speichern Java Basics - Anfänger-Themen 10
G JTree speichern und wieder einlesen Java Basics - Anfänger-Themen 5
P Wie kann ich in meinem Java Programm etwas dauerhaft speichern? Java Basics - Anfänger-Themen 5
P Wie kann ich beispielsweise Speicherstände eines Spiels DAUERHAFT in meinem Programm speichern? Java Basics - Anfänger-Themen 3
J Objekte in JSON speichern?? Java Basics - Anfänger-Themen 1
A Daten aus einer HashMap aus einer DB speichern und mit neuen Werten vergleichen Java Basics - Anfänger-Themen 8
I Bild richtig speichern / Hochkant im File Explorer, nach Upload vertikal Java Basics - Anfänger-Themen 9
I Objekte in ShareProject speichern um später zu nutzen Java Basics - Anfänger-Themen 4
I Passwort in Datenbank speichern um später wieder auszulesen Java Basics - Anfänger-Themen 5
S mehrere TreeSets so speichern, dass man sie miteinander vergleichen kann Java Basics - Anfänger-Themen 1
I Datei (Bild) Drucken und wie Druckeinstellung speichern? Java Basics - Anfänger-Themen 3
I H2 Datenbank starten / Daten in File speichern Java Basics - Anfänger-Themen 25
M Werte in Felder speichern und geordnet ausgeben Java Basics - Anfänger-Themen 8
A CSv.Datei einlesen und die werte in zweidemosional Int Array speichern Java Basics - Anfänger-Themen 9
L Dauerhaftes Speichern einer Eingabe bei einer ArrayList Java Basics - Anfänger-Themen 26
S Eine Variable in einem Array speichern Java Basics - Anfänger-Themen 5
T Permanentes speichern von Objekten in einer ArrayList Java Basics - Anfänger-Themen 6
M Mehrere Daten/ Variablen Speichern Java Basics - Anfänger-Themen 9
berserkerdq2 Ich gebe eine ArrayList als List zurück per MEthode, wie kann ich nun aber die ArrayList speichern? Java Basics - Anfänger-Themen 46
I Historisierung - Alter Wert, Neuer Wert... wie speichern? Java Basics - Anfänger-Themen 44
berserkerdq2 Wie datum im default format speichern? Java Basics - Anfänger-Themen 5
M Objekt in einem Objekt speichern Java Basics - Anfänger-Themen 9
J Speichern von zwei Variablen durch Auslesen aus einem Numberfield Java Basics - Anfänger-Themen 2
f3mys Objektwerte in Liste speichern und wieder abrufen Java Basics - Anfänger-Themen 23
I Liste von Infos von einer eigenen Annotation in Liste speichern Java Basics - Anfänger-Themen 0
U Wie ein Attribut von einer Klassenmethode in der Klasse speichern= Java Basics - Anfänger-Themen 2
B Screenshots machen und zwar viele und speichern Java Basics - Anfänger-Themen 12
C XML Datei speichern und laden Java Basics - Anfänger-Themen 18
Marlena Bauer Konsolenausgabe in .txt speichern Java Basics - Anfänger-Themen 6
B JaxB - Property vom Typ Object und LocalDateTime speichern? Java Basics - Anfänger-Themen 0
ansystin Teilerfremde Zahlen ausgeben + Zahlenausgabe speichern Java Basics - Anfänger-Themen 3
J Wert in einer json Datei ändern und speichern Java Basics - Anfänger-Themen 3
C File speichern Java Basics - Anfänger-Themen 5
D String und char in String speichern Java Basics - Anfänger-Themen 5
J Alle .java Dateien von einem Verzeichnis in eine Zip speichern Java Basics - Anfänger-Themen 2
I Werte (u.a. Geldbeträge) in Datenbank speichern und Rundungen? Java Basics - Anfänger-Themen 8
J Problem mit einer Methode, die beliebig viele Objekte in Array speichern soll Java Basics - Anfänger-Themen 6
H Daten aus einer Datei in eine Liste speichern Java Basics - Anfänger-Themen 23
B JaxB - speichern vom Typ "Object" Java Basics - Anfänger-Themen 8
GermanPie Nachrichten Speichern Java Basics - Anfänger-Themen 2
M Objekte in Array speichern und ausgeben Java Basics - Anfänger-Themen 17
C Wo Defaultpfad speichern? Java Basics - Anfänger-Themen 2
M Integer aus aus einer Klasse in andere speichern Java Basics - Anfänger-Themen 12
Dimax stream in string[] speichern Java Basics - Anfänger-Themen 6
H Liste speichern. Was lässt sich verbessern? Java Basics - Anfänger-Themen 7
C Fehler beim Speichern (Build projekt) Java Basics - Anfänger-Themen 42
J Ich brauche Hilfe bei einem Code (Variablen speichern) Java Basics - Anfänger-Themen 29
C Verschiedene Objekte in einer Liste speichern Java Basics - Anfänger-Themen 6
D Input/Output Input von zwei Koordinaten validieren und anschließend Werte speichern Java Basics - Anfänger-Themen 7
N Speichern von Werten in Variablen nach Schließen des Programms Java Basics - Anfänger-Themen 3
G Problem beim Speichern von Objekten in einer Datei Java Basics - Anfänger-Themen 7
I ArrayList - Methode zum Speichern eines Eintrags in einer Datei Java Basics - Anfänger-Themen 17
H Objekt im Array speichern Java Basics - Anfänger-Themen 2
H Objekt als Attribut speichern Java Basics - Anfänger-Themen 11
B Text-Datei nur in Stream speichern und dann ausgeben Java Basics - Anfänger-Themen 3
M JTextField in ArrayList speichern Java Basics - Anfänger-Themen 4
L Nur Bestimmte Werte aus einem Array in ein anderes Speichern Java Basics - Anfänger-Themen 11
S Zweidimensionales Array in ein eindimensionales Array speichern Java Basics - Anfänger-Themen 6
A Wie zwei zahlen in einer Variable speichern? Java Basics - Anfänger-Themen 7
C ResultSet in Array speichern Java Basics - Anfänger-Themen 5
S Byte-Array kann chars speichern? Java Basics - Anfänger-Themen 3
J Kann man files in einer Klasse speichern. Java Basics - Anfänger-Themen 2
B Infos zu Attribute in einer Klasse speichern Java Basics - Anfänger-Themen 3
M Input/Output JTextField Eingabe in String Variable speichern Java Basics - Anfänger-Themen 15
A Kann man eine Methode als Variable speichern und danach noch verändern? Java Basics - Anfänger-Themen 6
D Werte aus einem BinärBaum in einem Array speichern Java Basics - Anfänger-Themen 1
I Datei in Programm speichern Java Basics - Anfänger-Themen 3
A .txt-Datei mit Java speichern Java Basics - Anfänger-Themen 2
M Speichern unter. Java Basics - Anfänger-Themen 11
S Java Daten in Excel speichern Java Basics - Anfänger-Themen 1
S Daten speichern, ohne Datenbank Java Basics - Anfänger-Themen 8
L Objekt aus Textdatei in ArrayList speichern Java Basics - Anfänger-Themen 4
L Kommandozeileneinträge in Array speichern Java Basics - Anfänger-Themen 4
B HTML Code in XML speichern Java Basics - Anfänger-Themen 3
G Benutzereingaben durch Zeilenumbruch trennen und in Array individueller Größe speichern Java Basics - Anfänger-Themen 20
G JTextField per Button speichern und an andere Klasse übergeben Java Basics - Anfänger-Themen 2
Shallty Daten speichern und ändern? Java Basics - Anfänger-Themen 32
R Objekte aus Array als String + kommasepariert speichern Java Basics - Anfänger-Themen 12
N Best Practice Rückgabe eines Terminal Befehls in eine Variable speichern Java Basics - Anfänger-Themen 27
B XML in DB speichern -> Regelkonzept Java Basics - Anfänger-Themen 2
T Daten von Objekten speichern Java Basics - Anfänger-Themen 7
A Einträge aus Tupeln nach Regeln in Liste speichern Java Basics - Anfänger-Themen 8
void19 Methoden Binärbaum Inorder Traversierung in Array speichern Java Basics - Anfänger-Themen 1

Ähnliche Java Themen

Neue Themen


Oben