Bonjour à tous,
je débute en Java et je me forge avec quelques exercices pour essayer d'être plus à l'aise avec ce langage.
Cependant je me retrouve confronté à un problème, et n'étant pas suffisamment à l'aise, j'ai du mal à effectuer des test pour trouver la juste écriture.

Je désire créer un tableau à trois dimensions qui comportera pour chaque dimension un nombre i, par exemple, de "cases". Je m'y prends donc de cette façon:

int tableauPixels[][][] = new int[i];

Seulement je ne suis pas sur de l'écriture, ne me faudrait-il pas plutôt écrire:

int tableauPixels[][][] = new int[i][i][i];

En effet il me semble logique que chaque dimension d'un tableau comporte autant de "cases", mais je ne possède aucune assurance de ça.

D'avance merci pour vos réponses à ce problème qui doit être bien simple pourtant

Tu n'es pas obligé d'avoir toutes les dimensions de ton tabeau égales.
En gros tu peux avoir ceci:

int tableauPixels[][][] = new int[i][j][k];

Mais si tu utilise ta première proposition elle sera rejetée par la JVM lors de l'execution
Car tu n'a pas defini la taille des autres dimensions.

Bien, donc dans mon cas il me faut utiliser la deuxième écriture.

Merci beaucoup pour l'aide! (très rapide en prime )

A noter que dans le dernier code proposé, tableauPixels.length renvoie i.
D'ailleurs il est possible de donner d'autres dimensions aux sous tableaux :

int[][][] tab = new int[4][][];
for(int n = 0 ; n < tab.length ; n++) {
	tab[n] = new int [n+5][n+1];
	System.out.println("tab[" + n + "].length : " + tab[n].length);
	System.out.println("tab[" + n + "][2].length : " + tab[n][2].length);
}

tab[0].length : 5
tab[0][2].length : 1
tab[1].length : 6
tab[1][2].length : 2
tab[2].length : 7
tab[2][2].length : 3
tab[3].length : 8
tab[3][2].length : 4

Je reviens poster par ici, j'ai hésité à créer un nouveau sujet celui ci étant marqué comme résolu, mais le problème est dans la même lignée je pense et doit survenir de ma mauvaise compréhension des mécanismes liés aux tableaux.

Après avoir créer mon tableau, je désire, le remplir grâce à une boucle avec des valeurs quelconques(je vais prendre "50" comme exemple):

//Création d'un tableau a trois dimensions
int tableau[][][] = new int[i][i][i];

for(int j=0; j<i ; j++){
tableau[0][j] = 50;
tableau[1][j] = 50;
tableau[2][j] = 50;
}

Le soucis étant que la compilation me rapporte trois erreurs identiques:

Citation : Compilateur

incompatible types
found: int
required: int[]

J'ai alors essayé d'encadrer le valeur de l'entier par des [], ou encore par des {}, mais le compilateur me renvoie à chaque fois des erreurs: "illegal start of expression".


J'avoue ne pas vraiment saisir la source de l'erreur, donc d'avance merci si quelqu'un pouvait m'éclairer

PS: si mes explications ne sont pas suffisamment claires, je peux prendre des screens de l'écran de compilation

Un tableau à deux dimensions comme on l'imagine, c'est un tableau avec un certain nombre de "cases" et chacune de ces cases contient un tableau.

