Comment déclarer et initialiser un tableau en Java?

https://stackoverflow.com/questions/1200621

05-07-2019
|

Question

La solution

Vous pouvez utiliser une déclaration de tableau ou un littéral de tableau (mais uniquement lorsque vous déclarez et affectez 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 classes, par exemple String , il en va de 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 d'abord le tableau, puis l'initialisez. Le casting est nécessaire ici.

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

Autres conseils

Il existe deux types de tableaux.

Tableau à une dimension

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};

Remarque: pour des raisons de commodité, int [] num est préférable, car il indique clairement que vous parlez de array. Sinon, pas de différence. Pas du tout.

Tableau multidimensionnel

Déclaration

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

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

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;

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

Tableau déchiqueté (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 donc ici les colonnes de manière explicite.
Une autre façon:

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 chiffonnés sont des tableaux multidimensionnels.
Pour plus d'explications, reportez-vous aux didacticiels java officiels

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 crochets après le type, car il est plus facile de voir que le type de la variable est en réalité un tableau.

Il existe différentes manières de déclarer un tableau en Java:

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

Pour plus d'informations, consultez le Didacticiel Sun site et le JavaDoc .

Ce qui suit montre 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 point montre la propriété de création d'objets de tableau anonymes pointés par une variable de référence "myIntArray", donc si nous écrivons simplement "new int [] {1,2,3}" alors voici comment créer un objet-tableau anonyme.

Si nous écrivons simplement:

int[] myIntArray;

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

myIntArray=new int[3];

Je trouve utile de comprendre chaque partie:

Type[] name = new Type[5];

Le type [] est le type de la variable appelée nom ("nom" est appelé identificateur ). Le littéral & Type; Type " est le type de base et les crochets indiquent qu'il s'agit du type de tableau de cette base. Les types de tableaux sont eux-mêmes des types propres, ce qui vous permet de créer des tableaux multidimensionnels tels que Type [] [] (type de tableau de Type []). Le mot clé new indique qu'il faut allouer de la mémoire pour le nouveau tableau. Le nombre entre crochets 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 que vous souhaitez 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, tels que

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

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

Sinon,

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

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

De plus, si vous souhaitez quelque chose de plus dynamique, utilisez 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" );

Il existe deux manières 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 ...} ...};

Prenez le type de primitive int par exemple. Il existe plusieurs façons de déclarer un tableau int :

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 réflexion, vous pouvez utiliser (Type []) Array.newInstance (Type.class, capacity);

Notez que dans les paramètres de méthode, ... indique arguments variables . Essentiellement, n'importe quel nombre de paramètres convient. C'est plus facile à expliquer avec le 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};

Dans la méthode, varargs est traité comme un normal [int>] . Type ... ne peut être utilisé que dans les paramètres de méthode. Par conséquent, int ... i = new int [] {} ne sera pas compilé.

Notez que lorsque vous transmettez un int [] à une méthode (ou à un autre Type [] ], vous ne pouvez pas utiliser la troisième méthode. Dans l'instruction int [] i = * {a, b, c, d, etc} * , le compilateur suppose que {...} signifie un int [] . Mais c'est parce que vous déclarez une variable. Lorsque vous passez un tableau à une méthode, la déclaration doit être nouveau Type [capacité] ou nouveau 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'index maximal est i [x-1] [ y-1] . Pour l'essentiel, un int [3] [5] rectangulaire 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]

Si vous souhaitez créer des tableaux à l'aide de réflexions, procédez comme suit:

 int size = 3;
 int[] intArray = (int[]) Array.newInstance(int.class, size );

Déclaration d'un tableau de références d'objet:

class Animal {}

class Horse extends Animal {
    public static void main(String[] args) {

        /*
         * Array of Animal can hold Animal and Horse (all subtypes of Animal allowed)
         */
        Animal[] a1 = new Animal[10];
        a1[0] = new Animal();
        a1[1] = new Horse();

        /*
         * Array of Animal can hold Animal and Horse and all subtype of Horse
         */
        Animal[] a2 = new Horse[10];
        a2[0] = new Animal();
        a2[1] = new Horse();

        /*
         * Array of Horse can hold only Horse and its subtype (if any) and not
           allowed supertype of Horse nor other subtype of Animal.
         */
        Horse[] h1 = new Horse[10];
        h1[0] = new Animal(); // Not allowed
        h1[1] = new Horse();

        /*
         * This can not be declared.
         */
        Horse[] h2 = new Animal[10]; // Not allowed
    }
}

