Pour ceux qui viennent de commencer à apprendre la programmation, y compris le langage Java, et ceux qui l'ont déjà appris, pour examen Cette fois, j'écris pour en savoir plus sur les ** tableaux **.
Une variable est un conteneur qui contient une donnée de valeur pour une variable (Cliquez ici pour les variables).
En utilisant un tableau, vous pouvez gérer plusieurs données du même type de données dans un tableau. ''
Lorsqu'il y a 500 valeurs, dans le cas de variables, vous devez préparer 500 valeurs, Dans le cas d'un tableau, cela signifie qu'un tableau peut être préparé et 500 données peuvent y être stockées.
En outre, vous pouvez facilement trier les données du tableau et obtenir la valeur la plus élevée.
Lors de la création d'un tableau, il est d'abord nécessaire de décider du type de données du type de valeur à traiter comme une variable, et de le déclarer avec un nom.
Déclarez «type de données [] nom du tableau».
Main.java
class Main {
public static void main(String[] args) {
int[] numbers; //Déclaration d'un tableau pouvant gérer les valeurs de type int
// []Peut être après le nom de la séquence.
String names[]; //Déclaration d'un tableau pouvant gérer les valeurs de type String
}
}
Il est nécessaire de sécuriser une zone pour combien le tableau déclaré doit être rempli de valeurs.
Déterminez la taille de la zone à sécuriser par nouveau [nombre d'éléments].
Main.java
class Main {
public static void main(String[] args) {
int[] numbers; //Déclaration d'un tableau pouvant gérer les valeurs de type int
String names[]; //Déclaration d'un tableau pouvant gérer les valeurs de type String
numbers = new int[50]; //Réservez une zone pour stocker 50 valeurs dans le tableau de nombres
names = new String[3]; //Allouer une zone pour stocker 3 valeurs dans le tableau de noms
}
}
** Il est également possible de déclarer un tableau et de sécuriser une zone en même temps. ** **
Main.java
class Main {
public static void main(String[] args) {
int[] numbers = new int[50];//Déclaration d'un tableau capable de gérer des valeurs de type int et de sécuriser 50 zones
String names[] = new String[3]; //Déclaration d'un tableau pouvant gérer des valeurs de type String et une zone sécurisée pour 3
}
}
** Veuillez noter que si vous ne spécifiez pas le nombre d'éléments, une erreur de compilation se produira. ** **
Main.java
class Main {
public static void main(String[] args) {
int[] numbers = new int[];//Erreur de compilation car le nombre d'éléments n'est pas spécifié
String names[] = new String[]; //Erreur de compilation car le nombre d'éléments n'est pas spécifié
}
}
Le nombre d'éléments du tableau ne peut pas être modifié ultérieurement, Gardez à l'esprit que si vous spécifiez d'abord le nombre d'éléments dans le tableau comme 5, le nombre d'éléments après cela sera fixé à 5 tout le temps.
Gardez également à l'esprit que le nombre d'éléments doit être un entier.
Le tableau est déclaré et instancié et prêt à stocker les valeurs.
Utilisez subscript (index) pour attribuer une valeur à un tableau.
Les indices (index) sont des numéros de série attribués à chaque élément du tableau, commençant à 0.
Main.java
class Main {
public static void main(String[] args) {
int[] numbers = new int[5]; //Définir un tableau de nombres pouvant stocker 5 éléments de type int
numbers[0] = 100; //Premièrement, 100
numbers[1] = 200; //Deuxième, 200
numbers[2] = 300; //Troisième, 300
numbers[3] = 400; //Quatrième, 400
numbers[4] = 500; //Cinquième, 500
}
}
Des indices (index) sont également utilisés pour accéder à chaque élément du tableau.
Main.java
class Main {
public static void main(String[] args) {
int[] numbers = new int[5]; //Définir un tableau de nombres pouvant stocker 5 éléments de type int
numbers[0] = 100; //Premièrement, 100
numbers[1] = 200; //Deuxième, 200
numbers[2] = 300; //Troisième, 300
numbers[3] = 400; //Quatrième, 400
numbers[4] = 500; //Cinquième, 500
System.out.println(numbers[0]); //100 est la sortie
System.out.println(numbers[3]); //400 est la sortie
}
}
Jusqu'à ce qui précède, la déclaration du tableau, l'attribution de la zone et l'attribution de la valeur (valeur initiale) ont été effectuées étape par étape.
Vous pouvez déclarer un tableau, sécuriser une zone et attribuer une valeur (valeur initiale) en même temps. (Initialisation du tableau)
Mettez la valeur entre «{}» et décrivez chaque élément séparé par des virgules.
Type de données [] Nom du tableau = {Valeur initiale 1, Valeur initiale 2, Valeur initiale 3, Valeur initiale 4, Valeur initiale 5};
Aussi, utilisez lengthpour savoir combien de ʻéléments vous avez créés. Vous pouvez obtenir le nombre d'éléments avec ʻarray name.length;.
Main.java
class Main {
public static void main(String[] args) {
int[] numbers = {100, 200, 300, 400, 500}; //Initialisation de la baie
int size = numbers.length; //Obtenir le nombre d'éléments dans le tableau de nombres Dans ce cas, 5 est stocké
System.out.println(numbers[0]); //Sortie comme 100
System.out.println(numbers[1]); //Sortie comme 200
System.out.println(numbers[2]); //Sortie comme 300
System.out.println(numbers[3]); //Sortie comme 400
System.out.println(numbers[4]); //Sortie comme 500
System.out.println(size); //Est sortie comme 5
//L'initialisation du tableau à l'aide de cette méthode de description est également efficace.
int[] id = new int[]{1, 2, 3};
System.out.println(id[0]); //Est sortie comme 1
System.out.println(id[1]); //2 est la sortie
System.out.println(id[2]); //Est sortie comme 3
System.out.println(id.length); //Est sortie comme 3
}
}
J'utilisais des indices (index) pour accéder aux éléments du tableau, Lorsque vous essayez d'accéder à l'extérieur des éléments d'un tableau, une erreur de compilation ne se produit pas, mais une erreur d'exécution (exception) se produit. Pour plus d'informations, consultez les articles sur la gestion des exceptions (https://qiita.com/morioheisei/items/d25d2b67e7530c1aab9d).
Jetons un coup d'œil ici aussi.
Main.java
class Main {
public static void main(String[] args) {
int[] id = {1, 2, 3, 4, 5}; //Le nombre d'éléments dans le tableau est de 5
//Tournez la boucle 6 fois avec l'instruction for=Dépassement des éléments du tableau id
for(int i = 0; i < 6; i++) {
//Sortie un par un
System.out.println(id[i]);
}
System.out.println("J'ai fini de sortir tout le contenu du tableau id.");
}
}
Le résultat de sortie est
Terminal
1
2
3
4
5
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
at Main.main(Main.java:195)
C'était sortie comme ci-dessus. Une exception ArrayIndexOutOfBoundsException s'est produite. Et j'ai fini de sortir tout le contenu du tableau id. N'est pas affiché. Lorsque vous essayez d'accéder au tableau de cette manière, si vous accédez à l'extérieur de l'élément, Soyez prudent car une exception se produira et le traitement s'arrêtera au milieu.
Il existe également des tableaux à deux dimensions qui gèrent deux indices (index) et des tableaux plus multidimensionnels. Cette fois, je vais expliquer le tableau bidimensionnel.
Dans un tableau à deux dimensions, utilisez deux []
Déclarez le type de données [] [] nom du tableau.
Main.java
class Main {
public static void main(String[] args) {
int[][] numbers; //Déclaration d'un tableau à deux dimensions pouvant gérer des valeurs de type int
// [][]Peut être après le nom de la séquence.
String strs[][]; //Déclaration d'un tableau à deux dimensions pouvant gérer des valeurs de type String
}
}
Comme dans le cas d'un tableau unidimensionnel, il est nécessaire de sécuriser une zone pour combien le tableau déclaré doit être rempli de valeurs.
Main.java
class Main {
public static void main(String[] args) {
int[][] numbers; //Déclaration d'un tableau à deux dimensions pouvant gérer les valeurs de type int
String strs[][]; //Déclaration d'un tableau à deux dimensions pouvant gérer des valeurs de type String
//Un tableau avec trois éléments, des nombres[0]À partir de nombres[2]Sécurisez une zone avec 4 éléments pour chaque élément de
numbers = new int[3][4];
//Un tableau avec deux éléments, strs[0]À partir de strs[1]Sécurisez une zone avec deux éléments pour chaque élément de
strs = new String[2][2];
}
}
Comme un tableau unidimensionnel ** Il est également possible de déclarer un tableau et de sécuriser une zone en même temps. ** **
Main.java
class Main {
public static void main(String[] args) {
//Allouer une déclaration de tableau à deux dimensions et une zone pouvant gérer les valeurs de type int
int[][] numbers = new int[3][4];
//Allouer une déclaration de tableau à deux dimensions et une zone pouvant gérer les valeurs de type String
String strs[][] = new String[2][2];
}
}
Il est également possible de sécuriser uniquement la zone du `premier tableau de dimension. '' Dans ce cas, vous pouvez décider du nombre d'éléments dans la deuxième dimension plus tard.
Main.java
class Main {
public static void main(String[] args) {
int[][] array; //Déclaration d'un tableau à deux dimensions pouvant gérer les valeurs de type int
array = new int[3][]; //Zone de réserve pour un tableau avec 3 éléments
array[0] = new int[5]; //Le premier tableau de tableau peut stocker 5 éléments
array[1] = new int[3]; //Le deuxième tableau de tableau peut stocker 3 éléments
array[2] = new int[4]; //Le troisième tableau de tableau peut stocker 4 éléments
//Il en va de même lors de la déclaration d'un tableau et de la sécurisation d'une zone en même temps.
String[][] strs = new String[2][]; //Déclaration de tableau de type String, allocation de zone
strs[0] = new String[6]; //Le premier tableau de chaînes peut stocker 6 éléments
strs[1] = new String[3]; //Le deuxième tableau de chaînes peut stocker trois éléments
}
}
Même dans le cas d'un tableau à deux dimensions, le nombre d'éléments ne peut pas être modifié ultérieurement et le nombre d'éléments doit être un entier.
Les valeurs sont stockées à l'aide d'indices (index) de la même manière que les tableaux à 1 dimension.
Main.java
class Main {
public static void main(String[] args) {
int[][] numbers = new int[2][2]; //Déclaration d'un tableau à deux dimensions pouvant gérer les valeurs de type int
numbers[0][0] = 100;
numbers[0][1] = 200;
numbers[1][0] = 300;
numbers[1][1] = 400;
System.out.println(numbers[0][0]); //Sortie comme 100
System.out.println(numbers[0][1]); //Sortie comme 200
System.out.println(numbers[1][0]); //Sortie comme 300
System.out.println(numbers[1][1]); //Sortie comme 400
}
}
Même dans un tableau à deux dimensions
Vous pouvez déclarer un tableau, sécuriser une zone et attribuer une valeur (valeur initiale) en même temps. (Initialisation du tableau)
De même, mettez la valeur entre «{}» et décrivez chaque élément séparé par des virgules.
Type de données [] [] Nom du tableau = { {Valeur initiale 1, Valeur initiale 2, Valeur initiale 3, Valeur initiale 4, Valeur initiale 5}, {Valeur initiale 6, valeur initiale 7, valeur initiale 8, valeur initiale 9, valeur initiale 10} };
Aussi, utilisez lengthpour savoir combien de ʻéléments vous avez créés. Vous pouvez obtenir le nombre d'éléments avec ʻarray name.length;.
Pour obtenir la longueur du tableau dans ce tableau
Vous pouvez obtenir le nombre d'éléments avec ʻarray name [indice (index)] .length`.
Main.java
class Main {
public static void main(String[] args) {
//Comme avec un tableau unidimensionnel, il est possible de déclarer un tableau, de sécuriser une zone et d'attribuer une valeur à la fois.
int[][] numbers = {
{1, 2, 3, 4, 5},
{6, 7, 8, 9, 10},
{11, 12, 13},
{16, 17}
};
System.out.println("numbers[0][4]La valeur du: " + numbers[0][4]); // numbers[0][4]La valeur du:Est sortie comme 5
System.out.println("numbers[3][0]La valeur du: " + numbers[3][0]); // numbers[3][0]La valeur du:Est sortie comme 16
System.out.println("Longueur du nombre: " + numbers.length); // Longueur du nombre:Est sortie comme 4
System.out.println("numbers[0]Longueur de: " + numbers[0].length); // numbers[0]Longueur de:Est sortie comme 5
System.out.println("numbers[2]Longueur de: " + numbers[2].length); // numbers[2]Longueur de:Est sortie comme 3
System.out.println("numbers[3]Longueur de: " + numbers[3].length); // numbers[3]Longueur de:2 est la sortie
}
}
À partir de là, je vais présenter une utilisation simple du tableau à 1 dimension et du tableau à 2 dimensions.
N'oubliez pas d'importer d'abord car nous utiliserons la classe java.util.Arrays. Cliquez ici pour la classe Oracle's Arrays
Main.java
import java.util.Arrays;
class Main {
public static void main(String[] args) {
//Initialisez le tableau de nombres (l'ordre des entiers est aléatoire)
int[] numbers = {10, 1, 5, 6, 9};
//Trier par ordre croissant à l'aide de la méthode sort de la classe Arrays
Arrays.sort(numbers);
//Tableau des nombres de sortie un par un
for(int number : numbers) {
System.out.print(number + " "); //Sortie comme 1 5 6 9 10
}
}
}
Les nombres, qui contenaient des entiers aléatoires, peuvent être triés par ordre croissant à l'aide de la méthode de tri.
Ensuite, trions les chaînes de caractères.
Main.java
import java.util.Arrays;
class Main {
public static void main(String[] args) {
//Initialisez le tableau des noms (l'ordre des noms qu'il contient est aléatoire)
String[] names = {"tanaka", "abe", "suzuki", "maeda"};
//Trier par ordre alphabétique à l'aide de la méthode de tri de la classe Arrays
Arrays.sort(names);
//Tableau des noms de sortie un par un
for(String name : names) {
System.out.print(name + " "); //Sortie en tant que abe maeda suzuki tanaka
}
}
}
Les noms, qui contenaient des chaînes de caractères aléatoires, peuvent être triés par ordre alphabétique à l'aide de la méthode de tri.
Main.java
class Main {
public static void main(String[] args) {
//Initialisez les nombres du tableau à deux dimensions (l'ordre des entiers est aléatoire)
int[][] numbers = {
{2, 5, 6, -10, 100, 3},
{-1000, 1, 20},
{999, 12, 300, 50}
};
//Définir la variable max pour mettre la valeur maximale
int max = 0;
//Définir la variable min pour mettre la valeur minimale
int min = 0;
//Regardez la première dimension du tableau des nombres un par un
for(int i = 0; i < numbers.length; i++) {
// numbers[0]、numbers[1]、numbers[2]Regardez le contenu de, un par un
for(int j = 0; j < numbers[i].length; j++) {
// numbers[0]、numbers[1]、numbers[2]S'il y a un nombre supérieur à max dans
if(max < numbers[i][j]) {
//Remplacez ce nombre par la variable max
max = numbers[i][j];
}
// numbers[0]、numbers[1]、numbers[2]S'il y a un nombre inférieur à min dans
if(min > numbers[i][j]) {
//Remplacez ce nombre par la variable min
min = numbers[i][j];
}
}
}
System.out.println("Valeur maximale dans le tableau des nombres: " + max); // Valeur maximale dans le tableau des nombres:Sortie comme 999
System.out.println("Valeur minimale du tableau de nombres: " + min); // Valeur minimale du tableau de nombres: -Sortie comme 1000
}
}
Les éléments du tableau sont comparés un par un à l'aide de l'instruction for (un article séparé sera décrit pour le traitement itératif).
S'il y a un grand nombre ou un petit nombre, la valeur est affectée à la variable de valeur maximale max et à la variable de valeur minimale min à chaque fois.
C'est facile, mais j'ai appris sur les tableaux.
Le nombre d'éléments dans le tableau a été fixe, mais il existe également une liste variable. Je voudrais couvrir cela dans un autre article.
Étant donné que plusieurs données peuvent être utilisées, il existe de nombreuses possibilités de les utiliser. Je veux le tenir fermement.
Recommended Posts