Je n'ai pas bien compris le comportement de Java Array et ArrayList, j'ai donc essayé de résumer les parties susceptibles d'être utilisées fréquemment.
Main1 décrit comment créer Array et Main2 décrit comment créer ArrayList et comment obtenir des valeurs. Main3 et Main4 décrivent chaque tableau multidimensionnel.
Main1
Main1.java
import java.util.Arrays;
/**
* Created 2017/05/24.
*Liste du comportement normal des tableaux dans Main1
*/
public class Main1 {
public static void main(String[] args) {
//Comment créer un tableau
//Méthode de déclaration 1
//Déclarez le type et le nom du tableau
//int[] num;
//Sécurisez la zone à utiliser
//num = new int[3];
//Méthode de déclaration 2
//Comment faire la méthode ci-dessus en même temps
int[] num = new int[3];
//Stockage dans une baie
num[0] = 1;
num[1] = 2;
num[2] = 3;
//Quand vous faites tout, de la création au stockage
// int[] num = {1, 2, 3};
//Extraction de séquence
System.out.println(num[0]);
//Résultat d'exécution: 1
//Comment tout emporter en même temps
//Lors d'une boucle avec une instruction for normale
for (int i = 0; i < num.length; i++) {
System.out.print(num[i] + " ");
//Résultat d'exécution: 1 2 3
}
System.out.println(" "); //Je l'ai mis pour l'apparence après l'exécution
//Lors de l'utilisation de l'instruction Extended for
for (int value : num) {
//value est un nom de variable arbitraire,Contrairement à l'ordinaire pour, le nom de la variable est utilisé tel quel
System.out.print(value + " ");
//Résultat d'exécution: 1 2 3
}
System.out.println(" "); //Comme ci-dessus
//Comment afficher le contenu d'un tableau à la fois (méthode p en Ruby)
// Arrays.Ça fait du bien d'utiliser toString
//Par précaution lors de l'utilisation, importez java lors de l'utilisation.util.Arrays;Besoin de déclarer
//L'autre est Arrays lorsque le tableau cible est un tableau multidimensionnel..Doit être écrit comme deepToString
System.out.println(Arrays.toString(num));
//Résultat de l'exécution:[1, 2, 3]
//Si vous l'écrivez comme ça, cela devient une chaîne de caractères mystérieuse
System.out.println(num);
//Résultat d'exécution:[I@1540e19d
//Règles supplémentaires et ainsi de suite
//Array ne peut pas stocker plus que le nombre d'éléments déclarés au début
//num[3] = 4; //Cela n'a pas de sens d'écrire pour stocker 4 à la 4ème place du tableau, cela ne correspond pas réellement
//System.out.println(num[3]);
//En tant que comportement, il n'y a pas d'erreur de compilation, mais il y a une erreur d'exécution.
//Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException:Mets-toi en colère comme 3
//En outre, lorsque la déclaration de stockage dans le tableau n'est pas effectuée, par exemple, num[5]Et num[6]J'obtiens la même erreur en essayant d'afficher la valeur de
}
}
Résultat d'exécution
Main1.Java
1
1 2 3
1 2 3
[1, 2, 3]
[I@1540e19d
Main2
Main2.java
import java.util.ArrayList;
/**
* Created 2017/05/24.
*Main2 décrit le comportement normal de ArraysList
*/
public class Main2 {
public static void main(String[] args) {
//Comment créer une ArrayList
//Déclaration de base
//ArrayList<Integer> num = new ArrayList<Integer>();
//Exemple de définition de Java SE 7 ou version ultérieure
ArrayList<Integer> num = new ArrayList<>();
//Supplément
//new ArrayList<>();de()は、数値を入れることで、配列de初期サイズを決めることが出来る
//Méthode de stockage
//Utilisez la méthode add
//Ajouter comme manière d'écrire(Données que vous souhaitez stocker), ou ajouter(Index (position de stockage),Données que vous souhaitez stocker)Décrit dans
//Il est essentiellement stocké dans l'ordre
//Si la valeur existe déjà lorsque l'index est spécifié,Notez que la valeur est stockée de sorte qu'elle se décale horizontalement au lieu de l'écraser.
num.add(1);
num.add(1, 2);
num.add(3);
//num.add(2,4);
//Si vous ajoutez comme ça,[1,2,4]ne pas[1,2,4,3]Veuillez noter que ce sera un tableau
//Si vous souhaitez mettre à jour la valeur num.set(2,4);comme,.set()Avec[1.2,4]Peut être obtenu
//Extraire la valeur
//get()Utiliser la méthode
System.out.println(num.get(0));
//Résultat d'exécution: 1
//Sortir à la main
//pour déclaration
//Pour ArrayList, pour obtenir le nombre d'éléments.size()utilisation
for (int i = 0; i < num.size(); i++) {
System.out.print(num.get(i) + " ");
//Résultat d'exécution:1 2 3
}
System.out.println(" ");
//Étendu pour déclaration
for (int value : num) {
System.out.print(value + " ");
//Résultat d'exécution:1 2 3
}
System.out.println(" ");
//Lorsque vous affichez tout en même temps comme la méthode p, mettez-le simplement dans println tel quel
System.out.println(num);
//Résultat d'exécution:[1, 2, 3]
}
}
Résultat d'exécution
Main2.java
1
1 2 3
1 2 3
[1, 2, 3]
Main3
Main3.java
import java.util.Arrays;
/**
* Created 2017/05/24.
*Dans Main3, une liste de comportements lors de la création d'un tableau multidimensionnel dans un tableau normal
*/
public class Main3 {
public static void main(String[] args){
//Déclaration et création
int [][] num = new int[2][3];
//Stockage de valeur
num[0][0] = 1;
num[0][1] = 2;
num[0][2] = 3;
num[1][0] = 10;
num[1][1] = 11;
num[1][2] = 12;
//Comment récupérer la valeur
System.out.println(num[0][0]);
//Résultat d'exécution:1
System.out.println(num[1][2]);
//Résultat d'exécution:12
//Lorsque vous sortez tout en même temps
//Double boucle utilisant pour
//i est le nombre total d'éléments en num, num.Boucle par longueur
for(int i = 0; i < num.length; i++){
//j est le nombre d'éléments dans chaque tableau, num[i].Boucle à longueur
for(int j = 0; j < num[i].length;j++){
System.out.print(num[i][j] + " ");
//Résultat d'exécution: 1 2 3 10 11 12
}
}
System.out.println(" ");
//Pour prolongé pour
//Ceci est également écrit dans une double boucle
//Spécifiez un tableau comme données à récupérer
for(int[] index : num) {
//Ensuite, retirez le contenu de l'arrangement
for (int element : index) {
System.out.print(element + " ");
//Résultat d'exécution: 1 2 3 10 11 12
}
}
System.out.println(" ");
//Affichage par lots
//Tableaux pour tableaux multidimensionnels.deepToString();utilisation
System.out.println(Arrays.deepToString(num));
//Résultat d'exécution:[[1, 2, 3], [10, 11, 12]]
}
}
Résultat d'exécution
Main3.java
1
12
1 2 3 10 11 12
1 2 3 10 11 12
[[1, 2, 3], [10, 11, 12]]
Main4
Main4.java
import java.util.ArrayList;
/**
* Created 2017/05/24.
* *Main4 décrit le comportement multidimensionnel de ArraysList
*Je peux le comprendre, mais c'est difficile à gérer
*/
public class Main4 {
public static void main(String[] args){
//Comment créer une ArrayList bidimensionnelle
//Tout d'abord, créez deux ArrayLists ordinaires)
ArrayList<Integer> num1 = new ArrayList();
num1.add(1);
num1.add(2);
num1.add(3);
System.out.println(num1);
//Résultat d'exécution:[1, 2, 3]
ArrayList<Integer> num2 = new ArrayList<Integer>();
num2.add(10);
num2.add(11);
num2.add(12);
System.out.println(num2);
//Résultat d'exécution:[10, 11, 12]
//Ensuite, créez une ArrayList à stocker, faites attention au type de données à déclarer
//Lors de la déclaration du type de données, les données à stocker sont "ArrayList"<Integer>Boutique! Peut être saisi en déclarant
ArrayList<ArrayList<Integer>> num_list =new ArrayList<>();
num_list.add(num1);
num_list.add(num2);
//Comment sortir
//.get().get()Sortez avec
System.out.println(num_list.get(0).get(0));
//Résultat d'exécution:1
System.out.println(num_list.get(0).get(2));
//Résultat d'exécution:3
System.out.println(num_list.get(1).get(0));
//Résultat d'exécution:10
//Sortez tout
//for
//i est le nombre total d'éléments en num, num.size()Boucle avec
for(int i = 0; i < num_list.size(); i++){
//j est le nombre d'éléments dans chaque tableau, num[i].size(()Boucle vers
for(int j = 0; j < num_list.get(i).size();j++){
System.out.print(num_list.get(i).get(j) + " ");
//Résultat d'exécution:1 2 3 10 11 12
}
}
System.out.println(" ");
//Extension pour
//ArrayList dans la déclaration de variable<Integer>Si vous le déclarez avec + nom de variable, vous pouvez extraire la valeur!
for(ArrayList<Integer> index : num_list) {
//Le reste est décrit dans une instruction normale étendue pour
for (int element : index) {
System.out.print(element + " ");
//Résultat d'exécution:1 2 3 10 11 12
}
}
System.out.println(" ");
//Affichage des lots
System.out.println(num_list);
//Résultat d'exécution:[[1, 2, 3], [10, 11, 12]]
//Comment ajouter une valeur
//.add()Vous pouvez utiliser, mais devez-vous ajouter chaque tableau ou créer un nouveau tableau et l'ajouter?
//num_list.add()Je veux l'ajouter directement sous la forme de, mais je ne sais pas après tout
num1.add(4);
num2.add(13);
//Ajouter un nouveau tableau
ArrayList<Integer> num3 = new ArrayList<Integer>();
num3.add(20);
num3.add(21);
num3.add(22);
num_list.add(num3);
System.out.println(num_list);
//Résultat d'exécution[[1, 2, 3, 4], [10, 11, 12, 13], [20, 21, 22]]
}
}
Résultat d'exécution
Main4.java
[1, 2, 3]
[10, 11, 12]
1
3
10
1 2 3 10 11 12
1 2 3 10 11 12
[[1, 2, 3], [10, 11, 12]]
[[1, 2, 3, 4], [10, 11, 12, 13], [20, 21, 22]]
À l'origine, je faisais Ruby, donc les tableaux de longueur variable comme ArrayList étaient intuitivement plus faciles à utiliser. Lorsqu'il s'agit de tableaux multidimensionnels, l'impression est qu'ArrayList est déroutant et difficile à comprendre. Je ne sais toujours pas comment utiliser ces deux-là, alors j'aimerais bien étudier.
Recommended Posts