En Java 9

Utilisation de différents IntStream.iterate et IntStream.takeWhile méthodes:

int[] a = IntStream.iterate(10, x -> x <= 100, x -> x + 10).toArray();

Out: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]


int[] b = IntStream.iterate(0, x -> x + 1).takeWhile(x -> x < 10).toArray();

Out: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

En Java 10

Utilisation de la Inférence de type de variable locale :

var letters = new String[]{"A", "B", "C"};

Le tableau est une liste séquentielle d'éléments

int item = value;

int [] one_dimensional_array = { value, value, value, .., value };

int [][] two_dimensional_array =
{
  { value, value, value, .. value },
  { value, value, value, .. value },
    ..     ..     ..        ..
  { value, value, value, .. value }
};

Si c'est un objet, alors c'est le même concept

Object item = new Object();

Object [] one_dimensional_array = { new Object(), new Object(), .. new Object() };

Object [][] two_dimensional_array =
{
  { new Object(), new Object(), .. new Object() },
  { new Object(), new Object(), .. new Object() },
    ..            ..               ..
  { new Object(), new Object(), .. new Object() }
};

Dans le cas d'objets, vous devez l'affecter à null pour les initialiser à l'aide de nouveau Type (..) , des classes telles que String et Entier sont des cas particuliers qui seront traités comme suit

String [] a = { "hello", "world" };
// is equivalent to
String [] a = { new String({'h','e','l','l','o'}), new String({'w','o','r','l','d'}) };

Integer [] b = { 1234, 5678 };
// is equivalent to
Integer [] b = { new Integer(1234), new Integer(5678) };

En général, vous pouvez créer des tableaux M dimensionnels

int [][]..[] array =
//  ^ M times [] brackets

    {{..{
//  ^ M times { bracket

//            this is array[0][0]..[0]
//                         ^ M times [0]

    }}..}
//  ^ M times } bracket
;

Il est intéressant de noter que la création d'un tableau de dimensions M est coûteuse en termes d'espace. Depuis lors, lorsque vous créez un tableau dimensionnel M avec N sur toutes les dimensions, la taille totale du tableau est supérieure à N ^ M , car chaque tableau a une référence et à la dimension M, il y a un tableau de références (M-1). La taille totale est la suivante

Space = N^M + N^(M-1) + N^(M-2) + .. + N^0
//      ^                              ^ array reference
//      ^ actual data

Pour créer des tableaux d'objets de classe, vous pouvez utiliser le java.util.ArrayList . définir un tableau:

public ArrayList<ClassName> arrayName;
arrayName = new ArrayList<ClassName>();

Attribuez des valeurs au tableau:

arrayName.add(new ClassName(class parameters go here);

Lire dans le tableau:

ClassName variableName = arrayName.get(index);

Remarque:

NomVariable est une référence au tableau, ce qui signifie que manipuler NomVariable manipulera NomNom

pour les boucles:

//repeats for every value in the array
for (ClassName variableName : arrayName){
}
//Note that using this for loop prevents you from editing arrayName

boucle qui vous permet d’éditer arrayName (conventionnel pour la boucle):

for (int i = 0; i < arrayName.size(); i++){
    //manipulate array here
}

En Java 8, vous pouvez utiliser comme ceci.

String[] strs = IntStream.range(0, 15)  // 15 is the size
    .mapToObj(i -> Integer.toString(i))
    .toArray(String[]::new);

Déclarez et initialisez pour Java 8 et versions ultérieures. Créez un tableau entier simple:

int [] a1 = IntStream.range(1, 20).toArray();
System.out.println(Arrays.toString(a1));
// Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

Créez un tableau aléatoire pour les entiers compris entre [-50, 50] et pour les doubles [0, 1E17]:

int [] a2 = new Random().ints(15, -50, 50).toArray();
double [] a3 = new Random().doubles(5, 0, 1e17).toArray();

Séquence de la puissance des deux:

double [] a4 = LongStream.range(0, 7).mapToDouble(i -> Math.pow(2, i)).toArray();
System.out.println(Arrays.toString(a4));
// Output: [1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0]

Pour String [], vous devez spécifier un constructeur:

String [] a5 = Stream.generate(()->"I will not squeak chalk").limit(5).toArray(String[]::new);
System.out.println(Arrays.toString(a5));

Tableaux multidimensionnels:

String [][] a6 = List.of(new String[]{"a", "b", "c"} , new String[]{"d", "e", "f", "g"})
    .toArray(new String[0][]);
System.out.println(Arrays.deepToString(a6));
// Output: [[a, b, c], [d, e, f, g]]

Vous pouvez également le faire avec java.util.Arrays :

List<String> number = Arrays.asList("1", "2", "3");

Out: ["1", "2", "3"]

Celui-ci est assez simple et simple. Je ne l'ai pas vu dans d'autres réponses et j'ai donc pensé pouvoir l'ajouter.

Autre moyen de déclarer et d'initialiser ArrayList:

private List<String> list = new ArrayList<String>(){{
    add("e1");
    add("e2");
}};

Avec l'inférence de type de variable locale, il vous suffit de spécifier le type une fois:

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

int[] values = { 1, 2, 3 }

Beaucoup de réponses ici. Ajout de quelques astuces pour créer des tableaux (Pour un examen , il est bon de le savoir)

déclarer et définir un tableau
```
int intArray[] = new int[3];
```

cela créera un tableau de longueur 3. Comme il contient le type primitif int, toutes les valeurs définies sur 0 par défaut.Par exemple

    intArray[2]; // will return 0

Utilisation des crochets [] avant le nom de la variable

int[] intArray = new int[3];
intArray[0] = 1;  // array content now {1,0,0}

Initialiser et fournir des données au tableau
```
int[] intArray = new int[]{1,2,3};
```
cette fois, pas besoin de mentionner la taille entre parenthèses. Même la variante la plus simple est
```
int[] intArray = {1,2,3,4};
```

Un tableau de longueur 0

int[] intArray = new int[0];
int length = intArray.length; // will return length 0

Similaire pour les tableaux multidimensionnels

int intArray[][] = new int[2][3]; 
// This will create an array of length 2 and 
//each element contains another array of length 3.
// { {0,0,0},{0,0,0} } 
int lenght1 = intArray.length; // will return 2
int length2 = intArray[0].length; // will return 3

Utilisation des crochets avant la variable

int[][] intArray = new int[2][3];

sa absolument bien si vous mettez un support de boîte à la fin

int[] intArray [] = new int[2][4];
int[] intArray[][] = new int[2][3][4]

Quelques exemples

    int [] intArray [] = new int[][] {{1,2,3},{4,5,6}};
    int [] intArray1 [] = new int[][] {new int[] {1,2,3}, new int [] {4,5,6}};
    int [] intArray2 [] = new int[][] {new int[] {1,2,3},{4,5,6}} 
    // All the 3 arrays assignments are valid
    //Array looks like {{1,2,3},{4,5,6}}

Il n'est pas obligatoire que chaque élément interne ait la même taille.

    int [][] intArray = new int[2][];
    intArray[0] = {1,2,3};
    intArray[1] = {4,5};
    //array looks like {{1,2,3},{4,5}}

    int[][] intArray = new int[][2] ; // this won't compile keep this in mind.

Vous devez vous assurer que si vous utilisez la syntaxe ci-dessus, vous devez spécifier les valeurs entre crochets.Else ne compilera pas. Quelques exemples:

    int [][][] intArray = new int[1][][];
    int [][][] intArray = new int[1][2][];
    int [][][] intArray = new int[1][2][3];

Une autre caractéristique importante est la covariante

    Number[] numArray = {1,2,3,4};   // java.lang.Number
    numArray[0] = new Float(1.5f);   // java.lang.Float
    numArray[1] = new Integer(1);    // java.lang.Integer
   //You can store a subclass object in an array that is declared
   // to be of the type of its superclass. 
   // Here Number is the superclass for both Float and Integer.

   Number num[] = new Float[5]; // this is also valid

IMP: pour les types référencés, la valeur par défaut stockée dans le tableau est null.

Déclarer un tableau: int [] arr;

Initialize Array: int [] arr = new int [10]; 10 représente le nombre d'éléments autorisés dans le tableau

Déclarer un tableau multidimensionnel: int [] [] arr;

Initialisation du tableau multidimensionnel: int [] [] arr = new int [10] [17]; 10 lignes et 17 colonnes et 170 éléments car 10 fois 17 correspond à 170.

Initialiser un tableau signifie en spécifier la taille.

int[] SingleDimensionalArray = new int[2]

int[][] MultiDimensionalArray = new int[3][4]

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow