Comment déclarer et initialiser un tableau en Java?

Vous pouvez soit 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};

// Since Java 8. Doc of IntStream: https://docs.oracle.com/javase/8/docs/api/java/util/stream/IntStream.html

int [] myIntArray = IntStream.range(0, 100).toArray(); // From 0 to 99
int [] myIntArray = IntStream.rangeClosed(0, 100).toArray(); // From 0 to 100
int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).toArray(); // The order is preserved.
int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).sorted().toArray(); // Sort 

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

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

Il existe deux types de tableau.

Tableau unidimensionnel

Syntaxe des valeurs par défaut:

int[] num = new int[5];

Ou (moins préféré)

int num[] = new int[5];

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

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

Ou (moins préféré)

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

Remarque: Par commodité, int [] num est préférable car il indique clairement que vous parlez ici de tableau. Sinon, aucune 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} };

Tableau irrégulier (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 explicitement les colonnes.
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 des explications, voir les détails du tableau multidimensionnel dans les tutoriels 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 fait un tableau.

Il existe différentes 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 sur le site du didacticiel Sun et JavaDoc .

Je trouve cela utile si vous comprenez chaque partie:

Type[] name = new Type[5];

Type[]est le type de la variable appelée nom ("nom" est appelé l' identifiant ). Le "Type" littéral est le type de base, et les crochets 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 Type []). Le mot-clé newdit d'allouer de la mémoire pour le nouveau tableau. Le nombre entre les crochets indique la taille du nouveau tableau et la quantité de mémoire à allouer. Par exemple, si Java sait que le type de base Typeprend 32 octets et que 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 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 peut être déterminée implicitement.

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 également la déclaration ainsi que l'initialisation du tableau:

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

Mais cette troisième montre la propriété de la création anonyme d'objets de tableau 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 objet tableau anonyme.

Si nous écrivons simplement:

int[] myIntArray;

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

myIntArray=new int[3];

Alternativement,

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

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

De plus, 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" );

Il existe 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 ...} ...};

Prenons l' intexemple du type primitif . Il existe plusieurs façons de déclarer et de intgrouper:

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 à la int i[]place de int[] i.

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

Notez que dans les paramètres de méthode, ...indique variable arguments. Essentiellement, n'importe quel nombre de paramètres est correct. 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, varargsest traitée comme une normale int[]. Type...ne peut être utilisé que dans les paramètres de la méthode, donc int... i = new int[] {}ne sera pas compilé.

Notez que lorsque vous passez un int[]à une méthode (ou toute 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 le {...}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 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'index maximum est i[x-1][y-1]. Un rectangle int[3][5]est essentiellement :

[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]

Dans Java 9

En utilisant différentes méthodes IntStream.iterateet IntStream.takeWhile:

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]

Dans Java 10

Utilisation de l' inférence de type variable locale :

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

Si vous souhaitez créer des tableaux en utilisant des réflexions, vous pouvez faire comme ceci:

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

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

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

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, 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 soit l'assigner à nullpour les initialiser en utilisant new Type(..), des classes comme Stringet Integersont des cas spéciaux 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 Mdimensionnels

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

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

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

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

Il est à noter que la création d'un Mtableau dimensionnel coûte cher en termes d'espace. Depuis que vous créez un Mtableau dimensionnel avec Ntoutes les dimensions, la taille totale du tableau est plus grande que N^M, puisque chaque tableau a une référence, et à la dimension M il y a un tableau de références (M-1) -dimensionnel. La taille totale est la suivante

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

En Java 8, vous pouvez utiliser comme ça.

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

Pour créer des tableaux d'objets de classe, vous pouvez utiliser le java.util.ArrayList. pour 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 à partir du tableau:

ClassName variableName = arrayName.get(index);

Remarque:

variableNameest une référence au tableau, ce qui signifie que la manipulation variableNamemanipuleraarrayName

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

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

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

Déclarez et initialisez pour Java 8 et versions ultérieures. Créez un tableau d'entiers 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 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 puissance de 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]]

Une autre façon de déclarer et d'initialiser ArrayList:

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

Il y a beaucoup de réponses ici. J'ajoute quelques façons délicates de créer des tableaux (du point de vue de l' examen , il est bon de le savoir)

1. Déclarez et définissez un tableau

   int intArray[] = new int[3];

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

   intArray[2]; // Will return 0

2. Utilisation de crochets [] avant le nom de la variable

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

3. Initialiser et fournir des données à la baie

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

   Cette fois, il n'est pas nécessaire de mentionner la taille dans le support de boîte. Même une variante simple de ceci est:

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

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 de crochets avant la variable:

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

C'est très 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 intérieur soit de 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, que la direction avant vous devez spécifier les valeurs entre crochets. Sinon, il ne se 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

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

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 direct.

