, Il existe deux types de tableau.

Tableau unidimensionnel

Syntaxe pour les valeurs par défaut:

int[] num = new int[5];

Ou (moins préféré)

int num[] = new int[5];

Syntaxe avec des 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 plus de commodité, int [] num est préférable car il indique clairement que vous parlez ici de tableau. Sinon, aucune différence. Pas le moins du monde.

Multidimensionnel tableau

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 en lambeaux (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.
D'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 en lambeaux sont des tableaux multidimensionnels.
Pour une explication, voir le détail du tableau multidimensionnel à le 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 dans le Soleil tutoriel site et le JavaDoc.

Je trouve cela utile si vous comprenez chaque partie:

Type[] name = new Type[5];

Type[] est le de type de la variable, appelé nom ("name" est appelé le identificateur). Le "Type" littéral est le type de base, et les crochets signifient que c'est le type de tableau de cette base. Les types de tableau 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 indique d'allouer de la mémoire pour le nouveau tableau. Le nombre entre le support 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 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, donc la taille du le tableau peut être déterminé 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 ce troisième montre la propriété de la création d'objet de tableau anonyme qui est pointée par une variable de référence "myIntArray", donc si nous écrivons juste "new int [] {1,2,3};" alors voici comment un tableau-objet anonyme peut être créé.

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

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

De plus, si vous voulez quelque chose de plus dynamique, il y a l'interface de liste. 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 ...} ...};

Prenez le type primitif int par exemple. Il existe plusieurs façons de déclarer et int array:

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

, Où dans tous ces cas, 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 les paramètres de la méthode, ... indique variable arguments. Essentiellement, n'importe quel nombre de paramètres est correct. 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};

À l'Intérieur de la méthode, varargs est traité comme un normal int[]. Type... ne peut être utilisé que dans la méthode paramètres, 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 l'état 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 à traiter. Essentiellement, un tableau 2D est un tableau de tableaux. int[][] désigne une matrice de int[]s. La clé est que si un int[][] est déclarée comme int[x][y], l'indice maximum est de i[x-1][y-1]. Essentiellement, 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 voulez 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éclarer 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
    }
}

Array 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 des objets, vous devez l'affecter à null initialiser à l'aide de new Type(..), classes comme String et Integer sont des cas particuliers qui seront traitées 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 qui sont M dimensionnels

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

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

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

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

Il convient de noter que la création d'un tableau dimensionnel M coûte cher en termes d'espace. Depuis 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)-dimensionnel. La taille totale est comme suit

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. pour définir un tableau:

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

Assigner des valeurs au tableau:

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

Lire dans le tableau:

ClassName variableName = arrayName.get(index);

Remarque:

variableName est une référence au tableau signifiant que manipuler {[6] } manipulera arrayName

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 la boucle qui vous permet d'éditer arrayName (classique 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);

Dans Java 9

À l'Aide 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 l'inférence de type de variable locale :

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

Déclarer et initialiser pour Java 8 et versions ultérieures. Créer 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éer 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]

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

int[] SingleDimensionalArray = new int[2]

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