La interfaz establecida en Java tiene las siguientes características:
No se permiten elementos repetidos;
Los elementos en el conjunto no están en ningún orden;
Hay y solo un elemento con un valor de NULL.
Debido a que la interfaz establecida en Java imita la abstracción del conjunto matemático, las características del conjunto matemático correspondientes son:
Sexo opuesto mutuo: en un conjunto, los dos elementos se consideran diferentes, es decir, cada elemento solo puede aparecer una vez.
Trastorno: en un conjunto, cada elemento tiene el mismo estado y está desordenado entre elementos. Las relaciones secuenciales se pueden definir en un conjunto. Después de definir las relaciones de orden, los elementos se pueden clasificar de acuerdo con la relación de orden. Pero en términos de las características del conjunto en sí, no existe un orden necesario entre los elementos.
La naturaleza de un conjunto vacío: un conjunto vacío es un subconjunto de todos los conjuntos
SET no guarda elementos duplicados. El conjunto más utilizado son los atributos de prueba, puede preguntar fácilmente si un objeto está en un conjunto. SET tiene exactamente la misma interfaz que la colección, por lo que no hay funcionalidad adicional. De hecho, SET es una colección, pero el comportamiento es diferente.
Las cosas principales que implementan la interfaz establecida son Hashset, Treeset y Linkedhashset, que son los puntos comunes de cada mismo elemento se guardan solo una copia. También tienen diferencias, las diferencias son las siguientes:
1.hashset:
Hashset utiliza una forma muy compleja de almacenar elementos. El uso de hashset puede obtener elementos en la colección lo más rápido posible, lo cual es muy eficiente (para el espacio para intercambiar el tiempo). Si el pangduan es el mismo objeto se determinará en base a hashcode y iguales. Si el hashcode es el mismo y es igual a regresar verdadero, es el mismo objeto y no se puede almacenar repetidamente.
paquete cn.set; import java.util.hashset; import java.util.set; class Student {int id; estudiante público (int id) {this.id = id; } @Override public string toString () {return this.id+""; } @Override public int hashcode () {return this.id; } @Override public boolean iguales (objeto obj) {if (obj instancia de alumno) {estudiante stu = (estudiante) obj; if (stu.id == this.id) return true; } return false; }} clase pública Hashsettest {public static void main (string [] args) {set <dianting> set = new Hashset <entudent> (); Estudiante S1 = nuevo estudiante (1); Estudiante S2 = nuevo estudiante (1); Estudiante S3 = nuevo estudiante (2); set.add (S1); set.add (S2); set.add (S3); para (estudiante s: set) {system.out.println (s); }}}Como se muestra en el ejemplo anterior, después de reescribir los métodos hashcode () e igual () para distinguir los objetos de consentimiento, los mismos objetos no se pueden almacenar. Si estos dos métodos se anotan, todos los objetos de los estudiantes se consideran objetos diferentes y se pueden almacenar.
2.Treeset
TreeSet no puede almacenar objetos duplicados, pero Treeset se ordenará automáticamente. Si los objetos almacenados no se pueden ordenar, se informará un error, por lo que los objetos almacenados deben especificar las reglas de clasificación. Las reglas de clasificación incluyen clasificación natural y clasificación de clientes.
① Clasificación natural: el objeto para agregar TreeSet implementará la interfaz java.lang.comparable en qué clase de objeto y anular el método comparación (). Devolver 0 significa que es el mismo objeto, de lo contrario es un objeto diferente.
② Clasificación de Customer: cree una clase de terceros e implementa la interfaz java.util.comparator. Y reescribir el método. Definir el formulario de colección TreeSet TS = New TreeSet (nueva clase de terceros ());
El siguiente ejemplo usa TreeSet para almacenar objetos ordenados naturalmente:
paquete cn.set; import java.util.set; import java.util.treeset; class Student1 implementa comparable <deude1> {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 iguales (objeto obj) {if (obj instancia de student1) {student1 stu = (student1) obj; if (stu.id == this.id) return true; } return false; } public int Compareto (Student1 O) {return (this.id-o.id); }} public class TreeSettest {public static void main (string [] args) {set <diante1> set = new TreeSet <deudent1> (); Student1 S1 = nuevo estudiante1 (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); para (Student1 s: set) {System.out.println (s); }}} El resultado de la salida es:
El siguiente ejemplo usa TreeSet para almacenar objetos ordenados con los clientes:
paquete com.set; import java.util.set; import java.util.treeset; class Student1 implementa comparable <deude1> {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 iguales (objeto obj) {if (obj instancia de student1) {student1 stu = (student1) obj; if (stu.id == this.id) return true; } return false; } public int Compareto (Student1 O) {return (this.id-o.id); }} public class TreeSettest {public static void main (string [] args) {set <diante1> set = new TreeSet <deudent1> (); Student1 S1 = nuevo estudiante1 (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); para (Student1 s: set) {System.out.println (s); }}} El resultado de la salida es:
Todos saben que esa lista está ordenada en el orden de inserción cuando se almacena. De hecho, también puede clasificar las colecciones de listas mediante clasificación natural y clasificación de clientes. Consulte:
paquete cn.set; import java.util.arrayList; import java.util.collections; import java.util.list; class mySort1 implementa java.util.comparator <diestriete 3> {public int Compare (Student3 O1, Student3 o2) {return o2.id-o1.id; }} clase Student3 implementa comparable <deuding3> {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); }} Public Class ListSort {public static void main (string [] args) {list <druident3> list = new ArrayList <deudent3> (); 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 (lista); // clasificación natural: colección.sort (lista); System.out.println (lista); // colección de clasificación de clientes.sort (lista, nueva mysort1 ()); System.out.println (lista); }} El resultado de la salida es:
[5, 1, 2, 4, 3]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
El siguiente es un principio de que la interfaz de colección establecida en Java no implementa la duplicación de la inserción de objetos:
En una colección Java, la regla para determinar si dos objetos son iguales es:
1) Determine si los hashcodes de los dos objetos son iguales
Si no es igual, se considera que los dos objetos no son iguales. Si es igual, gire a 2)
(Esto solo se requiere para mejorar la eficiencia de almacenamiento. De hecho, es posible no tener teóricamente, pero si no, la eficiencia se reducirá considerablemente durante el uso real, por lo que lo haremos necesario aquí. Este problema se centrará más adelante).
2) Determinar si los dos objetos están igualmente calculados usando iguales
Si no es igual, piense que los dos objetos no son iguales. Si es igual, piense que los dos objetos son iguales (es igual a () es la clave para juzgar si los dos objetos son iguales)
Para objetos de clase general (excepto objetos encapsulados como la cadena):
Si la clase ordinaria no anula los métodos hashcode () e igual (), entonces al comparar los objetos, el método hashcode () en la clase de objeto heredado, el método hashcode () en la clase de objetos es un método local. Al comparar el valor de retorno del método, se compara la dirección del objeto (dirección de referencia). Use el nuevo método para crear un objeto con el mismo contenido. Por supuesto, diferentes objetos se generan dos veces. A menos que se anule el método hashcode (). El método igual () definido en la clase de objeto también es una comparación de las direcciones de objeto. En una palabra: si no reescribe los métodos hashcode () e igual () de las clases ordinarias, las direcciones de referencia del objeto son diferentes en la colección establecida, y el objeto no se repetirá.
Para objetos como String (String, Integer, Double ... etc.):
Dado que estas clases de encapsulación han reescrito el método hashcode (), y el valor de retorno del método reescrito está relacionado con el contenido del objeto, no con la dirección de referencia. El método igual () en estas clases encapsuladas también se reescribe, comparando el contenido del objeto en lugar de la dirección de referencia. En una palabra, los objetos de clases como la cadena comparan su contenido en la colección, y si se sobrescribe el mismo contenido, los objetos existentes están cubiertos.
Lo anterior se trata de este artículo, espero que sea útil para el aprendizaje de todos.