Comment déclarer et initialiser un tableau en Java?
Comment déclarer et initialiser un tableau en Java?
Vous pouvez utiliser une déclaration de tableau ou un littéral de tableau (mais uniquement lorsque vous déclarez et affectez immédiatement la variable, vous ne pouvez pas utiliser de littéraux de tableau 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, 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 vous l’initialisez. Le casting est nécessaire ici.
String[] myStringArray;
myStringArray = new String[]{"a", "b", "c"};
Il existe deux types de tableau.
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: par commodité, int [] num est préférable car il indique clairement que vous parlez 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 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.
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 en lambeaux sont des tableaux multidimensionnels.
Pour une explication, voir les détails du tableau multidimensionnel à la page tutoriels officiels Java
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"};
Vous pouvez trouver plus d'informations dans le site tutoriel Sun et dans 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 c’est comme cela que l’objet tableau 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];
Je trouve cela utile si vous comprenez chaque partie:
Type[] name = new Type[5];
Type[] est le type du nom variable appelé ("nom" est appelé le identifiant). Le 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 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 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.
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 devez utiliser les éléments 0 à 9).
De plus, au cas où vous voudriez 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 y a deux façons principales de faire 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 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 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 convient. 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};
Dans la méthode, varargs est traité comme un int[] normal. Type... ne peut être utilisé que dans les paramètres de méthode. int... i = new int[] {} ne sera donc pas compilé.
Notez que lorsque vous passez un int[] à une méthode (ou à tout autre Type[]), vous ne pouvez pas utiliser la troisième manière. 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. Lorsque vous passez 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 maximal est 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 utilisant des réflexions, procédez comme suit:
int size = 3;
int[] intArray = (int[]) Array.newInstance(int.class, size );
Dans Java 9
Utilisation de IntStream.iterate et IntStream.takeWhile méthodes différentes:
_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 Inférence de type de variable locale :
_var letters = new String[]{"A", "B", "C"};
_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
}
}
Dans 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);
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 soit l'assigner à null pour les initialiser à l'aide de new Type(..), des classes telles que String et Integer sont des cas particuliers 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 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 est intéressant de noter que la création d'un tableau dimensionnel M coûte cher en termes d'espace. Depuis quand 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 dimension, il existe un tableau de références (M-1) à dimensions. 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 du tableau:
ClassName variableName = arrayName.get(index);
Remarque:
variableName est une référence au tableau, ce qui signifie que manipuler variableName 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
boucle for qui vous permet d'éditer arrayName (boucle conventionnelle):
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 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 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]]
Vous pouvez aussi le faire avec Java.util.Arrays:
List<String> number = Arrays.asList("1", "2", "3");
Out: ["1", "2", "3"]
Celui-ci est joli simple et simple. Je ne l'ai pas vu dans d'autres réponses, j'ai donc pensé pouvoir l'ajouter.
Une autre façon de déclarer et d’initialiser ArrayList:
private List<String> list = new ArrayList<String>(){{
add("e1");
add("e2");
}};
Beaucoup de réponses ici. Ajout de quelques astuces pour créer des tableaux (D'un point de vue examen c'est bon à 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 sont définies sur 0 par défaut.Par exemple
intArray[2]; // will return 0
Utilisation de 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 dans le support. Même variante simple de ceci est
int[] intArray = {1,2,3,4};Un tableau de longueur 0
int[] intArray = new int[0]; int length = intArray.length; // will return length 0similaire 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 3Utiliser des parenthèses avant 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 covariant
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 nulle.
Avec l'inférence de type de variable locale, il suffit de spécifier le type une fois:
var values = new int[] { 1, 2, 3 };
ou
int[] values = { 1, 2, 3 }
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;
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 voulez sauvegarder 5 éléments entiers qui sont 1,2,3,4,5 dans un tableau afin que vous puissiez le faire de la manière suivante:
une)
int[] a =new int[5];
ou b)
int [] a = {1,2,3,4,5};
le motif de base est donc pour l'initialisation et la déclaration par la méthode a est:
datatype[] arrayname = new datatype[requiredarraysize];
le type de données doit être en minuscule. le modèle de base est donc pour l'initialisation et la déclaration par la méthode a: s'il s'agit d'un tableau de chaînes:
String[] a ={"as","asd","ssd"};
si c'est un tableau de caractères:
char[] a ={'a','s','w'};
pour float, le format du tableau sera le même que entier. par exemple:
double[] a={1.2,1.3,12.3};
mais lorsque vous déclarez et initialisez le tableau avec "méthode a", vous devez entrer les valeurs manuellement ou par boucle ou autre. mais lorsque vous le faites par la "méthode b", vous ne devrez pas entrer les valeurs manuellement.