Arry definieren in 3 Dim.

[tomovic]

hallo,
ich muss ein 3 Dimension Arry erstellen und zugleich Werte zuweisen.

eine Dimension war kein Problem.

float[] pos_xyz= {1,2,3,4,5,6,7,8,9,0};

Meine Idee:

float[][][] pos_xyz= // und weiter?

 

[lordofdonuts]

Hallo Tomovic,

bitte:

        // 1 dim
        float[] f = new float[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
        
        // 2 dim
        float[][] f2 = new float[][]{ {1,2}, {3,4}, {5,6}, {7,8}, {9,0}};
        
        // 3 dim
        float[][][] f3 = new float[][][]{ { {1,2}, {3,4} }, { {5,6}, {7,8}  }, { {9,0} } };

1-dimensionales Array:
ganz normale Ansammlung von Werten

2-dimensionales Array:
Ansammlung von Werten als Ansammlung von Werten

3-dimensionales Array:
Ansammlung von Werten in einer Ansammlung von Werten als Ansammlung von Werten

Was willst du eigentlich durch dieses Konstrukt erreichen?

 

[tomovic]

thx,
ok, ich steig da nicht richtig durch:
Woher weis ich ob 5 zur ersten Dim. oder zur 2ten Dim. gehört?
[0][0] = 1;
[0][1] = 2;
[0][2] = 3;
[1][0] = 4;

entspricht:
float[][] f2 = new float[][]{ {1,2,3}, {4}}

geht das so?

 

[thecain]

ja

 

[Bug Fisher]

Ansammlung von Werten in einer Ansammlung von Werten als Ansammlung von Werten

Cool 🙂 !

@tomovic: Dass das Array nicht "rechtwinklig", also nicht in jeder Dimension gleich "tief" ist, ist ein feature von Java (C# erlaubt das z.B. auch); Eigentlich ist es ein (inhärenter) Hinweis darauf, dass der Platz auf dem heap statt auf dem stack besorgt wird (compile-time vs run-time) Man spricht von jagged-arrays !

In Java ist es easy:

final int[][][] values = {{{1}}, {{2, 3}}, {{4, 5}}, {{6, 7, 8}}};
for(int[][] v_ : values) {
    for(int [] v__ : v_) {
        for(int v___ : v__) {
        //u got it in v___
        }
    }
}

 

[tomovic]

thx all,

float[][][] daten =  {{{1, 1, 1},{1, 1, 1},{1, 1, 1},{1, 1, 1},{1, 1, 1},{1, 1, 1},{1, 1, 1},{1, 1, 1},{1, 1, 1},{1, 1, 1},{1, 1, 1},{1, 1, 1},{1, 1, 1},{1, 1, 1},{1, 1, 1},{1, 1, 1}}};

daten[a][c]

b kann ich bis 8 füllen ohne Probleme das reicht mir auch eigentlich.
wenn ich a die Zahl 1 zuweise stützt mein Prog ab.
Bei c bekomme ich bei 10 Probleme

a = max 30
b = max 10
c = max 20

 

[Joose]

b kann ich bis 8 füllen ohne Probleme das reicht mir auch eigentlich.
wenn ich a die Zahl 1 zuweise stützt mein Prog ab.
Bei c bekomme ich bei 10 Probleme

Deine Struktur ist falsch initialisiert! Kontrolliere die Klammern und füge logische Zeilenumbrüche ein damit es übersichtlicher wird.

Generell: Wenn es sich vermeiden lässt solltest du statt einem 3d-Array lieber eine eigene Klasse oder ein Tuple verwenden um diese in einer Struktur zu verpacken.

 

[kaoZ]

int[][][] = 
{	//1.dim
	{	//2.dim
		{	//3.dim
			.....
		}
	}
};

Du befüllst letzten endes nur die 3 Dimension mit Werten, die 1 und 2 Dimension gibt ja nur an wie viele Informationen du wiederum in ihr hinterlegen kannst.

Sprich

public class Foo{

	public static void main(String[] args){
		

		int[][][] arr =
			{
				{
					{1,2,3},
					{2,4,5}
				}
			};
		
		
		System.out.println(arr[0][0][1]); 	//2
		System.out.println(arr[0][1][2]);	//5
		
	}
}

PS : Warum ist eigentlich die Formatierung seit dem Update so grausam.... die Whitespaces sind ja schrecklich ^^ fällt das nur mir auf wenn ich was paste, oder hast das schon wer gemeldet ?

 

[tomovic]

int[][][] = 
{	//1.dim
	{	//2.dim
		{	//3.dim
			.....
		}
	}
};

Du befüllst letzten endes nur die 3 Dimension mit Werten, die 1 und 2 Dimension gibt ja nur an wie viele Informationen du wiederum in ihr hinterlegen kannst.

Sprich

public class Foo{

	public static void main(String[] args){
		

		int[][][] arr =
			{
				{
					{1,2,3},
					{2,4,5}
				}
			};
		
		
		System.out.println(arr[0][0][1]); 	//2
		System.out.println(arr[0][1][2]);	//5
		
	}
}

PS : Warum ist eigentlich die Formatierung seit dem Update so grausam.... die Whitespaces sind ja schrecklich ^^ fällt das nur mir auf wenn ich was paste, oder hast das schon wer gemeldet ?

bin 2 Stunden vor eurer Antwort gestanden. Trotzdem Danke.

{1,2,3} // ok, ich befülle den Array
[0][0][0] //-> 1
[0][0][1] //-> 2
[0][1][0] //-> 3

stimmt das so?

Wenn ich aber zusätzlich...
{2,4,5}...nutze, dann überschreibe ich doch 1,2,3

Wenn ich später z.B. [11][12][13] nutzen will muss ich ja insgesammt über 1000 Dummy in die Klammer setzen ?

 

[Joose]

{1,2,3} // ok, ich befülle den Array
[0][0][0] //-> 1
[0][0][1] //-> 2
[0][1][0] //-> 3

stimmt das so?
Wenn ich aber zusätzlich...
{2,4,5}...nutze, dann überschreibe ich doch 1,2,3

Nein.
Ich würde vorschlagen übst vorerst mal mit 2dimensionalen Arrays! Wenn du diese verstanden hast kannst du dich an 3dim machen.

Es wurde oben schon erklärt:

// 1 dim
float[] f = new float[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
 
System.out.println(f1[0]); //1
System.out.println(f1[3]); //4

// 2 dim
float[][] f2 = new float[][]{ 
    {1,2}, 
    {3,4}, 
    {5,6}, 
    {7,8}, 
    {9,0}
};

System.out.println(f2[0][0]); //1
System.out.println(f2[0][1]); //2
System.out.println(f2[2][0]); //5
System.out.println(f2[4][1]); //0
 
// 3 dim
float[][][] f3 = new float[][][]{ 
   { 
      {1,2}, 
      {3,4} 
   }, 
   { 
      {5,6}, 
      {7,8} 
   }, 
   { 
       {9,0} 
   } 
};

System.out.println(f3[0][0][0]); //1
System.out.println(f3[0][0][1]); //2
System.out.println(f3[0][1][0]); //3
System.out.println(f3[0][1][1]); //4
System.out.println(f3[1][0][1]); //6
System.out.println(f3[1][1][0]); //7
System.out.println(f3[2][0][0]); //9

Wenn ich später z.B. [11][12][13] nutzen will muss ich ja insgesammt über 1000 Dummy in die Klammer setzen ?

Deswegen sollten solche Strukturen entweder eingelesen werden (von der Konsole, Datei, Datenbank, ....) oder wie weiter oben schon gesagt setzt du auf eigene Klassen welche etwas OOP in dein Programm bringen.

 

[Maskin]

Vielleicht hilft dir das hier ein wenig, aber wie Joose bereits sagte, fang zuerst mal mit den 2d Arrays an.

public static void main(String[] args) {


		int[][][] arr =
			{ //3 Elemente
				{ //4 Elemente
					{1,2,3}, // 3 Elemente
					{4,5,6},
					{7,8,9},
					{10,11,12} 
				},
				{// 5 Elemente
					{1,2,3},
					{2,4,5},
					{3,7,8},
					{23,27,28},
					{4,9,10}
				},
				{
					{1,2,3},
					{2,4,5},
					{1,2,3},
					{2,4,5,4}// 4 Elemente
				}
			};
		
	    
		System.out.println("Größe 1 Dim für das 1 Element: " + arr.length);
		System.out.println("Größe 2 Dim für das 1 Element: " + arr[0].length);
		System.out.println("Größe 3 Dim für das 1 Element: " + arr[0][0].length);
		//Die Größe der einzelnen Ebenen kann sich hier unterscheiden
		
                for(int i=0; i<arr.length; i++) {
			for(int j=0; j<arr[i].length; j++){
				for (int k=0; k<arr[i][j].length; k++){
			
					System.out.println("i: " + i + "/ j: " + j + " / k: " + k + " ---> value: " + arr[i][j][k]);
				
				}
				
			}
		}


	}

Und hier die Ausgabe der for- Schleifen

i: 0/ j: 0 / k: 0 ---> value: 1
i: 0/ j: 0 / k: 1 ---> value: 2
i: 0/ j: 0 / k: 2 ---> value: 3
i: 0/ j: 1 / k: 0 ---> value: 4
i: 0/ j: 1 / k: 1 ---> value: 5
i: 0/ j: 1 / k: 2 ---> value: 6
i: 0/ j: 2 / k: 0 ---> value: 7
i: 0/ j: 2 / k: 1 ---> value: 8
i: 0/ j: 2 / k: 2 ---> value: 9
i: 0/ j: 3 / k: 0 ---> value: 10
i: 0/ j: 3 / k: 1 ---> value: 11
i: 0/ j: 3 / k: 2 ---> value: 12
i: 1/ j: 0 / k: 0 ---> value: 1
i: 1/ j: 0 / k: 1 ---> value: 2
i: 1/ j: 0 / k: 2 ---> value: 3
i: 1/ j: 1 / k: 0 ---> value: 2
i: 1/ j: 1 / k: 1 ---> value: 4
i: 1/ j: 1 / k: 2 ---> value: 5
i: 1/ j: 2 / k: 0 ---> value: 3
i: 1/ j: 2 / k: 1 ---> value: 7
i: 1/ j: 2 / k: 2 ---> value: 8
i: 1/ j: 3 / k: 0 ---> value: 23
i: 1/ j: 3 / k: 1 ---> value: 27
i: 1/ j: 3 / k: 2 ---> value: 28
i: 1/ j: 4 / k: 0 ---> value: 4
i: 1/ j: 4 / k: 1 ---> value: 9
i: 1/ j: 4 / k: 2 ---> value: 10
i: 2/ j: 0 / k: 0 ---> value: 1
i: 2/ j: 0 / k: 1 ---> value: 2
i: 2/ j: 0 / k: 2 ---> value: 3
i: 2/ j: 1 / k: 0 ---> value: 2
i: 2/ j: 1 / k: 1 ---> value: 4
i: 2/ j: 1 / k: 2 ---> value: 5
i: 2/ j: 2 / k: 0 ---> value: 1
i: 2/ j: 2 / k: 1 ---> value: 2
i: 2/ j: 2 / k: 2 ---> value: 3
i: 2/ j: 3 / k: 0 ---> value: 2
i: 2/ j: 3 / k: 1 ---> value: 4
i: 2/ j: 3 / k: 2 ---> value: 5
i: 2/ j: 3 / k: 3 ---> value: 4

 

[kaoZ]

Ich versuche immer gerne es auf irgendetwas sinnbildliches zu Übertragen , bei
2-Dim Arrays wäre dies z.B ein Schrank mit Schubladen, bei einem 3-Dim Array hätten die Schubladen dann auch noch Fächer.

So konnte ich mir Stück für Stück den ganzen firlefanz mit den Mehrdimensionalen Arrays bei bringen, ein Mehrdimensionales Array ist letzten endes nichts anderes als :

Ein Array , welches aus weiteren Arrays besteht.

1- Dimensional = Schubladen

2- Dimensional = Schrank mit Schubladen

3- Dimensional = Schrank mit Schubladen die wiederum in einzelne Fächer unterteilt sind.

Also mir das anfangs eigentlich ganz gut weitergeholfen 😉

Array bedeutet ja nun auch nichts anderes als "Feld", und ein Mehrdimensionale Array

ist eben ein Feld , welches sich aus weiteren Feldern zusammensetzt 🙂

 

[tomovic]

thx all,
es ist einfach, aber erstmal muss man die Logig in den Kopf bekommen.
Habs verstanden.
vielen vielen dank.