Methode, die eine 2 dimensionale Matrix kopiert.

[tolgatus]

Guten Abend,

Aufgabe war es, eine Methode zu schreiben, die eine beliebige zweidimensionale Matrix kopiert, die nicht unbedingt quadratisch sein muss.

Nun habe ich diese Methode:

public class MatrixKopierer {
    double[][] a, b;
    
   double[][] matrixCopy( double[][] a)
   { double[][] b = new double[a.length][a[0].length];
   for ( int i = 0; i< a.length; i= i+1 )
       for ( int j = 0; j< a[i].length; j= j+1 )
           b[i][j] = a[i][j];
   return b;
   }

Verstehe ich richtig, dass [a[0].length] statt [a.length] und in der Schleife a.length statt a.length für den Fall sind, dass keine quadratische Matrix kopiert werden soll, sondern eben eine beliebige?
Vielen Dank und sorry für die vielleicht banale Frage 🙂

MfG

 

[diggaa1984]

das ganze macht peng, wenn a[0].length kleiner als irgendein a.length ist! Denn b ist quadratisch und in dem Fall hat b nicht ausreichend Felder, wenn a.length > a[0].length

 

[maxemann96]

Wie wärs mit

public class MatrixKopierer 
{
    double[][] a, b;
    
   double[][] matrixCopy( double[][] a)
   { 
       double[][] b = a;
      return b;
   }
}

 

[Spacerat]

Mom... das ging anders...

double[][] rc = new double[in.length][];
for(int n = 0; n < rc.length; n++) {
  rc[n] = in[n].clone();
}

[EDIT]\/\/@TO: In der Realität ist maxemann96's Methode noch viel schlimmer... es ist ja nich mal 'ne Kopie, sondern ein und die selbe Instanz deiner Matrix.[/EDIT]

 

[tolgatus]

@maxemann:Auf die weise erstelle ich doch aber nur eine genauso große Matrix, es soll ja aber eine Matrix samt Zelleninhalt komplett kopiert werden.

@diggaa: Du meinst also, das der Code an sich nicht ok ist? Dachte eigentlich der wäre in Ordnung, wollte nur hinter die Bedeutung von [a[0].length] statt beide male [a.length] und in der Schleife j < a.length statt einfach j< a.length steigen.

 

[diggaa1984]

probier es aus 🙂

public class MainClass {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[][] a = { { 1, 2 }, { 4, 5, 6 } };
		int[][] r = matrixCopy(a);
	}
	
	public static int[][] matrixCopy(int[][] a) {
		int[][] b = new int[a.length][a[0].length];
		
		for (int i = 0; i < a.length; i = i + 1)
			for (int j = 0; j < a[i].length; j = j + 1)
				b[i][j] = a[i][j];
		
		return b;
	}
}

 

[diggaa1984]

@maxemann:Auf die weise erstelle ich doch aber nur eine genauso große Matrix, es soll ja aber eine Matrix samt Zelleninhalt komplett kopiert werden.

@diggaa: Du meinst also, das der Code an sich nicht ok ist? Dachte eigentlich der wäre in Ordnung, wollte nur hinter die Bedeutung von [a[0].length] statt beide male [a.length] und in der Schleife j < a.length statt einfach j< a.length steigen.

Also wenn die Matrix immer quadratisch ist, kannst du immer a.length verwenden, da Länge von Spalten und Zeilen der Matrix identisch sind.
Willst du aber eine Methode für beliebige 2-dimensionale Matrizen schreiben, so kann es passieren, dass du unterschiedlich Längen hast .. je nachdem wie du durch die Matrix läufst beziehst du dich dann auf die jeweilige Spalte oder Zeile (a.length) um das zu handhaben.

 

[AquaBall]

@maxemann:Auf die weise erstelle ich doch aber nur eine genauso große Matrix, es soll ja aber eine Matrix samt Zelleninhalt komplett kopiert werden.

