Mehrfach Array "speichern"

[Craxxor]

Hallo zusammen,

ich muss für die Hochschule ein Beleg anfertigen. Dort ist gefordert mehrere Matrizen in einer eigenen Klasse anzulegen und zu "speichern" sodass man auch später noch auf die eingegebenen Matrizen zugreifen kann.
Die einfachste Lösung wäre ja, immer ein neues Objekt zu erzeugen, das gefällt mir aber nicht so.
Meine Idee ist, dass der Benutzer (mein Dozent) über ein Menü einen Index/Speicherplatz angibt wo dann die Matrix gespeichert wird.
Hier wäre die Beispiel-Klasse:

public class MatrixClass{

	private double matrix[][];
	private int zeile;
	private int spalte;
	
	
	//Defaul-Konstruktor
	public MatrixClass{
		zeile = 2;
		spalte = 2;
		matrix = new double[zeile][spalte];
		set_matrix();
	}
	
	private void set_matrix_random(){
		for(int i=0;i<this.zeile;i++)
		{
			for(int j=0;j<this.spalte;j++){
			 matrix[i][j] = Math.random()*10+1;
			}
		}
		
	}
	
	public void storage(int i)
	{
		//Hier brauche ich eure Hilfe
	}
	
	public void restore(int i)
	{
		//Hier brauche ich eure Hilfe
	}
}

Hier wäre die Main dazu:

import java.util.Scanner;

public class Main{
	public static void main (String [] args]{

		Scanner in = new Scanner(System.in);
		MatrixClass m = new MatrixClass();

		System.out.println("Auf welchem Speicherplatz soll die Matrix gespeichert werden?");
		System.out.print("Index: ");
		int index = in.nextInt()

		m.storage(index);

		System.out.println("Aus welchem Speicherplatz soll die Matrix geladen werden?");
		System.out.print("Index: ");
		int index = in.nextInt()

		m.restore(index);
	}
}

Ich habe versucht mich auch mit verketteten Listen auseinander zu setzen, nur leider weiß ich nicht wie ich das in meinem Programm umsetzen kann.

Ich habe den Code jetzt nicht kompiliert, da ich ihn in Notepad++ schnell geschrieben habe.
Falls dort jetzt was falsch sein sollte bin ich froh wenn ihr mich korrigiert.

PS: Ich hab mir das "bildlich" so vorgestellt:
[JAVA=28]
Index[0] = Matrix 1
Index[1] = Matrix 4
Index[2] = Matrix 2
Index[3] = Matrix 5
Index[4] = Matrix 3
[/code]

 

[kaoZ]

wenn dann müsstest du wohl schon , da du ein 2D Array nutzt
anstelle von

public void storage(int i)
    {
        //Hier brauche ich eure Hilfe
    }

das hier verwenden :

public void storage(int zeile, int spalte)
    {
        
    }

vorrausgesetzt du möchstest diesen Effekt :

XXXX
XX0X // 0 wäre dann zeile 1 / spalte 2
XXXX
XXXX

wenn du nur so deine Matritzen abspreichern möchtest

X
0 index wäre dann 1
X
X

benötigst du ja kein Mehrdimensionales Array

oder habe ich dich nun falsch verstanden ? du möchtest Mehre Matrizen in einer Matrix Speichern ?!

von deinem Bild ausgehen wäre letzteres dein anliegen.
[EDIT]
die Frage die sich mir stellt ist auch , Speichern im Sinne von Persistent Speichern (Serialisieren) oder einfach nur in einem Array aus Matrizen ?[/EDIT]

Ansonsten halt eine Klasse Matrix erstellen welche Deine Daten hält,

und dann ein Array aus diesen anlegen:

Matrix[] values = new Matrix[12];

values[5] = new Matrix(2,5);  // nur fiktives Beispiel ....

 

[Craxxor]

oder habe ich dich nun falsch verstanden ? du möchtest Mehre Matrizen in einer Matrix Speichern ?!

ja falsch verstanden
Ich möchte nur die Matrix "ablegen", sodass mehreren Rechnungen gesagt werden kann:
1. Rechnung "Matrix A + Matrix B"
2. Rechnung "Matrix A + Ergebnis aus 1. Rechnung"

Also das die Matrix nicht überschrieben wird und zu jederzeit abgerufen werden kann.
Wie gesagt man könnte es auch so lösen:

//Hab jetzt den Anfang weg gelassen...
MatrixClass mA = new MatrixClass();
MatrixClass mB = new MatrixClass();
MatrixClass mC = new MatrixClass();

//dann die Frage nach dem Index mit einem switch:
switch (index){
case 1: mA.set_matrix();
case 2: mB.set_matrix();
case 3: mC.set_matrix();
}
//das selbe dann noch mit einer Methode get_matrix();

Diese Lösung finde ich aber nicht schön gelöst.

[EDIT]
die Frage die sich mir stellt ist auch , Speichern im Sinne von Persistent Speichern (Serialisieren) oder einfach nur in einem Array aus Matrizen ?[/EDIT]

... :rtfm: Persistent Speichern kenne ich nicht...

Ansonsten halt eine Klasse Matrix erstellen welche Deine Daten hält,

und dann ein Array aus diesen anlegen:

Matrix[] values = new Matrix[12];

values[5] = new Matrix(2,5);  // nur fiktives Beispiel ....

:ideaas probiere ich mal gleich aus... :toll:

 

[Craxxor]

Ansonsten halt eine Klasse Matrix erstellen welche Deine Daten hält,

und dann ein Array aus diesen anlegen:

Matrix[] values = new Matrix[12];

values[5] = new Matrix(2,5);  // nur fiktives Beispiel ....

:ideaas probiere ich mal gleich aus... :toll:

Funktioniert nicht ganz, ich habe das jetzt folgendermaßen geschrieben:

//[...]
MatrixClass m = new MatrixClass();
MatrixClass[] storage = new Matrixclass[10];
//[...]

//Eingabe vom Benutzer welchen Speicherplatz...
m.set_Matrix();
storage[index] = new MatrixClass();

//Eingabe vom Benutzer aus welchem Speicherplatz geladen werden soll
System.out.println("Ihre Matrix aus dem Speicherplatz "+ index + " lautet:\n" + storage[index]);

als Ausgabe erhalte ich dann:

Ihre Matrix aus dem Speicherplatz 1 lautet:
beleg_1.MatrixClass@5c647e05

Was denke ich mal die RAM Adresse ist...
Was mache ich falsch? Habe ich die Logik nicht gerafft??

 

[trez]

Vor zig Monaten habe ich für dasselbe Problem eine Lösung gefunden (Weiss aber nicht mehr genau wo)

Pack deine 2D-Matrixen in eine serialisierbare Klasse (anstelle des Strings und int im Beispiel)
Wenn die Memoryadresse statt etwas "sinnvollem" ausgegeben wird, fehlt die toString Methode.

Das findest du alles

Spoiler: da

import java.io.Serializable;

public class SerializableObject implements Serializable {

	private static final long serialVersionUID = 8496584085708172980L;

	private String name;
	private int number;

	public SerializableObject() {
		name = "default constructor was called";
		number = 0;
	}

	public SerializableObject(String name, int number) {
		this.name = name;
		this.number = number;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getNumber() {
		return this.number;
	}

	public void setNumber(int intValue) {
		this.number = intValue;
	}
	
	@Override
	public String toString() {
		return "Name = " + name + ", Nummer = " + number;
	}
}

und

Spoiler: da

import java.io.*;

public class VersuchSerializable {

