# Zweidimensionales Array durch ToString ausgeben lassen



## java_jay (18. Feb 2011)

Hallo,

Ich habe eine Klasse "Matrix" geschrieben, welche durch ein zweidimensionales Array, Matrizen erzeugt.
Soweit ist das alles klar, jedoch habe ich bei der toString-Methode meine Probleme.
Bisher habe ich folgenden Code, der jedoch nicht funktioniert:

```
public String toString(double [][] matrix) {
	int n = matrix.length; //Spalten
	int m = matrix[0].length; //Zeilen
		for (int j=0; j<m; j++) {
			for (int i=0; i<n; i++) {
				return(matrix [i][j]+ " ");
			}

		}
	}
```

Wenn ich diese Code ausserhalb der Classe mit println anstelle von return schreiben, funktionert das.
Das Problem ist bei dieser Realisierung, dass Java das Return-Statment vermisst. (es wird in der For-Schleife anscheinden nicht angenommen).

So ich hoffe ich habe mich verständlich ausgedrückt 

Danke schonmal!

gruß
jay


----------



## egospezia (18. Feb 2011)

Wann willst du das return eigentlich haben und wann hast du es eingesetzt?

Überleg mal, was das println macht und warum da ein Matrix-Block rauskommt. Du brauchst auf alle Fälle einen String, in dem du all die Matrixzeilen ablegen kannst, wenn du sie ausgeben willst. Java kann nur ein Return.


----------



## java_jay (18. Feb 2011)

Ich möchte später aus einer anderen Klasse heraus Rechenoperationen mit Matrizen durchführen. Dafür möchte ich dann durch den Befehl println(matrix) die komplette Matrix ausgeben lassen.

Also alles in einen String speichern und ausgeben? Wie kann man das denn realisieren?


----------



## egospezia (18. Feb 2011)

Also die willst die unveränderte Matrix in Matrizenform über print ausgeben? 

Du kannst das in einem String machen, statt sofortiger Ausgabe weist du den Wert einer neuen Variablen zu und hängst im nächsten Schleifendurchlauf nur hinten an mit dem Tabulator für die Spalten. Mit dem Zeilenumbruch verfährst du ähnlich in der anderen For-Schleife.


----------



## xehpuk (18. Feb 2011)

Ich hab mir auch mal so ein kleines Matrizenprogramm geschrieben, da hab ichs so umgesetzt:

```
public final class Matrix {
	private final int[][] numbers;
	private final int rows;
	private final int columns;

	@Override
	public String toString() {
		final StringBuilder result = new StringBuilder();
		for (int m = 0; m < rows; ) {
			for (int n = 0; n < columns; ) {
				result.append(numbers[m][n]);
				if (++n < columns) result.append(' ');
			}
			if (++m < rows) result.append('\n');
		}
		return result.toString();
	}
}
```

Was du momentan machst: Höchstens einen einzigen Wert ausgeben. Wenn die Matrix "null-dimensioniert" ist, wird die Schleife nicht betreten, wodurch es keinen Rückgabewert gäbe. Daher das Compilergemecker.


----------



## java_jay (19. Feb 2011)

Danke schonmal für die Tipps!

Ich hab es jetzt so umgeschrieben:

```
public String toString(double [][] matrix) {
	StringBuilder matrixString = new StringBuilder();
	int n = matrix.length; 
	int m = matrix[0].length;
		for (int j=0; j<m; j++) {
			for (int i=0; i<n; i++) {
				matrixString.append(matrix [i][j]+" ");
			}
		matrixString.append('\n');
		}
		return matrixString.toString();
	}
```

Kompilieren funktioniert fehlerfrei, jedoch bekomme ich anstatt der eigentlichen Ausgabe der Matrix immer etwas in der Art hier:

 Matrix@18352d8


gruß


----------



## Gast2 (19. Feb 2011)

Falls du eine eigene Klasse Matrix hast und die toString methode überschreiben willst dann is deine Methode falsch. Die toString-Methode hat keine übergabeparameter.
Wenn du die MEthode mit nem @Override kennzeichnest dann würde der Compiler auch meckern dass es die Methode nicht gibt.


----------



## java_jay (19. Feb 2011)

Hallo Eike,

Genau das war das Problem. Ich wollte die Methode nicht überschreiben. 
Hatte ganz vergessen, dass die toString-Methode keine Übergabeparameter hat.
Jetzt läuft es! Danke (auch an die anderen Helfer)!

Gruß java_jay


----------



## Antoras (19. Feb 2011)

Alternative:

```
Arrays.deepToString(xDimArr)
```


----------



## Gast2 (19. Feb 2011)

Antoras hat gesagt.:


> Alternative:
> 
> ```
> Arrays.deepToString(xDimArr)
> ```



Da machter dann aber keine schönen Zeileumbrüche rein


----------



## eLogic (19. Feb 2011)

Warum eingentlich der Umweg auf zwei Integer Variablen?
Wieso ist denn bei dir  j und i  vertauscht muss das nicht andersrum?
return muss als letztes geschrieben werden...
Bei deinem ersten Post springt er immer mit dem Wert in matrix[0][0] als Rückgabewert raus.



```
public String toString(double [][] matrix) {
    StringBuilder matrixString = new StringBuilder();
    for (int j=0; j<matrix.length; j++) {
        for (int i=0; i<matrix[i].length; i++) {
            matrixString.append(matrix [j][i]+" ");
        }
    matrixString.append('\n');
    }
    return matrixString.toString();
}
```