Avec l'inférence de type de variable locale, vous ne devez spécifier le type qu'une seule fois:

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

Ou

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

Le tableau a deux types de base.

Tableau statique: tableau de taille fixe (sa taille doit être déclarée au début et ne peut pas être modifiée ultérieurement)

Tableau dynamique: aucune limite de taille n'est prise en compte pour cela. (Les tableaux dynamiques purs n'existent pas en Java. Au lieu de cela, la liste est la plus encouragée)

Pour déclarer un tableau statique de type Integer, string, float, etc ... utilisez la déclaration ci-dessous et les instructions d'initialisation.

    int[] intArray = new int[10]; 
    String[] intArray = new int[10]; 
    float[] intArray = new int[10]; 
    
   // here you have 10 index starting from 0 to 9

Pour utiliser des fonctionnalités dynamiques, vous devez utiliser List ... List est un tableau dynamique pur et il n'est pas nécessaire de déclarer la taille au début. Ci-dessous est la bonne façon de déclarer une liste dans JAVA>

        ArrayList<String> myArray = new ArrayList<String>();
        myArray.add("Value 1: something");
        myArray.add("Value 2: something more");

Déclarez le tableau: int[] arr;

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

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

Initialiser un tableau multidimensionnel: int[][] arr = new int[10][17];10 lignes et 17 colonnes et 170 éléments car 10 fois 17 est 170.

Initialiser un tableau signifie en spécifier la taille.

Il est très facile de déclarer et d'initialiser un tableau. Par exemple, vous souhaitez enregistrer cinq éléments entiers qui sont 1, 2, 3, 4 et 5 dans un tableau. Vous pouvez le faire de la manière suivante:

une)

int[] a = new int[5];

ou

b)

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

donc le modèle de base est pour l'initialisation et la déclaration par la méthode a) est:

datatype[] arrayname = new datatype[requiredarraysize];

datatype devrait être en minuscules.

Donc, le modèle de base est pour l'initialisation et la déclaration par la méthode a est:

S'il s'agit d'un tableau de chaînes:

String[] a = {"as", "asd", "ssd"};

S'il s'agit d'un tableau de caractères:

char[] a = {'a', 's', 'w'};

Pour float double, le format du tableau sera identique à entier.

Par exemple:

double[] a = {1.2, 1.3, 12.3};

mais lorsque vous déclarez et initialisez le tableau par la "méthode a", vous devrez entrer les valeurs manuellement ou par boucle ou quelque chose.

Mais lorsque vous le faites par la "méthode b", vous n'aurez pas à entrer les valeurs manuellement.

Le tableau peut contenir des types de données primitifs ainsi que des objets d'une classe selon la définition du tableau. Dans le cas des types de données primitifs, les valeurs réelles sont stockées dans des emplacements de mémoire contigus. Dans le cas d'objets d'une classe, les objets réels sont stockés dans un segment de tas.

Tableaux unidimensionnels:
La forme générale d'une déclaration de tableau unidimensionnel est

type var-name[];
OR
type[] var-name;

Instanciation d'un tableau en Java

var-name = new type [size];

Par exemple

    int intArray[];    //declaring array
    intArray = new int[20];  // allocating memory to array
    // the below line is equals to line1 + line2
    int[] intArray = new int[20]; // combining both statements in one
     int[] intArray = new int[]{ 1,2,3,4,5,6,7,8,9,10 }; 
    // accessing the elements of the specified array
    for (int i = 0; i < intArray.length; i++)
    System.out.println("Element at index " + i + " : "+ intArray[i]);

Réf: https://www.geeksforgeeks.org/arrays-in-java/

un autre exemple complet avec la classe de films 😋

public class A {

        public static void main(String[] args) {

                class Movie{

                    String movieName;
                    String genre;
                    String movieType;
                    String year;
                    String ageRating;
                    String rating;

                    public Movie(String [] str)
                    {
                        this.movieName = str[0];
                        this.genre = str[1];
                        this.movieType = str[2];
                        this.year = str[3];
                        this.ageRating = str[4];
                        this.rating = str[5];    
                    }

                }

                String [] movieDetailArr = {"Inception", "Thriller", "MovieType", "2010", "13+", "10/10"};

                Movie mv = new Movie(movieDetailArr);

                System.out.println("Movie Name: "+ mv.movieName);
                System.out.println("Movie genre: "+ mv.genre);
                System.out.println("Movie type: "+ mv.movieType);
                System.out.println("Movie year: "+ mv.year);
                System.out.println("Movie age : "+ mv.ageRating);
                System.out.println("Movie  rating: "+ mv.rating);


            }

        } 

int[] x=new int[enter the size of array here];

exemple:

int[] x=new int[10];

ou

int[] x={enter the elements of array here];

exemple:

int[] x={10,65,40,5,48,31};

int[] SingleDimensionalArray = new int[2]

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