[Ici](https://yk0807.com/techblog/2020/03/05/java%e3%81%ae%e3%82%b3%e3%83%ac%e3%82%af%e3%82% b7% e3% 83% a7% e3% 83% b3% e5% 85% a5% e9% 96% 80% ef% bc% 8b% ce% b1 /) article de blog publié sur Qiita.
Non limité à Java, il existe de nombreux cas où les tableaux seuls ne fonctionnent pas bien pour organiser les données dans la programmation. Par conséquent, la structure des données devient importante et la méthode d'expression qui l'entoure varie en fonction de la langue.
Pour C ++, il existe des conteneurs pour les bibliothèques vectorielles, de listes et standard, et pour C #, il semble utiliser quelque chose appelé LINQ. Avec PHP, vous pouvez faire beaucoup avec les tableaux (vous devez être prudent lorsque vous l'utilisez). Avec Python, on a l'impression d'utiliser des types de liste, des tapples, des dictionnaires, etc. selon le but.
Eh bien, Java. Java utilise un framework de collecte. Dans le cadre de collecte, des listes (les valeurs sont ordonnées), des ensembles (les valeurs ne sont pas nécessairement ordonnées, mais une seule valeur est la même), une carte (les valeurs correspondent à chaque clé). Nous avons un ensemble complet de structures de données nécessaires pour exprimer des données telles que (il existe également un Deque qui ne peut entrer et sortir que des valeurs des deux extrémités, mais il est omis cette fois car son utilisation est limitée).
Tout d'abord, une liste. La liste est ** contenant des données pour chaque index à partir de ** 0. Il est implémenté sur la base de l'interface List, et deux classes, ArrayList (tableau de longueur variable) et LinkedList (liste liée), sont souvent utilisées. ArrayList est comme un vecteur en C ++. Java a également une classe Vector, mais elle est obsolète dans Java 8 et versions ultérieures. Chacun est défini comme suit.
List<Integer> arrayList = new ArrayList<>();
List<Integer> linkedList = new LinkedList<>();
La classe dans laquelle vous définissez est déterminée lorsque vous appelez le constructeur. À propos, le <> entre la classe et la parenthèse est appelé l'opérateur losange, qui est une notation pour omettre le type d'élément. Les opérations fréquemment utilisées sont les suivantes. Bien qu'il soit décrit pour ArrayList, le traitement à effectuer est le même même pour LinkedList.
List<String> arrayList = new ArrayList<>();
List<String> linkedList = new LinkedList<>();
arrayList.add("Apple"); //Élément à la fin de la liste"Apple"Ajouter
arrayList.get(5); //5 dans la liste+Obtenez le premier élément
arrayList.set(3, "Orange"); //Liste 3+La valeur du premier élément"Orange"Mis à
arrayList.remove(4); //4 dans la liste+Supprime le premier élément et décrémente les index suivants de un
arrayList.size(); //Renvoie le nombre d'éléments de la liste
arrayList.clear(); //Vider la liste
//Sortie de la liste d'éléments de arrayList
for (String data : arrayList) {
System.out.println(data);
}
Cependant, bien que j'aie écrit plus haut que "le traitement à effectuer est le même", ArrayList et LinkedList ont des méthodes d'implémentation différentes, donc ils peuvent avoir leurs propres forces et faiblesses. Pour obtenir et définir, ArrayList où chaque élément est indexé en mémoire est plus rapide, et pour ajouter et supprimer, lier les informations entre les éléments (image comme un pointeur en langage C. Java n'a pas de pointeur) LinkedList connecté par) peut être plus rapide. Par conséquent, si vous apportez des données volumineuses à partir d'une base de données et que le but principal est d'accéder aux éléments qu'elle contient, ArrayList convient et si des données sont fréquemment ajoutées ou supprimées de la liste, LinkedList convient.
Un ensemble est une collection de données comme une liste, mais contrairement à une liste, il n'y a pas d'index **, et vous ne pouvez pas en avoir plus d'un avec la même valeur **. J'espère que ceux qui ont étudié les mathématiques à l'université pourront imaginer un ensemble / ensemble de phases. Ceci est implémenté sur la base de l'interface Set, et HashSet, TreeSet et LinkedHashSet sont souvent utilisés. Chacun est défini comme suit.
Set<String> hashSet = new HashSet<>();
Set<String> treeList = new TreeList<>();
Set<String> linkedHashSet = new LinkedHashSet<>();
L'opération de base est la suivante. J'écris pour HashSet, mais les deux autres sont identiques. Veuillez noter que ** get et set sont manquants **.
Set<String> hashSet = new HashSet<>();
Set<String> treeSet = new TreeSet<>();
Set<String> linkedHashSet = new LinkedHashSet<>();
hashSet.add("Banana"); //Aux éléments de l'ensemble"Banana"Si non inclus, ajoutez
hashSet.remove("Lemon"); //À l'ensemble"Lemon"S'il est inclus, supprimez-le
hashSet.size(); //Renvoie le nombre d'éléments de l'ensemble
//Sortie d'une liste d'éléments hashSet
for (String data : hashSet) {
System.out.println(data);
}
La différence entre HashSet, TreeSet et LinkedHashSet est que HashSet est plus rapide mais que l'ordre n'est pas du tout garanti, TreeSet conserve les éléments triés et LinkedHashSet conserve l'ordre dans lequel les éléments sont ajoutés.
treeSet.add("Banana");
treeSet.add("Orange");
treeSet.add("Apple");
for (String data : treeSet) {
System.out.println(data);
}
Ensuite, il est sorti dans l'ordre "Pomme" -> "Banane" -> "Orange".
linkedHashSet.add("Banana");
linkedHashSet.add("Orange");
linkedHashSet.add("Apple");
for (String data : linkedHashSet) {
System.out.println(data);
}
Ensuite, il sera sorti dans l'ordre "Banana" -> "Orange" -> "Apple".
Les cartes contiennent non seulement des valeurs, mais également ** des données associées à des clés qui spécifient des valeurs **. Les clés sont uniques sur la carte (il n'y a pas de valeurs identiques multiples), mais plusieurs valeurs peuvent être identiques. Les cartes sont implémentées sur la base de l'interface Map, et HashMap, TreMap et LinkedHashMap sont souvent utilisés. Chacun est défini comme suit.
Map<String, Integer> hashMap = new HashMap<>();
Map<String, Integer> treeMap = new TreeMap<>();
Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
L'opération de base est la suivante. Utilisez la méthode put pour ajouter une combinaison clé / valeur à la carte.
Map<String, Integer> hashMap = new HashMap<>();
Map<String, Integer> treeMap = new TreeMap<>();
Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
hashMap.put("Tomato", 300); //Carte clé"Tomato"Définissez la valeur sur 300
hashMap.get("Tomato"); //La clé de la carte est"Tomato"Renvoie la valeur de (nulle sinon)
hashMap.remove("Lemon"); //La clé est sur la carte"Lemon"Supprimer s'il contient
hashMap.size(); //Renvoie le nombre d'éléments de la carte
//Clé pour chaque élément de la carte:Sortie sous forme de valeur
for (Map.Entry<String, Integer> data : hashSet.entrySet()) {
System.out.println(data.getKey() + ":" + data.getValue());
}
La sortie de toutes les données prend un peu plus de temps que les autres. Comme l'ensemble, HashMap est rapide mais l'ordre n'est pas garanti, TreeMap contient les données dans l'ordre des clés et LinkedHashMap conserve les données dans l'ordre dans lequel les données ont été ajoutées.
J'ai jeté un coup d'œil aux collections que j'utilise habituellement en Java. Il semble y en avoir plusieurs autres, mais si vous pouvez maîtriser celles introduites cette fois en fonction de la finalité, je pense qu'il n'y aura pas beaucoup de problèmes dans la gestion des données en Java. J'avais l'habitude de définir des données pour une combinaison d'un nom et d'un objet dans HashMap, mais je me suis rendu compte qu'il était nécessaire de sortir dans l'ordre croissant du nom en cours de route, alors je l'ai rapidement réécrit dans TreeMap. Lorsque vous utilisez une collection, pensez à ce que vous visez et choisissez celle qui vous convient le mieux.
Recommended Posts