2 dimensionale Arrays

[Cjava]

Hallo!

Bin neu hier, und hab auc mein erste kleines Problemchen, mit dem ich euch belästigen will 😳

Hab hier was programmiert, was mir den Inhalt eines 2 dimensionalen Arrays anzeigen soll. Der Compiler meckert nicht, aber bei der Ausführung gibts nen Problem.

class zweiDArray
        {
            public static void main(String[] args)
            {
                int[][]field = new int[2][]; // Ein zweidimensionales Array wird erzeugt.
                field[0] = new int[4];         // Das erste dieser Arrays soll aus 4 Elementene, vom Typ int, bestehen.
                
                field[0][0] = 23;
                field[1][2] = 18;
                field[0][2] = 42;
                field[1][1] = field[0][0] + field[1][2];
                
                for (int i = 0; i < field.length; i++)
                
                    for (int j = 0; j < field[i].length; j++)
                    System.out.println(field[i][j] + "");
                
                
                }
             }

 

[0x7F800000]

1) Blöcke lieber Klammern, auch wenn da nur eine anweisung folgt
2) [noparse]

[/noparse] tags verwenden
3) Genaue Problembeschreibung!!

Der Compiler meckert nicht, aber bei der Ausführung gibts nen Problem.

Was für ein...? Immer alle exceptions/errors/unerwartetes Verhalten genau beschreiben. Hier sagt mir meine Kristallkugel aber, dass du eher sowas willst:

class zweiDArray {
    public static void main(String[] args) {
        int[][] field = new int[2][]; // Ein zweidimensionales Array wird
                                        // erzeugt.
        field[0] = new int[4]; // Das erste dieser Arrays soll aus 4 Elementene,
                                // vom Typ int, bestehen.

        field[0][0] = 23;
        field[1][2] = 18;
        field[0][2] = 42;
        field[1][1] = field[0][0] + field[1][2];

        for (int i = 0; i < field.length; i++) {
            for (int j = 0; j < field[i].length; j++) {
                System.out.print(field[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

edit [@Mods]: so, mit dem standard-editor geht's wesentlich besser, ich kann hier doch noch was hinzufügen, ich bleibe einfach dabei^^ 😉

 

[0x7F800000]

*grrr* wegen den verdammten tags werde ich mich nochmal beschweren :autsch:

Ich wollte noch was hinzufügen: unterwegs müsste es eine NullPointerexception geben, weil du auf den zweiten "unterarray" zugreifst, obwohl dieser nirgends definiert wird.

 

[Spacerat]

Irgenwie vermisse ich ne Zeile...[highlight=java]field[1] = new int[laenge];[/highlight]Würde bedeuten, du bekommst bei der Ausführung 'ne NPE (NullPointerException).

 

[dvid85]

fürs nächste mal: du müsstest das problem, dass es gibt schon erklären. wies aus sieht hast du eine Nullpointer-exception, oder?

du hast fileld[1] nicht konstruiert

also du brauchst noch sowas field[1] = new int[4];

tipp:

man kann ein array auch so konstruieren:

int[] array = new int[]{1,2,1,4,2}
das ist dann automatisch ein int[5] mit den o.g. einträgen.

im 2d fall gehts analog
int[][] mat = new int[][]{ {1,2,2}, {1,2,5} }
ist dann ein int[2][2]
EDIT: sorry, ein int[2][3]

 

[hdi]

Vllt nochmal genauer erklärt:

int a = field[x][y];

macht eigentlich folgendes:

int[] temp = field[x];
int a = temp[y];

Jetzt sollte dir also klar sein warum du eine NPE in Zeile 9 (theoretisch auch in Zeile 11) bekommst. Du versucht auf ein Fach eines Arrays zuzugreifen, dass es gar nicht gibt.

Ansonsten, wie ich finde, erstaunlich schöner Code für eine Forums-Jungfrau 😉 Vorallem die Schleife gefällt (length-Nutzung).

Nur eine klitzekleine Kleinigkeit: Klassen-Namen schreibt man für gewöhnlich gross. Also "ZweiDArray" wäre besser. Bei den Variablen haste es ja richtig gemacht: Die schreibt man nämlich klein.

mfg

 

[UdoKessler]

Hi, bin auch Anfänger 🙂

..aber vielleicht kann ich gerade deshalb gut erklären, was
Du missverstanden hast.

Du bekommst eine NullPointerException, was bedeutet, daß Du auf
etwas zugreifen willst, was nicht initialisiert ist.

..
...

field[0] = new int[4]; //Hier initialisierst Du nur(!) die erste Zeile "0".

field[0][0] = 23; // *
field[1][2] = 18; //(2) //..und hier versuchst Du auf Zeile "1" zuzugreifen.
...
..

Bis (*) ist alles korrekt.
Dann versuchst Du auf Elemente zuzugreifen, welche nicht existieren.

Dein Array hat in dem Moment nur 1 Zeile mit 4 Elementen. Die restlichen
Zeilen existieren noch gar nicht, also kannst Du nicht drauf zugreifen.


(edit)

So funktioniert es:

class ZweiDArray {
    public static void main(String[] args) {
        int[][] field = new int[2][]; // Ein zweidimensionales Array wird
                                        // erzeugt.
        field[0] = new int[4]; // Das erste dieser Arrays soll aus 4 Elementene,
        field[1] = new int[4]; // neu


        field[0][0] = 23;
        field[1][2] = 18;
        field[0][2] = 42;
        field[1][1] = field[0][0] + field[1][2];

        for (int i = 0; i < field.length; i++)

            for (int j = 0; j < field[i].length; j++)
                System.out.println(field[i][j] + "");

    }
}

Gruß
Udo

 

[Cjava]

ahhhhhh!!! Jetzt ist mir ein Licht aufgegangen. Vielen Dank an alle, für die schnellen und präzisen Antworten! 🙂

 

[0x7F800000]

<spam>

Vielen Dank an alle, für die schnellen und präzisen Antworten! 🙂

...sagte Cjava nach 15 Stunden :lol:
</spam>

 

[Cjava]

Hab gestern nur noch kurz reingeguckt, nach dem nach 2 Minuten die ersten Antworten kamen. War aber schon zu spät für mich, als dass ich mich damit noch richtig beschäftigt hätte ^^

 

[Cjava]

😀 so, eine Frage habe ich jetzt noch, wie kann ich dieses Array, sortiert mit java.util.Arrays.sort(field) ausgeben?

class zweiDArray
        {
            public static void main(String[] args)
            {
                int[][]field = new int[2][]; // Ein zweidimensionales Array wird erzeugt.
                field[0] = new int[4];         // Das erste dieser Arrays soll aus 4 Elementene, vom Typ int, bestehen.
                field[1] = new int[4];         // Das zweiter Array wird initialisiert. Ganz wichtig!
                
                // Wertzuwisung der Felder:
                
                field[0][0] = 23;            
                field[1][2] = 18;
                field[0][2] = 42;
                field[1][1] = field[0][0] + field[1][2];
                
                for (int i = 0; i < field.length; i++)    // Mit einer For-Schleife werden alle Inhalte angezeigt.
                
                    for (int j = 0; j < field[i].length; j++)
                    System.out.println(field[i][j] + "");
                
                
                java.util.Arrays.sort(field);
                
                
                
                
                }
             }

 

[0x7F800000]

Das mit java-tags hast du irgendwie überlesen oder wie... :noe:

java.util.Arrays.sort(field);

Was soll das sein?

[Monomordnungen kennt java keine, und selbst wenn, müsste man hier eine spezifizieren... Wenn dir das überhaupt was sagt, was ich schwer bezweifle 😉 ]

 

[Cjava]

was genau meinst du mit java-tags? Soll ich bei dem Anweisungsblock für den Ausgabe Klammern noch setzen?

java.util.Arrays.sort(field) = Elemente des Arrays entsprechend den Inhalten aufsteigend sortieren.

Beispiel:

public static void main(String[] args)
{
int[] someNumbers = {11, 23, 4, 17, 6};
java.util.Arrays.sort(someNumbers);

for (int value : someNumbers)
System.out.println(value);
String s = java.util.Arrays.toString(someNumbers);
System.out.println(s);
}

Das ist aber nur für ein eindimensionales Array, ich aber möchte, mein Programm mit dieser Methode ergänzen, was aber ein 2d-Array hat.

 

[0x7F800000]

was genau meinst du mit java-tags?

Fällt dir denn kein Unterschied zwischen deinem jetzigen beitrag, und dem edit von L-ectron-X auf? :autsch:

java.util.Arrays.sort(field)

Das funktioniert nur bei primitiven datentypen (die im wesentlichen teilmengen der geordneten reellen zahlen sind) und für Objekte, die Comparable implementieren.
Das tuen die Arrays nicht. Es gibt einfach keine natürliche ordnung für Arrays.

Daher musst du dir einen eigenen Comparator für Arrays schreiben:
Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 12.4 Vergleichen von Objekten
und folgende methode aufrufen:
http://java.sun.com/j2se/1.4.2/docs/api/java/util/Arrays.html#sort(java.lang.Object[],%20java.util.Comparator)

Sinnvoll definierte totale Ordnungen auf der menge der Tupel aus natürlichen Zahlen werden meist unter dem begriff:
Monomial order - Wikipedia, the free encyclopedia
zusammengefasst, aber du wirst wohl bereits irgendeine idee haben, wie du diese tupel sortieren willst... ???:L

 

[Cjava]

nein, sags mir bitte.

 

[hdi]

Java-Tags kriegst du indem du

1) Nicht den Schnell-Antwort Button verwendest sondern oben links auf "Antworten" klickst
2) im Editor dann deinen Code markierst und auf das Java-Symbol klickst (die Kaffeetasse), das du dann oben in der Leiste sehen wirst.

 

[Spacerat]

@TS: Wie? Keine Idee? Oder ging es dabei um die Tags? WDAS... some dirty code[highlight=java]int[][] a = new int[2][];
a[0] = new int[4];
a[1] = new int[4];

for(int n = 0; n < 2; n++) {
for(int m = 0; m < 4; m++) {
a[n][m] = (int) (Math.random() * (double) Integer.MAX_VALUE);
}
Arrays.sort(a[n]);
}

Arrays.sort(a, new Comparator<int[]>() {
public int compare(int[] o1, int[] o2) {
int len = Math.min(o1.length, o2.length);
int cnt = 0;
while(cnt < len) {
if(o1[cnt] < o2[cnt]) return -1;
if(o1[cnt] > o2[cnt]) return 1;
cnt++;
}
return 0;
}
});[/highlight]

 

[0x7F800000]

Öhm, Spacerat, was hast du denn da mit der for-schleife gemacht? ???:L
Außerdem kann es bei unterschiedlich langen Arrays ziemlich schnell schiefgehen: das ist keine totalordnung. [1,2,3,4,5] und [1] ergeben beim vergleich 0, obwohl sie ungleich sind 😉

(und jetzt fang bitte nicht dasselbe an, wie bei dem Vertrag für HashCode 😀 )

 

[Spacerat]

Wieso? stimmt was nicht? Soll einfach nur die beiden Arrays mit Zufallszahlen füllen. Bei mir klappts prima...:bahnhof:
@Edit: Ok beim 2. hast du durchaus recht. Aber steht ja drüber "some dirty code"

 

[0x7F800000]

Wieso? stimmt was nicht? Soll einfach nur die beiden Arrays mit Zufallszahlen füllen. Bei mir klappts prima...:bahnhof:

oh, sorry wegen der verwirrung, ich meinte die merkwürdige for-schleife im comparator, die rein optisch irgendwie eher nach while aussieht 😉

 

[Spacerat]

[highlight=java]int[][] a = new int[2][];
a[0] = new int[4];
a[1] = new int[4];

for(int n = 0; n < 2; n++) {
for(int m = 0; m < 4; m++) {
a[n][m] = (int) (Math.random() * (double) Integer.MAX_VALUE);
}
Arrays.sort(a[n]);
}

Arrays.sort(a, new Comparator<int[]>() {
public int compare(int[] o1, int[] o2) {
int len = Math.min(o1.length, o2.length);
int cnt = 0;
int rc = 0;
while(rc == 0 && cnt < len) {
rc = o1[cnt] - o2[cnt];
cnt++;
}
if(rc == 0 && o1.length != o2.length) rc = (o1.length < o2.length)? -1 : 1;
return rc;
}
});[/highlight]"Jetz bessäää, jetz bessäää? Wursblinkäää son humbuuug"... Nee mal ernsthaft... kann dir sonst nicht folgen...

 

[0x7F800000]

kA... in deinem code sind mir zuviele hilfsvariablen...
sowas wie Math.min(o1.length,o2.length) braucht man imho nicht in eine temporäre variable abzuspeichern, weil das beides finale variablen sind, und der compiler das hoffentlich wegoptimiert, weil er sieht, dass die arrays dieselben bleiben (das hoffe ich zumindest, aber du weißt ja, mit der performance in java ist das so eine sache: der compiler optimiert die merkwürdigsten stellen weg...)

	public static String array2DToString(int[][] a){
		StringBuilder b=new StringBuilder();
		for (int n = 0; n < a.length; n++) {
			for (int m = 0; m < a[n].length; m++) {
				b.append(a[n][m]+"\t");
			}
			b.append("\n");
		}
		return b.toString();
	}
	
	public static void main(String... _) {
		int[][] a = new int[20][5];

		java.util.Random random = new java.util.Random();

		for (int n = 0; n < a.length; n++) {
			for (int m = 0; m < a[n].length; m++) {
				a[n][m] = random.nextInt(10);
			}
		}
		
		System.out.println("Array:");
		System.out.println(array2DToString(a));
		
		Arrays.sort(a, new Comparator<int[]>() {
			public int compare(int[] o1, int[] o2) {
				int rc;
				for (int cnt = 0; cnt < Math.min(o1.length, o2.length); cnt++) {
					if ((rc = o1[cnt] - o2[cnt]) != 0) {
						return rc;
					}
				}
				return o1.length - o2.length;
			}
		});

		System.out.println("Lexikographisch sortiert:");
		System.out.println(array2DToString(a));
	}

Was ich mit der merkwürdig aufegschriebenen for schleife gemeint habe, war folgende konstruktion:

int cnt=0;
while(cnt<len){
   ...
   cnt++;
}

...sowas ist eben eine "klassische for schleife" nur aus irgendeinem grund hast du sie als while hingeschrieben... ???:L

 

[Spacerat]

Ach so... Ist 'ne Angewohnheit von mir, wenn ich Schleifen "unkonventionell" verlasse. d.H. wenn der Schleifenzähler nicht unbedingt bis zum Ende zählt, verwende ich "while" statt "for".

 

[0x7F800000]

Ach so... Ist 'ne Angewohnheit von mir, wenn ich Schleifen "unkonventionell" verlasse. d.H. wenn der Schleifenzähler nicht unbedingt bis zum Ende zählt, verwende ich "while" statt "for".

Achso. Nach dem Motto: "Achtung, bei while jedes mal gehirn einschalten und neudenken!"
Okay, ist eine durchaus sinnvolle Angewohnheit.
Ich glaube aber, dass es nichts für mich ist, da in meinem code sonst kaum noch for schleifen übrigbleiben würden 😉