A interface definida em Java tem as seguintes características:
Elementos repetidos não são permitidos;
Os elementos no conjunto não estão em ordem;
Existe e apenas um elemento com um valor de nulo.
Como a interface definida em Java imita a abstração do conjunto matemático, as características correspondentes do conjunto matemático são:
Sexo oposto mútuo: em um conjunto, quaisquer dois elementos são considerados diferentes, ou seja, cada elemento só pode aparecer uma vez.
Transtorno: Em um conjunto, cada elemento tem o mesmo status e é desordenado entre os elementos. Relacionamentos seqüenciais podem ser definidos em um conjunto. Depois de definir as relações de ordem, os elementos podem ser classificados de acordo com o relacionamento da ordem. Mas em termos das características do próprio conjunto, não há ordem necessária entre os elementos.
A natureza de um conjunto vazio: um conjunto vazio é um subconjunto de todos os conjuntos
O conjunto não salva elementos duplicados. O conjunto mais comumente usado são os atributos de teste, você pode facilmente perguntar se um objeto está em um conjunto. O set tem exatamente a mesma interface que a coleção, portanto não há funcionalidade extra. De fato, Set é uma coleção, mas o comportamento é diferente.
As principais coisas que implementam a interface definida são hashset, árvores e linkedhashset, que são os pontos comuns de cada mesmo item, são salvos apenas uma cópia. Eles também têm diferenças, as diferenças são as seguintes:
1.HashSet:
O hashset usa uma maneira muito complexa de armazenar elementos. O uso de hashset pode obter elementos na coleção o mais rápido possível, o que é muito eficiente (para o espaço para negociar o tempo). Se o Pangduan é o mesmo objeto será determinado com base no código de hash e iguais. Se o HashCode for o mesmo e igual a retornar verdadeiro, é o mesmo objeto e não poderá ser armazenado repetidamente.
pacote cn.set; importar java.util.hashset; importar java.util.set; classe estudante {int id; public Student (int id) {this.id = id; } @Override public string tostring () {return this.id+""; } @Override public int hashCode () {return this.id; } @Override public boolean igual (object obj) {if (obj instanceof student) {student stu = (student) obj; if (stu.id == this.id) retorna true; } retornar false; }} classe pública hashsetTest {public static void main (string [] args) {set <vertware> set = new HashSet <vertware> (); Aluno s1 = novo aluno (1); Aluno s2 = novo aluno (1); Aluno s3 = novo aluno (2); set.add (S1); set.add (s2); set.add (S3); para (estudante s: set) {System.out.println (s); }}}Conforme mostrado no exemplo acima, após a reescrita dos métodos HashCode () e Equals () para distinguir os objetos de consentimento, os mesmos objetos não podem ser armazenados. Se esses dois métodos forem anotados, todos os objetos dos alunos são considerados objetos diferentes e podem ser armazenados.
2.TreeSet
O TreeSet não pode armazenar objetos duplicados, mas a TreeSet classificará automaticamente. Se os objetos armazenados não puderem ser classificados, um erro será relatado, portanto, os objetos armazenados devem especificar as regras de classificação. As regras de classificação incluem classificação natural e classificação de clientes.
① Classificação natural: o objeto para adicionar a TreeSet implementará a interface java.lang.comparable em qual classe de objeto e substituirá o método comparato (). Retornar 0 significa que é o mesmo objeto, caso contrário, é um objeto diferente.
② Classificação Customer: Crie uma classe de terceiros e implemente a interface java.util.comparator. E reescrever o método. Defina a coleção Formule TreeSet TS = New TreeSet (nova classe de terceiros ());
O exemplo a seguir usa o TreeSet para armazenar objetos naturalmente classificados:
pacote cn.set; importar java.util.set; importar java.util.treeset; classe Student1 implementa comparável <vertenty1> {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 é igual (object obj) {if (obj instanceof student1) {student1 stu = (student1) obj; if (stu.id == this.id) retorna true; } retornar false; } public int compareto (student1 o) {return (this.id-o.id); }} classe pública TreeSetTest {public static void main (string [] args) {set <vertware1> set = new TreeSet <Dentudent1> (); Estudante1 s1 = novo aluno1 (5); Estudante1 s2 = novo aluno1 (1); Estudante1 s3 = novo aluno1 (2); Estudante1 s4 = novo aluno1 (4); Estudante1 s5 = novo aluno1 (3); set.add (S1); set.add (s2); set.add (S3); set.add (S4); set.add (S5); para (Student1 s: set) {System.out.println (s); }}} O resultado da saída é:
O exemplo a seguir usa a TreeSet para armazenar objetos classificados por clientes:
pacote com.set; importar java.util.set; importar java.util.treeset; classe Student1 implementa comparável a <vertudy1> {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 é igual (object obj) {if (obj instanceof student1) {student1 stu = (student1) obj; if (stu.id == this.id) retorna true; } retornar false; } public int compareto (student1 o) {return (this.id-o.id); }} classe pública TreeSetTest {public static void main (string [] args) {set <vertware1> set = new TreeSet <Dentudent1> (); Estudante1 s1 = novo aluno1 (5); Estudante1 s2 = novo aluno1 (1); Estudante1 s3 = novo aluno1 (2); Estudante1 s4 = novo aluno1 (4); Estudante1 s5 = novo aluno1 (3); set.add (S1); set.add (s2); set.add (S3); set.add (S4); set.add (S5); para (Student1 s: set) {System.out.println (s); }}} O resultado da saída é:
Todo mundo sabe que essa lista é classificada na ordem de inserção quando armazenada. De fato, você também pode classificar as coleções de listas de classificação natural e classificação de clientes. Por favor, veja:
pacote cn.set; importar java.util.ArrayList; importar java.util.Collections; importar java.util.list; classe mysort1 implementa java.util.comparator <vertudent3> {public int compare (Student3 O1, Student3 O2) {retornar o2.id-o1.id; }} classe Student3 implementa comparável a <vertudy3> {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 pública listsort {public static void main (string [] args) {list <vertent3> list = new ArrayList <Dentudent3> (); Estudante3 s1 = novo aluno3 (5); Estudante3 s2 = novo aluno3 (1); Estudante3 s3 = novo aluno3 (2); Estudante3 s4 = novo aluno3 (4); Estudante3 s5 = novo aluno3 (3); list.add (S1); list.add (s2); list.add (S3); list.add (S4); list.add (S5); System.out.println (list); // classificação natural: coleções.sort (lista); System.out.println (list); // coleções de classificação de clientes.Sort (List, New MySort1 ()); System.out.println (list); }} O resultado da saída é:
[5, 1, 2, 4, 3]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
A seguir, é apresentado um princípio de que a interface de coleta de conjuntos em Java não implementa duplicação de inserção de objetos:
Em uma coleção Java, a regra para determinar se dois objetos são iguais é:
1) determinar se os códigos de hash dos dois objetos são iguais
Se não for igual, considera -se que os dois objetos não são iguais. Se for igual, volte para 2)
(Isso é necessário apenas para melhorar a eficiência do armazenamento. De fato, é possível não ter teoricamente, mas, se não, a eficiência será bastante reduzida durante o uso real; portanto, tornaremos isso necessário aqui. Esse problema será focado posteriormente.)
2) determinar se os dois objetos são igualmente calculados usando iguais
Se não for igual, pense que os dois objetos não são iguais. Se for igual, pense que os dois objetos são iguais (iguais () é a chave para julgar se os dois objetos são iguais)
Para objetos de classe geral (exceto objetos encapsulados como string):
Se a classe comum não substituir os métodos hashcode () e iguals (), ao comparar os objetos, o método hashcode () na classe de objeto herdado, o método hashcode () na classe de objeto é um método local. Ao comparar o valor de retorno do método, o endereço do objeto (endereço de referência) é comparado. Use o novo método para criar um objeto com o mesmo conteúdo. Obviamente, objetos diferentes são gerados duas vezes. A menos que o método hashcode () seja substituído. O método iguals () definido na classe de objeto também é uma comparação dos endereços de objeto. Em uma palavra: se você não reescrever os métodos HashCode () e Equals () de classes comuns, os endereços de referência do objeto são diferentes na coleção de conjuntos e o objeto não será repetido.
Para objetos como String (String, Inteiro, Double ... etc.):
Como essas classes de encapsulamento reescreveram o método hashcode (), e o valor de retorno do método reescrito está relacionado ao conteúdo do objeto, não ao endereço de referência. O método iguals () nessas classes encapsuladas também é reescrito, comparando o conteúdo do objeto em vez do endereço de referência. Em uma palavra, objetos de classes como String comparam seu conteúdo na coleção e, se o mesmo conteúdo for substituído, os objetos existentes serão cobertos.
O exposto acima é tudo sobre este artigo, espero que seja útil para o aprendizado de todos.