java之set接口

1.set集合不能存储重复的元素，

2.HashSet集合不能保证的迭代顺序与元素存储顺序相同。

3.HashSet集合，采用哈希表结构存储数据，保证元素唯一性的方式依赖于：hashCode()与equals()方法。

4.hashset集合的存储结构为哈希表（实质上为数组机制的链式存储），在存储对象时，会调用对象的hashcode()，判断hash值是否一致，若一致则调用equals(),判断内容是否一致，不一致则进行存储从而保证了数据的唯一性。【自定义对象必须重写hashcode()和equals()方法】。

如果两个对象hashCode方法算出结果一样，这样现象称为哈希冲突，这时会调用对象的equals方法，比较这两个对象是不是同一个对象，如果equals方法返回的是true，那么就不会把第二个对象存放在哈希表中，如果返回的是false，就会把这个值存放在哈希表中。

总结：保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，就必须复写hashCode和equals方法建立属于当前对象的比较方式。

5.基本数据的包装类、引用数据类型；

 1 package com.oracle.demo01;
 2 
 3 import java.util.Iterator;
 4 import java.util.LinkedHashSet;
 5 
 6 public class Demo04 {
 7 public static void main(String[] args) {
 8     //仍不能存储重复元素，但有序有堆栈数据存储结构的效果
 9     LinkedHashSet<String> set=new LinkedHashSet<String>();
10     set.add("a");
11     set.add("b");
12     set.add("c");
13     set.add("a");
14     //获取迭代器对象
15     Iterator<String>  i=set.iterator();
16     while(i.hasNext()){
17         System.out.println(i.next());
18     }
19 }
20 }

6.存储自定义数据类型时，需要重写hashcode（）和equals()

自定义对象：成员属性、成员方法、有参构造、无参构造、get-set方法、tostring()、hashcode()、equals().

 1 package com.oracle.demo01;
 2 
 3 //自定义类型，存哈希
 4 public class Person {
 5     private String name;
 6     private int age;
 7 
 8     public String getName() {
 9         return name;
10     }
11 
12     public void setName(String name) {
13         this.name = name;
14     }
15 
16     public int getAge() {
17         return age;
18     }
19 
20     public void setAge(int age) {
21         this.age = age;
22     }
23 
24     @Override
25     public String toString() {
26         return "Person [name=" + name + ", age=" + age + "]";
27     }
28 
29     public Person(String name, int age) {
30         super();
31         this.name = name;
32         this.age = age;
33     }
34 
35     public Person() {
36         super();
37     }
38 
39     @Override // 输入hashcode alt+/
40     //source   hashcode()
41     public int hashCode() {
42         // TODO Auto-generated method stub
43         //乘以31，避免重复
44         return name.hashCode() + age*31;//String类调用hashcode();  31  65  33
45     }
46 
47     @Override
48     public boolean equals(Object obj) {//此时obj为集合中原有的元素
49         if(obj==this){
50             return true;
51         }
52         if(obj==null){
53             return false;
54         }
55         if(obj instanceof Person){
56             Person p=(Person)obj;
57             return this.name.equals(p.name)&&this.age==p.age;
58         }
59         // TODO Auto-generated method stub
60         return false;
61     }
62 }

添加对象，遍历对象

linkedhashset:双向链表，保证存取有序，是链表和哈希表组成的一个数据存储结构。

 1 package com.oracle.demo01;
 2 
 3 import java.util.Iterator;
 4 import java.util.LinkedHashSet;
 5 
 6 public class Demo05 {
 7 public static void main(String[] args) {
 8     LinkedHashSet<Person>  p=new LinkedHashSet<Person>(); 
 9     p.add(new Person("阿布都",18));
10     p.add(new Person("易建联",28));
11     p.add(new Person("郭艾伦",38));
12     p.add(new Person("郭艾伦",48));
13     //迭代器迭代
14     /*    public String toString() {
15         return "Person [name=" + name + ", age=" + age + "]";
16     }*/
17     //迭代器
18     Iterator<Person> pp=p.iterator();
19     while(pp.hasNext()){
20         System.out.println(pp.next());//重写的String toString()方法
21     }
22     //增强for循环
23     for(Person ppp:p){
24         System.out.println(ppp);
25     }
26 }
27 }

猜你喜欢