Donc ce que tu fais dans ton code, tu prends le j-ème tableau du tableau 0 et tu lui affectes une valeur, or ce qu'il veut c'est un tableau et non une valeur, comme te l'indique l'erereur de compilation : int[] required (autrement dit tableau d'entiers requis).
Pour remplir entièrement un tableau 3D il suffit de remplir les cases une par une :

for(int x = 0 ; x < i ; x++) {
  for(int y = 0 ; y < i ; y++) {
    for(int z = 0 ; z < i ; z++) {
      tableau[x][y][z] = 50;
    }
  }
}

Déroule la boucle pour comprendre comment ça marche.

Hum, je crois comprendre mon erreur.
En fait je pensais d'après le tuto parlant des tableaux, et surtout d'après cette image:

Que peu importe la dimension du tableau(2, 3, 37, etc...), pour pouvoir assigner une valeur il fallait faire ainsi:

nomDuTableau[x][y] = nouvelleValeur;

Avec x: la dimension sur laquelle on souhaite travailler(la première dimension correspondant à 0, la deuxième à 1, ...)
Et y: la case en question

Or si je comprends bien ton post, ce n'est pas le cas, mais je ne comprends pas totalement pour autant comment accéder à certaines valeurs.
Par exemple dans un tableau à trois dimensions, comportant chacune 10 cases, si je veux accéder à la case 5 de la troisième dimension, quelle sera l'écriture exacte?

Pour ma part j'imaginais cette écriture:

tableau[2][5]

EDIT: en fait je relis ton code depuis tout à l'heure, il serait effectivement excelent pour remplir toutes les "cases" avec une valeur identique. Le soucis c'est que je désire attribuer à chaque "case" une valeur particulière . Donc pour se faire il me faut pouvoir accéder à une case en particulier d'une dimension particulière, ce que je réussi pas à faire
En tout cas merci pour ta réponse.

Je vais essayer de t'expliquer simplement.
Imagine les tableaux comme des poupées russes, ou des tiroirs emboîtés quoi.
Avec l'instruction suivante int[][][] tableau = new int[2][4][3]; , nous avons créé une commode à deux tiroirs, chacun de ces tiroirs contenant 4 sous-tiroirs, ces derniers contenant chacun 3 tiroirs.

Une autre représentation possible, mais moins pertinente, est celle d'une fonction mathématique de 3 variables. A chaque triplet est associé une valeur : la valeur que l'on met dans notre tableau.

Pour comprendre ton soucis, garde la première représentation.
Si on a l'instruction int[][][] tableau = new int[10][10][10]; , tu dis vouloir accéder au 5ème sous-sous-tiroir. Oui d'accord mais lequel ? Car il y'en a <math>\(10\times10=100\)</math> de 5ème sous-sous-tiroir !

Si tu souhaites remplacer ton 2ème sous-tiroir, il va falloir y mettre un autre sous-tiroir qui contienne lui aussi 10 sous-sous tiroirs.

Tu peux aussi te représenter ça sous la forme d'arbres...

[EDIT]Pour remplir ton tableau avec des valeurs particulières, y'a pas de miracles faut tout rentrer à la main. A moins qu'une fonction quelconque relie tes nombres, là tu pourrais automatiser la chose...

En réalité, tu confonds "nombre de dimensions" et "taille de la première dimension".

Quand tu parles de "Tableau à 3 Dimensions", tu penses en faire à un tableau 2D dont la première dimension est 3 :

{
   {A, B, C},
   {D, E, F},
   {G, H, I}
}

Ca, c'est un tableau à *2* dimensions. Dans un tableau à 2 Dimensions, A est une valeur. Dans un tableau à 3 dimensions, A est un tableau. Dans un tableau à 4 dimensions, A est un tableau de tableaux (= un tableau 2D). etc.

Autrement dit : un tableau 2D est un carré ; un tableau 3D est un cube. Pour accéder à une valeur d'un tableau, il te faut la ligne et la colonne : tableau[ligne][colonne]. Pour accéder à une case d'un tableau 3D, il te faut le x, le y et le z (Ligne, colonne... Hauteur ?)

Donc, un tableau 2D 3x3 se déclare comme ça :

int[][] tableau = new int[3][3];

Et on accède aux valeurs comme ça :

tableau[1][2] // = F (2ème Ligne, 3ème colonne, avec des index qui commencent à 0).

Dans le cas d'un tableau 3D, F est un tableau, et non pas un nombre. Dans ce cas, l'appel :

int[] tab = tableau[1][2] //retourne un tableau (tab). Pour accéder à la n-ème valeur de ce tableau, il faut ensuite faire :

int val = tab[n]

Ca peut être fait en une seule ligne :

int val = tableau[1][2][n]

Bref, ne confonds pas "nombre de dimensions" (Ton tableau est une ligne, un carré, un cube, ...) et "nombre de cases d'une dimension" (Ta ligne contient x cases, ton carré contient y lignes, ton cube contient z carrés...)

Oui je m'en suis rendu compte avec la dernière explication de Elmh(et l'exemple des commodes).
Je pensais en effet créer un tableau à 3 dimensions chacune comportant i "cases", alors qu'en fait il me faut créer un tableau à deux dimension, la première dimension étant de "i", et la seconde étant "3".

Quoi qu'il en soit merci à tout deux pour vos explications, je n'avais vraiment pas compris le système des dimensions, et c'est désormais chose faite