@diggaa: Du meinst also, das der Code an sich nicht ok ist? Dachte eigentlich der wäre in Ordnung, wollte nur hinter die Bedeutung von [a[0].length] statt beide male [a.length] und in der Schleife j < a.length statt einfach j< a.length steigen.

Also maxemann'sche Lösung ist Blödsinn, (sorry), weil wirklich nichts kopiert wird. sondern nur ein 2. Verweis auf die selben Daten erstellt wird.

Der Code an sich ist schon richtig, wenn man davon ausgehen kann, dass die Matrix strikt rechtwinkelig (wenn auch nicht quadratisch) ist.
Es müssen also alle a[] EXAKT gleich viele Elemente (sozusagen Spalten) haben.
Wie lang a[] selbst ist ist davon unabhängig (sozusagen Zeilen).
Aber wenn du das schon sicherstellen kannst, dass mutet es auch seltsam an, dass du dein for j von a abhängig machst.

Wenn, dann solltest du davor 1x die Länge festlegen:
Im Prinzip machst du ja bei der Instanziierung von b das selbe, wenn auch sehr versteckt,
was ja genau deine Frage trifft:

die Bedeutung von [a[0].lenth]

beide male [a.length]

würde quadratisch bedeuten.
und

in der Schleife j < a[i].length

ist nicht begründbar.

j< a.length

würde aber schiefgehen.

int zeilenAnzahl=a.length;
int spaltenAnzahl=a[0].length;   // sofern STRIKT rechtwinkeleig, also alle gleich lang sind
   for ( int zeile = 0; zeile< zeilenAnzahl; zeile++)
       for ( int spalte = 0; spalte< spaltenAnzahl; spalte++ )
           b[zeile][spalte] = a[zeile][spalte];

Aber abgesehen davon, ist die Lösung von Spacerat sicher die eleganteste und sicherste.

 

[maxemann96]

Das war einer meiner genialsten Einfälle!

Spaß beiseite ihr habt natürlich recht, da war wieder einem meiner lichten Momente

[WR]
Mein erstes Posting nicht beachten, nur Murks 😉
[/WR]

