Question Comment déclarer et initialiser un tableau en Java?


Comment déclarer et initialiser un tableau en Java?


1613
2017-07-29 14:22


origine


Réponses:


Vous pouvez utiliser la déclaration de tableau ou le littéral de tableau (mais seulement lorsque vous déclarez et modifiez la variable immédiatement, les littéraux de tableau ne peuvent pas être utilisés pour réaffecter un tableau).

Pour les types primitifs:

int[] myIntArray = new int[3];
int[] myIntArray = {1,2,3};
int[] myIntArray = new int[]{1,2,3};

Pour les cours, par exemple String, c'est le même:

String[] myStringArray = new String[3];
String[] myStringArray = {"a","b","c"};
String[] myStringArray = new String[]{"a","b","c"};

La troisième méthode d'initialisation est utile lorsque vous déclarez le tableau en premier, puis l'initialisez. Le casting est nécessaire ici.

String[] myStringArray;
myStringArray = new String[]{"a","b","c"};

2188
2017-07-09 21:59



Il y a deux types de tableau.
 

Un réseau dimensionnel

Syntaxe pour les valeurs par défaut:

int[] num = new int[5];

Ou (moins préféré)

int num[] = new int[5];

Syntaxe avec les valeurs données (initialisation de variable / champ):

int[] num = {1,2,3,4,5};

Ou (moins préféré)

int num[] = {1, 2, 3, 4, 5};

Note: Pour plus de commodité, int [] num est préférable car il indique clairement que vous parlez ici de tableau. Sinon, pas de différence. Pas du tout.

Tableau multidimensionnel

Déclaration

int[][] num = new int[5][2];

Ou

int num[][] = new int[5][2];

Ou

int[] num[] = new int[5][2];

Initialisation

 num[0][0]=1;
 num[0][1]=2;
 num[1][0]=1;
 num[1][1]=2;
 num[2][0]=1;
 num[2][1]=2;
 num[3][0]=1;
 num[3][1]=2;
 num[4][0]=1;
 num[4][1]=2;

Ou

 int[][] num={ {1,2}, {1,2}, {1,2}, {1,2}, {1,2} };

Ragged Array (ou tableau non rectangulaire)

 int[][] num = new int[5][];
 num[0] = new int[1];
 num[1] = new int[5];
 num[2] = new int[2];
 num[3] = new int[3];

Nous définissons ici des colonnes explicitement.
Autrement: 

int[][] num={ {1}, {1,2}, {1,2,3,4,5}, {1,2}, {1,2,3} };

Pour accéder:

for (int i=0; i<(num.length); i++ ) {
    for (int j=0;j<num[i].length;j++)
        System.out.println(num[i][j]);
}

Alternativement:

for (int[] a : num) {
  for (int i : a) {
    System.out.println(i);
  }
}

Les tableaux irréguliers sont des tableaux multidimensionnels.
Pour plus d'explications, voir le tableau multidimensionnel à les tutoriels Java officiels


220
2017-07-29 14:29



Type[] variableName = new Type[capacity];

Type[] variableName = {comma-delimited values};



Type variableName[] = new Type[capacity]; 

Type variableName[] = {comma-delimited values};

est également valide, mais je préfère les parenthèses après le type, car il est plus facile de voir que le type de la variable est en réalité un tableau.


116
2017-07-29 14:28



Il existe plusieurs façons de déclarer un tableau en Java:

float floatArray[]; // Initialize later
int[] integerArray = new int[10];
String[] array = new String[] {"a", "b"};

Vous pouvez trouver plus d'informations dans Tutoriel Sun site et le JavaDoc.


32
2017-07-29 14:29



Je trouve qu'il est utile de comprendre chaque partie:

Type[] name = new Type[5];

Type[] est le type du variable appelé nom ("nom" est appelé le identifiant). Le "type" littéral est le type de base, et les parenthèses signifient qu'il s'agit du type de tableau de cette base. Les types de tableaux sont à leur tour des types qui leur sont propres, ce qui vous permet de créer des tableaux multidimensionnels comme Type[][] (le type de tableau de Type []). Le mot-clé new dit d'allouer de la mémoire pour le nouveau tableau. Le nombre entre parenthèses indique la taille du nouveau tableau et la quantité de mémoire à allouer. Par exemple, si Java sait que le type de base Type prend 32 octets, et vous voulez un tableau de taille 5, il doit allouer en interne 32 * 5 = 160 octets.

Vous pouvez également créer des tableaux avec les valeurs déjà présentes, telles que

