D'une manière générale, les structures de données dans les manuels incluent des tableaux, des listes liées uniques, des piles, des arbres et des graphiques. La structure de données dont je parle ici est une question de savoir comment représenter un objet. Parfois, une seule déclaration variable est inutile, telle que int, String, double ou même des tableaux unidimensionnels et des tableaux bidimensionnels ne peuvent pas exprimer pleinement ce que vous voulez exprimer, et il est trop difficile de définir une classe de classe. Pour le moment, vous pouvez envisager d'utiliser la classe de collections en Java. À l'aide de la classe de collections, vous devez déclarer l'importation java.util. * Dans l'en-tête de fichier;
1. Dynamique, ordonné, vecteur de tableau unidimensionnel de taille variable
La classe de collections comprend un vecteur de tableau unidimensionnel et une liste d'array-array.
La seule différence entre Vector et ArrayList est: Vector est livré avec des threads mutuellement exclusifs, et plusieurs threads lanceront des exceptions pour lire et écrire, tandis que ArrayList permet à plusieurs threads de lire et d'écrire, et les autres parties sont exactement les mêmes. En d'autres termes, si un seul thread lit et écrit, il n'y a pas de différence entre l'utilisation de Vector et ArrayList, mais maintenant la programmation est essentiellement ArrayList, et l'utilisation de Vector est un peu sans flux.
1. L'utilisation du vecteur est la suivante:
public static void vectorTest () {// vector <pouct> signifie que ce vecteur ne peut stocker que le double // vector <string> signifie que ce vecteur ne peut stocker que String // bien que Vector <Bject> vector = new vector <objet> (); est équivalent à vector vector = new // vector (); Cependant, l'écriture de ceci dans Eclipse vous avertira, indiquant que votre vecteur n'est pas standardisé, () vector <Object> vector = new vector <object> (); vector.add (1.6); vector.add (2.06); vector.add (1); System.out.println ("Add simple signifie ajouter des éléments de la fin:" + vecteur); System.out.println ("size () peut trouver le nombre d'éléments contenus dans le vecteur:" + vector.size ()); Vector.Remove (1); System.out.println ("Supprimer (1) signifie supprimer le premier élément, car le nombre commence à partir de 0, c'est-à-dire l'élément 2.06:" + vecteur); Vector.Remove (Vector.Lastelement ()); System.out.println ("Le vecteur qui supprime le dernier élément est:" + vecteur); vector.add (0, 1.8888); System.out.println ("Ajouter 1.8888 cet élément à la 0e position:" + vecteur); vector.set (0, "a"); System.out.println ("Modifier la 0e position:" + vecteur); } Si cette méthode est appelée dans la fonction principale:
System.out.println ("======== Début de la structure des données vectorielles =========="); VectorTest (); System.out.println ("======== Test End of Vector Data Structure ============); Les résultats de l'opération sont les suivants:
======= Test Démarrage de la structure des données vectorielles ======
Un ADD simple signifie ajouter des éléments de la fin: [1.6, 2.06, 1]
size () peut trouver le nombre d'éléments contenus dans le vecteur: 3
Supprimer (1) signifie supprimer le premier élément. Étant donné que le décompte commence à 0, c'est-à-dire l'élément 2.06: [1.6, 1]
Le vecteur qui supprime le dernier élément est: [1.6]
Ajoutez l'élément 1.8888 en position 0e: [1.8888, 1.6]
Modifiez l'élément à la 0e position en a: [a, 1.6]
======== Test End of Vector Data Structure ======
2. ArrayList
public static void ArrayListTest () {ArrayList <Double> ArrayList = new ArrayList <Double> (); arrayList.add (1.0); arrayList.add (4.0); ArrayList.add (5.0); ArrayList.add (2.3); System.out.println ("Add simple signifie ajouter des éléments de la fin:" + ArrayList); System.out.println ("size () peut trouver le nombre d'éléments contenus:" + arrayList.size ()); ArrayList.Remove (1); System.out.println ("Supprimer (1) signifie supprimer le premier élément. Étant donné que le nombre commence à partir de 0, c'est-à-dire l'élément 4:" + ArrayList); ArrayList.Remove (ArrayList.Size () - 1); System.out.println ("Le ArrayList pour la suppression du dernier élément est:" + ArrayList); ArrayList.add (0, 1.8888); System.out.println ("Ajouter un élément 1.8888 à la 0e position:" + ArrayList); ArrayList.set (0, 9.0); System.out.println ("Modifiez l'élément à la 0e position en A:" + ArrayList); Collection.Sort (ArrayList); System.out.println ("Le tri est pris en charge si ArrayList n'est pas un type abstrait" + ArrayList); } Ici, vous pouvez voir que la façon dont ArrayList supprime le dernier élément est différente du vecteur. La raison principale est que ArrayList n'a pas la méthode LasteElement () pour supprimer le dernier élément. Retirer () ne peut être utilisé que pour déterminer la position du dernier élément. Si cette méthode est appelée dans la fonction principale comme ceci:
System.out.println ("========= Début de la structure de données ArrayList ========"); ArrayListTest (); System.out.println ("======== Test End of ArrayList Data Structure ===============); Ensuite, les résultats en cours d'exécution suivants sont obtenus:
======= Test Démarrage de la structure des données ArrayList ======
Un ADD simple signifie ajouter des éléments de la fin: [1.0, 4.0, 5.0, 2.3]
size () peut trouver le nombre d'éléments contenus: 4
Supprimer (1) signifie supprimer le premier élément. Étant donné que le décompte commence à 0, c'est-à-dire l'élément 4: [1.0, 5.0, 2.3]
La liste Array pour supprimer le dernier élément est: [1.0, 5.0]
Ajoutez l'élément 1.8888 en position 0e: [1.8888, 1.0, 5.0]
Modifiez l'élément à la 0e position en A: [9.0, 1.0, 5.0]
Si ArrayList n'est pas un type abstrait, le tri est pris en charge [1.0, 5.0, 9.0]
======== Test End of ArrayList Data Structure ======
D'après les deux exemples ci-dessus, nous pouvons voir que Vector et ArrayList sont plus qu'un tableau ordinaire, c'est-à-dire le tableau unidimensionnel enseigné dans le tableau Int de manuel [] = {8, 7, 100, 88, 6, 4, 5, 33, 7}; C'est beaucoup plus puissant. Vous pouvez insérer des éléments à n'importe quelle position, ou vous pouvez supprimer des éléments à une position spécifiée sans traverser le tableau. Bien sûr, vous devez toujours savoir comment ce tableau est traversé pour vous. En fait, ArrayList et les tableaux unidimensionnels ordinaires peuvent être complètement transformés, et ArrayList peut également être utilisé pour trier le tableau directement sans écrire un tri de bulles sur le tableau. Vous pouvez trier le tableau directement avec Collection.Sort (); puis utiliser des collection.reverse (); pour atteindre le tri inverse. Bien sûr, c'est toujours la même phrase. Pour vous, vous devez toujours savoir comment ce tableau est trié.
Par exemple, la méthode suivante met en œuvre le tri et le tri inverse du tableau de tableau unidimensionnel INT [] = {8, 7, 100, 88, 6, 4, 5, 33, 7}; Convertissez d'abord le tableau en ArrayList, puis triez-le avec Collection.Sort (); et collections.reverse ();, et enfin convertir le contenu ArrayList en un tableau unidimensionnel:
public static void arraylistSort () {int array [] = {8, 7, 100, 88, 6, 4, 5, 33, 7}; ArrayList <Integer> ArrayList = new ArrayList <Integer> (); for (int i = 0; i <array.length; i ++) System.out.print (array [i] + ","); pour (int i = 0; i <array.length; i ++) arrayList.add (array [i]); Collection.Sort (ArrayList); pour (int i = 0; i <array.length; i ++) arrayList.add (array [i]); Collection.Sort (ArrayList); pour (int i = 0; i <array.length; i <array.length; i ++) arrayList.add (array [i]); Collection.Sort (ArrayList); pour (int i = 0; i <array.length; i <array.length; i ++) arrayList.add (array [i]); Collection.Sort (ArrayList); pour (int i = 0; i <array.length; i ++) array [i] = arrayList.get (i); System.out.print ("Array trié:"); for (int i = 0; i <array.length; i ++) System.out.print (array [i] + ","); Collection.Reverse (ArrayList); pour (int i = 0; i <array.length; i ++) array [i] = arrayList.get (i); System.out.print ("Array trié inversement:"); for (int i = 0; i <array.length; i ++) System.out.print (array [i] + ","); // Détruisez la liste Array après le tri. ArrayList = null; // Cette phrase suggère que Java recycle les ordures immédiatement. Bien sûr, que cette phrase soit OK ou non, Java supprimera automatiquement les ordures pendant le processus d'exécution; } Dans la fonction principale, la méthode est appelée ceci:
System.out.println ("========== Java Array Sy Start =========="); ArrayListsTort (); System.out.println ("============= Java Triement du tableau Ends =========); Vous pouvez obtenir les résultats en cours d'exécution suivants:
======== Le tri du tableau Java commence ======
8,7,100,88,6,4,5,33,7, tableau trié: 4,5,6,7,7,8,33,88,100, tableau trié inversement: 100,88,33,8,7,7,6,5,4,
========= Java Triy Triing Ends ======
De plus, il en va de même pour la précédente "Une brève introduction à l'utilisation de la liste dans Java" (cliquez pour ouvrir le lien)
2. Collection Hashset
De plus, il existe un hashset de collection, qui est exactement le même que le concept de collection mathématique. Un ensemble composé d'un ou plusieurs éléments est appelé un ensemble. Hashset a:
1. Déterminisme . Les éléments de l'ensemble doivent être déterministes. C'est un non-sens. Il doit être déterministe. Puis-je encore y mettre une chose incertaine?
2. Sex opposé mutuel , les éléments de l'ensemble sont différents. Par exemple: Définissez A = {1, A}, alors A ne peut pas être égal à 1, c'est-à-dire que si vous mettez deux 1 dans un hashset, il deviendra automatiquement un 1
3. Trouble , il n'y a pas d'ordre d'éléments dans l'ensemble. Par conséquent, HashSet ne doit pas effectuer d'opérations de tri, par exemple, la méthode suivante:
public static void hashSetTest () {hashSet <Bject> hashSet = new HashSet <Bject> (); hashset.add (1); hashset.add (1); hashset.add (5); hashset.add (2.3); System.out.println ("Add simple signifie ajouter des éléments de la fin:" + hashset); System.out.println ("size () peut trouver le nombre d'éléments contenus:" + hashSet.size ()); hashset.remove (1); System.out.println ("Supprimer (1) signifie supprimer l'élément '1':" + hashset); hashSet.Remove ("ASD"); System.out.println ("S'il n'y a pas d'élément 'ASD', supprime ne fait rien:" + hashset); hashset.add (1.8888); System.out.println ("Ajouter un élément 1.8888:" + hashset); }Dans la fonction principale, appelez cette méthode:
System.out.println ("========= Démarrage du test de la structure des données HashSet ========"); HashSetTest (); System.out.println ("========= Test End of Hashset Data Structure ===============); Les résultats sont les suivants:
======= Le test commence par la structure des données de hashset ======
Un ADD simple signifie ajouter des éléments de la fin: [1, 5, 2.3]
size () peut trouver le nombre d'éléments contenus: 3
Supprimer (1) signifie supprimer l'élément «1»: [5, 2.3]
Sans l'élément «ASD», supprimer ne fait rien: [5, 2.3]
Ajouter l'élément 1.8888: [5, 1.8888, 2.3]
======== Test End of Hashset Data Structure ======
HashSet a la méthode Add () et la méthode retire (). Les éléments ajoutés pour ajouter () sont en ordre. Les résultats imprimés avec System.out.println () peuvent être dans différents ordres. Ils ne peuvent pas être les mêmes que le vecteur et l'arrayList ci-dessus. Tant que les éléments stockés ne sont pas des objets, Collection.Sort (ArrayList); peut être utilisé pour les trier.
3. Double hashmap
La méthode d'utilisation ici est essentiellement la même que les données ci-dessus, et elle est également très simple. C'est pour mettre l'objet dans la carte et obtenir peut enlever les objets de la carte, mais il est mal d'essayer d'utiliser le hashmap binaire en triple. Si un objet contient trop d'éléments, vous devriez envisager d'utiliser des classes. Au lieu d'être obsédé par la classe de collections de Java qui interfère entre les variables ordinaires et les classes de classe.
Par exemple, la méthode suivante montre le fonctionnement d'erreur d'essayer de modifier Hashmap en triple:
public static void Maptest () {System.out.println ("=========== Début de l'utilisation de la carte Erreur ============); Hashmap <String, String> Map = New Hashmap <String, String> (); Hashmap <String, Hashmap <String, String >> String >> (); System.out.println (bigmap.get ("test1"). Get ("key1"); System.out.println (bigmap.get ("test2"). Get ("key2")); incorrectly================================================================================================================ ======================================================================. =======================================================================. ======================================================================. =======================================================================. =======================================================================. =======================================================================. L'appel de ce code dans la fonction principale donne le résultat d'exécution suivant:
======== Le test commence par la structure des données de la carte ======
======== Début de l'utilisation de l'erreur de carte ======
{test1 = {key2 = 4, key1 = 3}, test2 = {key2 = 4, key1 = 3}}
3
4
3
4
======= Fin de l'utilisation de la carte Erreur ======
========= Démarrage de l'utilisation correcte de la carte ======
{key3 = 3, key2 = 2, key1 = 1}
======== Fin de l'utilisation correcte de la carte ======
======== Test End of Map Data Structure ======
Ce programme était à l'origine destiné à être très évident, essayant de construire un {test1, key1,1}, {test1, key2,2}, {test2, key3,3}, {test2, key4,4}
Cependant, chaque bigmap a encore cette carte. Une fois que vous avez effacé la carte, la carte de Test1 sera également effacée. Quelqu'un a essayé de créer plusieurs Map1, Map2, ... Ensuite, vous pourriez aussi bien utiliser une classe simple pour paraître plus claire, et vous pouvez écrire des méthodes dans la classe à l'avenir et être héréditaire
4. Notes
Lors de la création d'un nouveau vecteur, arraylist, hashset ou hashmap, vous pouvez l'écrire comme:
Collection <string> a = new ArrayList <string> ();
List <string> a = new vector <string> ();
Parce qu'il y a ArrayList, Vector, LinkedList, Hashset et Treeset qui héritent de l'interface de collection, et hashmap et hashtable qui héritent de l'interface de carte, il s'agit d'un problème d'héritage, de polymorphisme, d'encapsulation et d'autres classes de Java. Bien sûr, pour que vos compagnons puissent voir plus clairement, ne jouez pas à la dénomination fantaisie ici, écrivez un ArrayList Clear Array <Integer> ArrayList = new ArrayList <Integer> (); Personne n'ose dire que vous ne comprenez pas les cours en Java.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.