// 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} } };
Cool !lordofdonuts hat gesagt.:Ansammlung von Werten in einer Ansammlung von Werten als Ansammlung von Werten
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___
}
}
}
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}}};
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
int[][][] =
{ //1.dim
{ //2.dim
{ //3.dim
.....
}
}
};
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
}
}
bin 2 Stunden vor eurer Antwort gestanden. Trotzdem Danke.Java: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
Java: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 ?
{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
// 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 ?
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]);
}
}
}
}
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