	public SerializableObject readObject(String filename) {
		ObjectInputStream ois = null;
		FileInputStream fis = null;
		SerializableObject so = null;
		try {
			fis = new FileInputStream(filename);
			ois = new ObjectInputStream(fis);
			Object obj = ois.readObject();
			if (obj instanceof SerializableObject) {
				so = (SerializableObject)obj;
			}
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			if (ois != null) {
				try {
					ois.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (fis != null) {
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}	
		return so;
	}

	public void writeObject(SerializableObject so, String path) {
		ObjectOutputStream oos = null;
		FileOutputStream fos = null;
		try {
			fos = new FileOutputStream(path);
			oos = new ObjectOutputStream(fos);
			oos.writeObject(so);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (oos != null) {
				try {
					oos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

	public static void main(String[] args) {
		String filename = "C:/temp/file_";
		VersuchSerializable vs = new VersuchSerializable();
		SerializableObject so = new SerializableObject("Objekt 1", 1);
		vs.writeObject(so, filename + 1);
		so = new SerializableObject("Objekt 2", 2);
		vs.writeObject(so, filename + 2);
		so = vs.readObject(filename + 1);
		System.out.println("Gelesenes Objekt : " + so);
		so = vs.readObject(filename + 2);
		System.out.println("Gelesenes Objekt : " + so);
	}
}

 

[Craxxor]

Danke trez, die Lösung von dir ist mir derzeit ein wenig zu komplex für diese kleine Arbeit.

Der Lösungs ansatz bzw. sogar die Lösung von kaoZ ist für meine Zwecke perfekt, sie ist simpel und ich kann sie gut einbauen.

Mein Fehler war einfach, dass ich immer mit meinem noch zuvor erzeugten Objekt
[JAVA=7]MatrixClass m = new MatrixClass();[/code]
gearbeitet habe und darüber meine Methoden aufgerufen hatte.
Diese Zeile musste weg und wurde dafür hier mit ersetzt:

MatrixClass[] storage = new MatrixClass[10];

darüber musste ich auch die ganzen get-/set-Methoden ausführen sprich

//Benutzer gibt index ein.
storage[index].set_matrix();

Danke für eure Hilfe :idea::toll:

 

[kaoZ]

Funktioniert nicht ganz, ich habe das jetzt folgendermaßen geschrieben:

Klar funktioniert das nicht, da ich meine Klasse anders benannt habe

Hier mal ein "kleines" Beispiel was ich meine :

Matrix:

public class Matrix {
	
	int[][] matrix;
	
	public Matrix(int row, int coloumn) {
		matrix = new int[row][coloumn];
	}
	
	public void addToMatrix(int value, int row, int coloumn){
		matrix[row][coloumn] = value;
	}
	
	public int getValueAtIndex(int row, int coloumn){
		return matrix[row][coloumn];
	}
	
	public static void main(String[] args) {
		
		new MatrixTest();
	}

}

MatrixMemory:

class MatrixMemory{
	
	ArrayList<Matrix> matrixList;
	
	public MatrixMemory() {
		matrixList = new ArrayList<>();
	}
	
	public void store(Matrix...matrizen){
		for (Matrix matrix : matrizen) {
			matrixList.add(matrix);
		}
	}
	
	public void storeAtIndex(int index, Matrix matrix){
		matrixList.add(index, matrix);
	}
	
	public Matrix loadFromIndex(int index){
		return matrixList.get(index);
	}
}

MatrixTest (Dies wäre die Anwendungsklasse)

class MatrixTest{
	
public MatrixTest() {
	
	Matrix m1 = new Matrix(2, 3); // 1.te matrix mit beliebiger Größe erstellen
	Matrix m2 = new Matrix(1, 1); // 2.te matrix mit beliebiger Größe erstellen
	
	m1.addToMatrix(12, 1, 2); // Werte zu matrix 1 hinzufügen
	m2.addToMatrix(22, 0, 0); // Werte zu matrix 2 hinzufügen
	
	MatrixMemory mem = new MatrixMemory(); // matrixspeicher instanzieren
	
	mem.store(m1,m2); // matrix 1 und 2 im "speicher" ablegen

        /* Werte an den angegebenen indizies der verschiedenen matrizen zusammenrechnen */

	System.out.println(mem.loadFromIndex(0).getValueAtIndex(1, 2) + mem.loadFromIndex(1).getValueAtIndex(0, 0));
	}
}

Wenn du nun in der main Methode MatrixTest instanzierst , rechnet dir die Operation der klasse MatrixTest direkt die werte aus den beiden Matrizen zusammen :

und liefert dir das Ergebnis

34

 

[kaoZ]

mal abgesehen das ich mich verschrieben habe ^^ es heißt natürlich column

 

[kaoZ]

Um das ganze noch etwas innovativer zu gestalten kannst du z.B der Klasse Matrix noch eine Art Identifier mitgeben z.B

public class Matrix {
	
	
	private String identifier;
	private int[][] matrix;
	
	public Matrix(String ident, int row, int column) {
		this.identifier = ident;
		matrix = new int[row][column];
	}
	
	public Matrix(int row, int column) {
		this.identifier = "";
		matrix = new int[row][column];
	}
	
	public void addToMatrix(int value, int row, int column){
		matrix[row][column] = value;
	}
	
	public int getValueAtIndex(int row, int column){
		return matrix[row][column];
	}
	
	public String getIdentifier() 		 {return this.identifier;}
	public int[][] getMatrix() 			 {return this.matrix;}
	
	public static void main(String[] args) {
		
		new MatrixTest();
	}

}

so würdest du mit der Übergabe eines Strings dann nach dem Beleg suchen können:

class MatrixMemory{
	
	ArrayList<Matrix> matrixList;
	
	public MatrixMemory() {
		matrixList = new ArrayList<>();
	}
	
	public void store(Matrix...matrizen){
		for (Matrix matrix : matrizen) {
			matrixList.add(matrix);
		}
	}
	
	public void storeAtIndex(int index, Matrix matrix){
		matrixList.add(index, matrix);
	}
	
	public Matrix loadFromIndex(int index){
		return matrixList.get(index);
	}

        // Hier die Methode zum suchen nach dem Identifier, liefert null wenn nicht vorhanden !
	
	public Matrix loadByIdentifier(String ident){
		Matrix matrix = null;
		
		for (int i = 0; i < matrixList.size(); i++) {
			if (matrixList.get(i).getIdentifier().equals(ident)) {
				matrix = matrixList.get(i);
			}
		}
		return matrix;
	}
}

Anwendung :

public MatrixTest() {
	
	Matrix m1 = new Matrix(2, 3);
	Matrix m2 = new Matrix(1, 1);
	
	Matrix m3 = new Matrix("Beleg1", 3, 3);  //<--
	m3.addToMatrix(55, 1, 1);
	
	m1.addToMatrix(12, 1, 2);
	m2.addToMatrix(22, 0, 0);
	
	MatrixMemory mem = new MatrixMemory();
	
	mem.store(m1,m2);
	mem.store(m3);

	System.out.println(mem.loadByIdentifier("Beleg1").getValueAtIndex(1,1));
	System.out.println(mem.loadFromIndex(0).getValueAtIndex(1, 2) + mem.loadFromIndex(1).getValueAtIndex(0, 0));
	}
}

Ausgabe :

55
34

 

[kaoZ]

... Persistent Speichern kenne ich nicht...

Das bedeutet dauerhaft speichern, sprich in einer Datei z.B auf deiner Festplatte, wie du es z.B von Dateien mit der endung .dat kennst

Hier spricht man in Java von Serialisierung, da es so möglich ist Objekte und deren Zustände ( Wertbelegungen ) unter anderem dauerhaft zu Speichern und zu einem späteren Zeitpunkt und sogar an anderer Stelle wieder herzustellen , z.B für Spielstände bei Games oder ähnlichem.