Explication détaillée du cadre de la collection Java

1. Présentation du cadre de la collection Java

Java SE comprend un cadre de collection Java (JCF) composé d'un ensemble de classes et d'interfaces. Sa fonction principale est d'organiser des données stockées dans une certaine structure et d'accéder à ces données de manière spécifique. Son objectif est de fournir un cadre général pour le traitement des collections d'objets et de réduire la quantité de codage que les programmeurs utilisent lors du traitement des différentes collections d'objets.

Certaines différences dans les classes de collecte, en plus qu'elles prennent en charge les opérations d'éléments en double, incluent si les éléments sont en ordre et si des éléments nuls peuvent être ajoutés. Selon ces trois différences dans le cadre de la collection Java, les méthodes de stockage des objets sont divisées en trois types, à savoir:

1. SET: Les objets du conteneur d'objets n'ont pas d'ordre et ne peuvent pas être répétés.
2. Liste: les objets du conteneur d'objets sont triés dans l'ordre d'index, et il peut y avoir des objets en double.
3. MAP: Les éléments du conteneur d'objet contiennent une paire de cartes de "objet d'objet de clé de clé", où l'objet clé ne peut pas être répété et l'objet de valeur peut être répété.

Afin de prendre en charge les opérations d'accès de tri et de traversée des objets, plusieurs interfaces sont fournies dans le cadre de la collection Java:

1. L'interface trisedset fournit des fonctions de tournage pour les conteneurs de type set.
2. Interface tridmap fournit le tri des objets clés pour les conteneurs de type de carte.
3. L'interface comparable et le comparateur sont utilisés pour implémenter le tri des objets dans la collection.

2. Interface de collecte et interface d'itérateur

Certaines méthodes de base partagées par des objets de collection sont définies dans l'interface de collection.

L'interface itérateur est une interface utilisée pour traverser une collection.

1. Éliminer l'interface

L'interface de liste est héritée de l'interface de collecte et a les caractéristiques suivantes:

1. Les éléments de la liste sont en ordre.
2. Les listes permettent généralement des éléments répétés.
3. Les classes d'implémentation de liste prennent généralement en charge les éléments nuls.
4. Les éléments du conteneur d'objets de liste sont accessibles via des index.

Les classes d'implémentation les plus couramment utilisées pour l'interface de liste sont la classe ArrayList et la classe LinkedList.

1) .ArrayList

Exemple du programme:

 Package Lei; import java.util.arraylist; Importer java.util.list; classe publique test {public static void main (String [] args) {list list = new ArrayList <> (); list.add (1); list.add ("zhangsan"); list.add (false); list.add ('a'); list.add (0, "Lisi"); list.add (1); list.remove (1); list.remove (2); list.set (0, "wangwu"); for (int i = 0; i <list.size (); i ++) {System.out.println (list.get (i)); }}}

La méthode equals () définie par la classe d'objets ne renvoie pas vrai uniquement lorsque l'objet transmis à la méthode et l'objet appelant la méthode est le même objet. Deux objets avec le même état peuvent être considérés comme le même objet en écrasant la méthode equals ().

2).

Exemple du programme:

 Package Lei; import java.util.linkedlist; Importer java.util.list; classe publique test2 {public static void main (String [] args) {LinkedList l = new LinkedList <> (); L.Add ("Zhangsan"); L.Add ("Lisi"); L.AddFirst (1); L.Addlast (4); System.out.println (l.getFirst ()); System.out.println (l.getLast ()); L.RemoveFirst (); L.Removelast (); for (int i = 0; i <l.size (); i ++) {System.out.println (l.get (i)); }}}

Sélection de LinkedList contre ArrayList

Si la liste doit être rapidement accessible mais n'insert pas et ne supprime pas fréquemment les éléments, il sera préférable de sélectionner ArrayList; Si la liste doit être fréquemment insérée et supprimée, vous devez sélectionner LinkedList.

2.Set Interface

L'interface définie hérite de l'interface de collection et hérite également de toutes les méthodes de l'interface de collecte. L'interface définie a les caractéristiques suivantes:

1. Le conteneur de type set ne peut pas contenir des éléments en double. Lorsque vous ajoutez un élément au conteneur, vous souhaitez comparer si le contenu de l'élément est dupliqué, donc l'objet qui ajoute le conteneur de type de type set doit remplacer la méthode equals ().
2. Les éléments peuvent être en ordre ou il ne peut y avoir aucune commande.
3. Étant donné que les éléments peuvent ne pas avoir de commande, les éléments intégrés de l'ensemble ne sont pas accessibles en fonction des indices.

Les plus couramment utilisées pour implémenter l'interface SET sont la classe HashSet et la classe TreeSet.

1) .Hashset

La classe HashSet est une implémentation d'interface définie basée sur l'algorithme de hash. Il a les caractéristiques suivantes:

1. Lors de l'itération d'un hashset, les éléments ne sont en aucun cas.
2. Les éléments en double ne sont pas autorisés dans Hashset. L'élément répétitif se réfère ici à deux objets qui renvoient True par rapport à la méthode equals ().
3. Permet d'inclure des éléments nuls.

Si la classe que nous avons écrite redéfinit la méthode Equals, alors cette classe doit également redéfinir la méthode HashCode () et s'assurer que lorsque le résultat des deux objets est comparé à la méthode égaux est vrai, les valeurs de retour de la méthode HashCode () des deux objets sont égales.

Exemple du programme:

 Package Lei; import java.util.hashset; import java.util.set; classe publique test4 {public static void main (string [] args) {set <string> set = new hashset <string> (); set.add ("zhangsan"); set.add ("Lisi"); pour (String s: set) {System.out.println (s); }}}

2) .Treeset

La classe TreeSet implémente non seulement l'interface de définition de classe, mais implémente également l'interface tridset, afin de s'assurer que les objets de la collection sont triés dans un certain ordre. Lorsqu'un objet est ajouté à la collection Treeset, il est inséré dans une séquence d'objets ordonnée, mais ce type n'est pas trié dans l'ordre dans lequel des objets sont ajoutés, mais sont triés en fonction d'un certain algorithme.

Treeset trie les éléments dans l'ordre naturel des éléments, ou les trie selon le comparateur fourni lors de la création de l'ensemble. Treeset prend en charge deux méthodes de tri: le tri naturel et le tri personnalisé.

3. MAP INTERFACE

L'interface MAP (MAP) est une autre interface importante dans le cadre de collection Java qui est différente de l'interface de collection. Il correspond à une collection de relations correspondantes des clés aux valeurs. Il y a deux groupes d'objets dans le conteneur d'objets MAP, un groupe d'objets est utilisé pour enregistrer la clé de la carte, et l'autre groupe est utilisé pour enregistrer la valeur. La clé et la valeur peuvent mettre à niveau les données de tout type de référence. La clé ne peut pas être répétée, mais la valeur peut être répétée.

1).

HashMap est une implémentation de l'interface MAP basée sur l'algorithme de hachage. Hashmap économise ses clés dans la table de hachage pour la maintenance, et les clés sont uniques. Cependant, HashMap ne garantit pas que les clés sont organisées dans un ordre spécifique, en particulier que l'ordre est inchangé en permanence.

La classe HashMap implémente l'interface MAP, ayant ainsi toutes les méthodes de l'interface MAP.

 Package Day1228; import java.util. *; classe publique HashMapDemo {public static void main (String [] args) {// Créer une nouvelle carte HashMap <String, String> map = new Hashmap <String, String> (); map.put ("a1", "xiao"); map.put ("b2", "xiaol"); map.put ("a4", "xiaosd"); map.put ("b1", "12a"); map.put ("A3", "1"); // Utilisez Iterator pour parcourir la clé et la valeur System.out.println ("Avant la valeur de la carte,"); Set <string> keys = map.KeySet (); for (iterator <string> i = keys.iterator (); i.hasnext ();) {string key = i.next (); String value = map.get (key); System.out.println (clé + "=" + valeur); } // Supprimer la valeur avec la clé "A4" System.out.println ("/ ndelete l'élément avec la valeur clé a4"); Map.Remove ("A4"); // // Utilisez Iterator pour traverser les touches et valeurs System.out.println ("/ n Valeur de carte après:"); keys = map.KeySet (); for (iterator <string> i = keys.iterator (); i.hasnext ();) {string key = i.next (); String value = map.get (key); System.out.println (clé + "=" + valeur); }}}

2) .treemap

La classe Treemap est une implémentation d'interface MAP basée sur l'algorithme d'arbre rouge et noir. La méthode de stockage des clés dans Treemap est similaire à Treeset. Il stocke les clés dans un arbre, et l'ordre des clés est disposé en ordre naturel ou ordre personnalisé.

Exemple du programme:

 Package Day1228; import java.util. *; classe publique TreemapDemo {public static void main (String [] args) {// Créer une nouvelle carte Treemap <Integer, String> map = new Treemap <Integer, String> (); map.put (1, "un"); map.put (2, "deux"); map.put (3, "trois"); map.put (4, "quatre"); map.put (5, "cinq"); // Utilisez Iterator pour afficher les touches et les valeurs System.out.println ("La valeur de carte précédente est:"); Set <Integer> keys = map.KeySet (); pour (touche objet: touches) {String value = map.get (key); System.out.println (clé + "=" + valeur); } // Supprimer la valeur de la clé 3 System.out.println ("/ ndelete l'élément avec la valeur clé 3"); Map.Remove (3); // Utilisez Iterator pour afficher la touche et la valeur System.out.println ("/ nThe Valeur après la carte est:"); pour (touche objet: touches) {String value = map.get (key); System.out.println (clé + "=" + valeur); }}}

Ce qui précède est tout le contenu de cet article. J'espère que le contenu de cet article sera d'une aide à l'étude ou au travail de chacun. J'espère également soutenir plus Wulin.com!