Da programmiert man schon 2-3 Jahre und baut dann son Mist, schon deprimierend ;(

 

[diggaa1984]

das schreit doch nach einer persönlichen Hall of Shame oder? 😀 Glaub ich werd mir ma sowas anlegen, wenns soweit ist :lol:

 

[mla.rue]

@tolgatus
dein Algorithmus ist soweit richtig, dein Verständniss auch (nochmal gesagt: mit a.length greift man auf die "erste Dimension" zu, mit a[].length auf die zweite, mit a[][] würde man auf die dritte zugreifen etc).

Problemchen sehe ich in:
- du initialisierst a nicht, wie willst es dann einer Methode als Parameter übergeben und ein Ergebnis erwarten? Der Compiler meckert da
- i = i+1 solltest du als i++ schreiben (gleiches gilt für j)
- es gibt arrayCopy, auf dass man sich sowas sparen kann, mein Compiler meckert da jedenfalls wegen "manual array copy" bei solchem Code

 

[maxemann96]

Hab nun die Hall of Shame eröffnet:

http://www.java-forum.org/plauderecke/136757-hall-shame.html

 

[tolgatus]

@tolgatus
dein Algorithmus ist soweit richtig, dein Verständniss auch (nochmal gesagt: mit a.length greift man auf die "erste Dimension" zu, mit a[].length auf die zweite, mit a[][] würde man auf die dritte zugreifen etc).

Problemchen sehe ich in:
- du initialisierst a nicht, wie willst es dann einer Methode als Parameter übergeben und ein Ergebnis erwarten? Der Compiler meckert da
- i = i+1 solltest du als i++ schreiben (gleiches gilt für j)
- es gibt arrayCopy, auf dass man sich sowas sparen kann, mein Compiler meckert da jedenfalls wegen "manual array copy" bei solchem Code

War ja nich der ganze Code, Aufgabe war es halt, so eine Methode selbst zu schreiben, und dann ne 100x100 Matrix mit den Elementen Aij = i-j+2 zu übergeben.

Das mache ich hier:

public static void main(String[] arg)
   {   
       
       MatrixKopierer mat = new MatrixKopierer();
       double[][] neu = new double[100][100];
       for(int i=0; i < neu.length; i++)
           for(int j=0; j < neu.length; j++)
           {neu[i][j] = i - j +2;}
       double[][] ausg = mat.matrixCopy(neu);
       for(int i=0; i<ausg.length; i++)
       {System.out.println(ausg[i][i]);}
       
   }

Bekomme da keinen Compiler Fehler, jedoch kommt mir die Aufgabe schwachsinnig vor, da ja immer der Wert 2 reingeschrieben wird. j++ ist doch exakt dasselbe wie j = j + 1 oder nicht? ???:L

 

[AquaBall]

... den Elementen Aij = i-j+2 zu übergeben.
Das mache ich hier:

{neu[i][j] = i - j +2;}

Mir kommt die Aufgabe schwachsinnig vor, da ja immer der Wert 2 reingeschrieben wird.

Wie kommst du auf die Idee??
Offensichtlich gibt die

for (i ...) for (j...) { ...}

-Konstruktion manchen Leuten das Gefühl, es wäre immer

i = j

.
Das ist natürlich NICHT so!!
Wenn i = 1, dann läuft j von 1 bis ...,
danach i = 2 , j von 1 bis ...,
dann i=3 ...
Somit ergibt

i - j + 2

sehr wohl sinnvolle Werte. (So ne Art 'Diagonal-Muster').
(Nur an der Hauptachse hast du alles '2'.)

j++ ist doch exakt dasselbe wie j = j + 1 oder nicht?

Hast du recht, aber

• eleganter
• und schneller (Wenn der Compiler nicht ideal optimiert)
• und Java-mäßiger (lol).

Übrigens: plötzlich ist deine Matrix nicht nur überall gleichlang, sondern sogar doch quadratisch?!???:L

 

[Fant]

j++ ist doch exakt dasselbe wie j = j + 1 oder nicht? ???:L

Es liefert dir den gleichen Wert, aber nicht auf die gleiche Weise. ++ ist ein unärer Operator wohingegen das + dort ein binärer Operator ist. Die erste Variante ist wohl theoretisch etwas schneller. Spürbare Effekte wird das in solchen kleinen Konsolenanwendungen wohl niemals haben :>

Gruß Fant

 

[Ulic Quel-Droma]

Also bei der Matrix die du zum Testen verwendest müsste dein Code vom Anfang doch eigentlich funktionieren, da sie überall gleich lang ist. Würde sie das nicht sein, würde das hier helfen:

public class MatrixKopierer {
    
   double[][] matrixCopy( double[][] a)
   { 
   double[][] b = new double[a.length][0];//einfach mal initialisieren
   for ( int i = 0; i< a.length; i= i+1 ){
       b [i] = new double[a[i].length];
       for ( int j = 0; j< a[i].length; j= j+1 )
           b[i][j] = a[i][j];
   }
   return b;
   }
}

Glaub ich zumindest.

 

[tolgatus]

Wie kommst du auf die Idee??
Offensichtlich gibt die

for (i ...) for (j...) { ...}

-Konstruktion manchen Leuten das Gefühl, es wäre immer

i = j

.
Das ist natürlich NICHT so!!
Wenn i = 1, dann läuft j von 1 bis ...,
danach i = 2 , j von 1 bis ...,
dann i=3 ...
Somit ergibt

i - j + 2

sehr wohl sinnvolle Werte. (So ne Art 'Diagonal-Muster').
(Nur an der Hauptachse hast du alles '2'.)

Danke, werd mir das nochmal genau anschauen 🙂

Übrigens: plötzlich ist deine Matrix nicht nur überall gleichlang, sondern sogar doch quadratisch?!???:L

Ja, die zum Testen gegebene Matrix ist halt quadratisch, aber die Methode sollte auch nichtquadratische Matrizen kopieren können.

Bedanke mich bei allen, Thema wäre dann erledigt ;-)