L'interface définie dans Java a les caractéristiques suivantes:
Les éléments répétés ne sont pas autorisés;
Les éléments de l'ensemble ne sont en aucun cas;
Il y a et un seul élément avec une valeur de null.
Étant donné que l'interface définie dans Java imite l'abstraction de l'ensemble mathématique, les caractéristiques de l'ensemble mathématique correspondantes sont:
Sex opposé mutuel: Dans un ensemble, deux éléments sont considérés comme différents, c'est-à-dire que chaque élément ne peut apparaître qu'une seule fois.
Trouble: Dans un ensemble, chaque élément a le même statut et est désordonné entre les éléments. Les relations séquentielles peuvent être définies sur un ensemble. Après avoir défini les relations de commande, les éléments peuvent être triés en fonction de la relation de commande. Mais en termes de caractéristiques de l'ensemble lui-même, il n'y a pas d'ordre nécessaire entre les éléments.
La nature d'un ensemble vide: un ensemble vide est un sous-ensemble de tous les ensembles
Le jeu n'enregistre pas les éléments en double. L'ensemble le plus utilisé est les attributs de test, vous pouvez facilement vous demander si un objet est dans un ensemble. Set a exactement la même interface que la collection, il n'y a donc pas de fonctionnalité supplémentaire. En fait, Set est une collection, mais le comportement est différent.
Les principales choses qui implémentent l'interface définie sont HashSet, Treeset et LinkedHashSet, qui sont les points courants de chaque même élément ne sont enregistrés qu'une seule copie. Ils ont également des différences, les différences sont les suivantes:
1.Hashset:
Hashset utilise une façon très complexe de stocker des éléments. L'utilisation de Hashset peut obtenir des éléments dans la collection le plus rapidement possible, ce qui est très efficace (pour que l'espace pour échanger le temps). La question de savoir si le pangduan est le même objet sera déterminé sur la base de HashCode et égaux. Si le HashCode est le même et égal à REVALS TRUE, c'est le même objet et ne peut pas être stocké à plusieurs reprises.
package cn.set; import java.util.hashset; import java.util.set; classe étudiante {int id; Étudiant public (int id) {this.id = id; } @Override public String toString () {return this.id + ""; } @Override public int hashcode () {return this.id; } @Override public boolean equals (objet obj) {if (obj instanceof student) {Student Stu = (étudiant) obj; if (stu.id == this.id) renvoie true; } return false; }} classe publique HashSetTest {public static void main (String [] args) {set <Student> set = new HashSet <Student> (); Étudiant S1 = nouvel étudiant (1); Student S2 = nouvel étudiant (1); Étudiant S3 = nouvel étudiant (2); set.add (s1); set.add (s2); set.add (S3); pour (Student S: set) {System.out.println (s); }}}Comme indiqué dans l'exemple ci-dessus, après avoir réécrit les méthodes HashCode () et Equals () pour distinguer les objets de consentement, les mêmes objets ne peuvent pas être stockés. Si ces deux méthodes sont annotées, tous les objets étudiants sont considérés comme des objets différents et peuvent être stockés.
2.Treeset
Treeset ne peut pas stocker des objets en double, mais Treeset triera automatiquement. Si les objets stockés ne peuvent pas être triés, une erreur sera signalée, donc les objets stockés doivent spécifier les règles de tri. Les règles de tri incluent le tri naturel et le tri des clients.
① Tri naturel: l'objet pour ajouter Treeset implémentera l'interface java.lang.comparable sur quelle classe d'objets, et remplacera la méthode comparato (). Le retour 0 signifie que c'est le même objet, sinon c'est un objet différent.
② Tri des clients: créez une classe tierce et implémentez l'interface java.util. Et réécrivez la méthode. Définissez le formulaire de collection Treeset ts = new Treeset (Nouvelle classe tiers ());
L'exemple suivant utilise Treeset pour stocker des objets triés naturellement:
package cn.set; import java.util.set; import java.util.treeset; class student1 implémente comparable <Student1> {int id; public Student1 (int id) {this.id = id; } @Override public String toString () {return this.id + ""; } @Override public int hashcode () {return this.id; } @Override public boolean equals (objet obj) {if (obj instanceof student1) {Student1 Stu = (Student1) obj; if (stu.id == this.id) renvoie true; } return false; } public int compareto (Student1 o) {return (this.id-o.id); }} classe publique TreeseTest {public static void main (String [] args) {set <Student1> set = new TreeSet <Student1> (); Student1 S1 = New Student1 (5); Student1 S2 = New Student1 (1); Student1 S3 = New Student1 (2); Student1 S4 = New Student1 (4); Student1 S5 = New Student1 (3); set.add (s1); set.add (s2); set.add (S3); set.add (S4); set.add (s5); pour (Student1 S: set) {System.out.println (s); }}} Le résultat de la sortie est:
L'exemple suivant utilise Treeset pour stocker les objets triés par les clients:
package com.set; import java.util.set; import java.util.treeset; class student1 implémente comparable <Student1> {int id; public Student1 (int id) {this.id = id; } @Override public String toString () {return this.id + ""; } @Override public int hashcode () {return this.id; } @Override public boolean equals (objet obj) {if (obj instanceof student1) {Student1 Stu = (Student1) obj; if (stu.id == this.id) renvoie true; } return false; } public int compareto (Student1 o) {return (this.id-o.id); }} classe publique TreeseTest {public static void main (String [] args) {set <Student1> set = new TreeSet <Student1> (); Student1 S1 = New Student1 (5); Student1 S2 = New Student1 (1); Student1 S3 = New Student1 (2); Student1 S4 = New Student1 (4); Student1 S5 = New Student1 (3); set.add (s1); set.add (s2); set.add (S3); set.add (S4); set.add (s5); pour (Student1 S: set) {System.out.println (s); }}} Le résultat de la sortie est:
Tout le monde sait que cette liste est triée dans l'ordre d'insertion lors du stockage. En fait, vous pouvez également trier les collections de liste par tri naturel et tri client. Veuillez voir:
package cn.set; import java.util.arraylist; import java.util.collections; import java.util.list; class mysort1 implémente java.util ..Parator <Student3> {public int compare (student3 o1, étudiant3 o2) {return o2.id-o1.id; }} classe Student3 implémente comparable <Student3> {int id; public Student3 (int id) {this.id = id; } @Override public String toString () {return this.id + ""; } public int compareto (Student3 o) {return (this.id-o.id); }} classe publique ListSort {public static void main (String [] args) {list <Student3> list = new ArrayList <Student3> (); Student3 S1 = New Student3 (5); Student3 S2 = New Student3 (1); Student3 S3 = New Student3 (2); Student3 S4 = New Student3 (4); Student3 S5 = New Student3 (3); list.add (s1); list.add (s2); list.add (S3); list.add (s4); list.add (s5); System.out.println (liste); // Tri naturel: Collection.Sort (liste); System.out.println (liste); // Customer Tri Collection.Sort (liste, new MySort1 ()); System.out.println (liste); }} Le résultat de la sortie est:
[5, 1, 2, 4, 3]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
Ce qui suit est un principe selon lequel l'interface de collecte de set dans Java n'implémente aucune duplication de l'insertion d'objets:
Dans une collection Java, la règle pour déterminer si deux objets sont égaux est:
1) Déterminez si les codes de hash des deux objets sont égaux
S'il n'est pas égal, il est considéré que les deux objets ne sont pas égaux. S'il est égal, tournez-vous à 2)
(Cela n'est nécessaire que pour améliorer l'efficacité du stockage. En fait, il est possible de ne pas avoir théoriquement, mais sinon, l'efficacité sera considérablement réduite lors d'une utilisation réelle, nous le rendra donc nécessaire ici. Ce problème sera axé sur plus tard.)
2) Déterminez si les deux objets sont également calculés en utilisant des égaux
S'il n'est pas égal, pensez que les deux objets ne sont pas égaux. S'il est égal, pensez que les deux objets sont égaux (equals () est la clé pour juger si les deux objets sont égaux)
Pour les objets de classe générale (sauf des objets encapsulés tels que la chaîne):
Si la classe ordinaire ne remplace pas les méthodes HashCode () et Equals (), alors lors de la comparaison des objets, la méthode HashCode () dans la classe d'objets héréditaire, la méthode HashCode () dans la classe d'objets est une méthode locale. Lors de la comparaison de la valeur de retour de la méthode, l'adresse de l'objet (adresse de référence) est comparée. Utilisez la nouvelle méthode pour créer un objet avec le même contenu. Bien sûr, différents objets sont générés deux fois. À moins que la méthode HashCode () ne soit remplacée. La méthode equals () définie dans la classe d'objets est également une comparaison des adresses d'objet. Dans un mot: si vous ne réécrivez pas les méthodes de HashCode () et Equals () des classes ordinaires, les adresses de référence de l'objet sont différentes dans la collection SET et l'objet ne sera pas répété.
Pour des objets tels que String (String, Integer, Double ... etc.):
Étant donné que ces classes d'encapsulation elles-mêmes ont réécrit la méthode HashCode () et que la valeur de retour de la méthode réécrite est liée au contenu de l'objet, et non à l'adresse de référence. La méthode equals () dans ces classes encapsulées est également réécrite, en comparant le contenu de l'objet plutôt que sur l'adresse de référence. En un mot, des objets de classes tels que String comparent leur contenu dans la collection, et si le même contenu est écrasé, les objets existants sont couverts.
Ce qui précède concerne cet article, j'espère qu'il sera utile à l'apprentissage de tout le monde.