Gruß  eLogic


----------



## xehpu (19. Feb 2011)

xehpuk hat gesagt.:


> Wenn die Matrix "null-dimensioniert" ist, wird die Schleife nicht betreten, wodurch es keinen Rückgabewert gäbe. Daher das Compilergemecker.



Die Meldung wird davon unabhängig ausgegeben.


```
public boolean m() {
    while (true) {
        return true;
    }
}
```
wäre es syntaktisch auch nicht korrekt.


----------



## Gast2 (19. Feb 2011)

```
public boolean m() {
    while (true) {
        return true;
    }
}
```
Doch. Die Methode lässt sich ohne probleme kompilieren. Macht natürlich nicht sonderlich viel sinn


----------



## xehpu (19. Feb 2011)

Der Compiler wegoptimiert das.


```
public boolean m() {
    int i = 5;
    while (i == 5) {
        return true;
    }
}
```
würde aber nicht mehr compilieren.


----------



## xehpuk (19. Feb 2011)

xehpu hat gesagt.:


> Die Meldung wird davon unabhängig ausgegeben.


Weswegen sonst?


----------



## xehpu (19. Feb 2011)

Weil das Statement vor der klammer kein return Statement ist.


----------



## xehpuk (19. Feb 2011)

Welches Statement vor welcher Klammer?


----------



## Gast2 (19. Feb 2011)

xehpu hat gesagt.:


> Weil das Statement vor der klammer kein return Statement ist.


Das letzte Statement muss nicht immer ein return sein...
Folgendes wäre auch gültig:

```
public static boolean m() {
		int i = 5;
	    while (i == 5) {
	        return true;
	    }
	    
	    throw new IllegalStateException("em...this should never happen...");
	}
```


----------



## xehpu (20. Feb 2011)

EikeB hat gesagt.:


> Das letzte Statement muss nicht immer ein return sein...



Ein solches Statement ist wohl auch eines der return statements. Siehe hier:



> In computer programming, a return statement causes execution to leave the current subroutine and resume at the point in the code immediately after where the subroutine was called, known as its return address.





Wlche Klammern ergeben denn sinn?


----------



## java_jay (22. Feb 2011)

@eLogik: Da hatte ich in der Tat etwas vertauscht.

Hier nochmal die (nun hoffentlich) richtige Version: (angezeigt wird es so auf jeden fall richtig)


```
public String toString() {
	StringBuilder matrixString = new StringBuilder();
		for (int i=0; i<matrix.length; i++) {
			for (int j=0; j<matrix[0].length; j++) {
				matrixString.append(this.matrix [i][j]+" ");
			}
		matrixString.append('\n');
		}
		return matrixString.toString();
	}
```


Gruß


----------



## eLogic (22. Feb 2011)

:bae::bae::bae::applaus::applaus:


```
import java.io.IOException;


public class meineHausaufgaben {

	public static void main(String[] args) throws IOException, InterruptedException {

		char a = 78;
		String eingabe = "";
		
		while(true){

			a = 78;
			eingabe = eingabe+a+" ";
			System.out.println(eingabe);
			cls();
			for(int i = 0;i<2;i++){
				eingabe = eingabe+(char)(a+1)+" ";		
				System.out.println(eingabe);
				cls();
			}
			a=66;
			eingabe = eingabe+a+" ";
			System.out.println(eingabe);
			eingabe = "";
			cls();
			System.out.println();
			cls();
		}
	}
	public static void cls() throws InterruptedException{
		Thread.sleep(300);
		for(int i = 0;i<100;i++){
			System.out.print("\n");		
		}
	}
}
```


----------



## xehpu (22. Feb 2011)

Ohne Zeichentabelle steigt man dort nicht durch 

Die Aufgaben sehen tatsächlich so aus, als wären sie HA.

Formatiere den vorletzten Code mal:


```
private int[][] matrix;

    public String toString() {
        StringBuilder matrixString = new StringBuilder();
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                matrixString.append(matrix[i][j] + " "); // this-Referenz entfernt
            }
            matrixString.append('\n');
        }
        return matrixString.toString();
    }
```

In Zeile 6 hat j immer die Werte von 0 bis matrix[0].length - 1; matrix muss aber nicht immer so sein, das alle int-Arrays die gleiche Länge haben oder doch?
Man könnt matrix_ verwenden, für die Länge der i-ten Zeile.
Muss jedes Element von matrix eine int-Array-Referenz sein oder kann auch null referenziert sein? Wenn das nicht is, muss eben vorher auf null-Elemente geprüft werden.

Könnte matrix null sein? Macht es sinn, das die Methode eine Objektmethode ist, also nicht mit static gekennzeichnet ist? Wenn matrix wesentlich die Klasse mmacht, dann wahrscheinlich schon.

Sokönnte man es auch so schreiben:


		Java:In die Zwischenablage kopieren


    private int[][] matrix;

    public static String tdats(int[][] iaa) {
        if (iaa == null) {
            return "null array";
        }

        StringBuilder b = new StringBuilder();
        for (int i = 0; i < iaa.length; i++) {
            if (iaa[i] == null) {
                b.append("null");
            } else {
                for (int j = 0; j < iaa[i].length; j++) {
                    b.append(iaa[i][j]);
                    b.append(' ');
                }
            }
            b.append('\n');
        }
        return b.toString();
    }

    public String toString() {
        return tdats(matrix);
    }

_


----------