int[] name = {1, 2, 3, 4, 5};

qui non seulement crée l'espace vide mais le remplit de ces valeurs. Java peut dire que les primitives sont des entiers et qu'il y en a 5, donc la taille du tableau peut être déterminée implicitement.


26
2018-06-04 06:02



Voici la déclaration d'un tableau, mais le tableau n'est pas initialisé:

 int[] myIntArray = new int[3];

Ce qui suit montre la déclaration ainsi que l'initialisation du tableau:

int[] myIntArray = {1,2,3};

Maintenant, ce qui suit montre aussi la déclaration ainsi que l'initialisation du tableau:

int[] myIntArray = new int[]{1,2,3};

Mais ce troisième montre la propriété de création d'un tableau-objet anonyme qui est pointée par une variable de référence "myIntArray", donc si nous écrivons juste "new int [] {1,2,3};" c'est ainsi que l'on peut créer un tableau-objet anonyme.

Si nous écrivons juste:

int[] myIntArray;

ce n'est pas une déclaration de tableau, mais la déclaration suivante complète la déclaration ci-dessus:

myIntArray=new int[3];

26
2017-07-29 14:25



Alternativement,

// Either method works
String arrayName[] = new String[10];
String[] arrayName = new String[10];

Cela déclare un tableau appelé arrayName de taille 10 (vous avez les éléments 0 à 9 à utiliser).


22
2017-07-29 15:56



En outre, si vous voulez quelque chose de plus dynamique, il y a l'interface List. Cela ne fonctionnera pas aussi bien, mais est plus flexible:

List<String> listOfString = new ArrayList<String>();

listOfString.add("foo");
listOfString.add("bar");

String value = listOfString.get(0);
assertEquals( value, "foo" );

22
2018-01-28 19:19



Il y a deux façons principales de créer un tableau:

Celui-ci, pour un tableau vide:

int[] array = new int[n]; // "n" being the number of spaces to allocate in the array

Et celui-ci, pour un tableau initialisé:

int[] array = {1,2,3,4 ...};

Vous pouvez également créer des tableaux multidimensionnels, comme ceci:

int[][] array2d = new int[x][y]; // "x" and "y" specify the dimensions
int[][] array2d = { {1,2,3 ...}, {4,5,6 ...} ...};

12
2018-05-23 19:56



Prenez le type primitif int par exemple. Il y a plusieurs façons de déclarer et int tableau:

int[] i = new int[capacity];
int[] i = new int[] {value1, value2, value3, etc};
int[] i = {value1, value2, value3, etc};

où dans tout cela, vous pouvez utiliser int i[] au lieu de int[] i.

Avec la réflexion, vous pouvez utiliser (Type[]) Array.newInstance(Type.class, capacity);

Notez que dans les paramètres de la méthode, ... indique variable arguments. Essentiellement, n'importe quel nombre de paramètres est bien. C'est plus facile à expliquer avec du code:

public static void varargs(int fixed1, String fixed2, int... varargs) {...}
...
varargs(0, "", 100); // fixed1 = 0, fixed2 = "", varargs = {100}
varargs(0, "", 100, 200); // fixed1 = 0, fixed2 = "", varargs = {100, 200};

À l'intérieur de la méthode, varargs est traité comme un normal int[]. Type... ne peut être utilisé dans les paramètres de la méthode, donc int... i = new int[] {} ne compilera pas.

Notez que lorsque vous passez un int[] à une méthode (ou à tout autre Type[]), vous ne pouvez pas utiliser la troisième voie. Dans la déclaration int[] i = *{a, b, c, d, etc}*, le compilateur suppose que {...} signifie un int[]. Mais c'est parce que vous déclarez une variable. Lors du passage d'un tableau à une méthode, la déclaration doit être soit new Type[capacity] ou new Type[] {...}.

Tableaux multidimensionnels

Les tableaux multidimensionnels sont beaucoup plus difficiles à gérer. Essentiellement, un tableau 2D est un tableau de tableaux. int[][] signifie un tableau de int[]s. La clé est que si un int[][] est déclaré comme int[x][y], l'indice maximum est i[x-1][y-1]. Essentiellement, un rectangle int[3][5] est:

[0, 0] [1, 0] [2, 0]
[0, 1] [1, 1] [2, 1]
[0, 2] [1, 2] [2, 2]
[0, 3] [1, 3] [2, 3]
[0, 4] [1, 4] [2, 4]

9
2018-01-20 11:54