A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

Set(☆☆☆☆☆):存取无序 元素唯一
        一:HashSet(☆☆☆☆☆):存取无序 元素唯一
               
                代码演示:
                public static void demo1() {
                        HashSet<String> hs = new HashSet<>();        //创建HashSet对象
                        boolean b1 = hs.add("a");
                        boolean b2 = hs.add("a");                //当向set集合中存储重复元素的时候返回为false
                        hs.add("b");
                        hs.add("c");
                        hs.add("d");
                        System.out.println(hs);                        //[d, b, c, a] 存取无序  并且去掉了重复元素
                        System.out.println(b1);                        //true
                        System.out.println(b2);                        //false
                       
                        for (String string : hs) {                //只要能用迭代器迭代的,就可以使用增强for循环遍历
                                System.out.println(string);
                        }
                }

                保证元素唯一性 需要让元素重写两个方法 一个是 hashCode() 另一个是 equals()
                HashSet在存储元素的过程中 首先会去调用元素的hashCode()值,看其哈希值与已经存入HashSet的元素的哈希值是否相同
                        如果不同 :就直接添加到集合
                        如果相同 :则继续调用元素的equals() 和哈希值相同的这些元素依次去比较
                                        如果说有返回true的   那就重复 不添加
                                        如果说比较结果都说false  那就是不重复 就添加

                        为了减少equals的比较次数提高效率 一般情况 让属性不同的对象尽量hashCode()值不同
                        那么如何重写 equals()和hashCode()呢? Eclipse自动生成即可

                代码演示:
                public static void main(String[] args) {

                        HashSet<Person> hs = new HashSet<>();
                        hs.add(new Person("张三", 23));
                        hs.add(new Person("张三", 23));
                        hs.add(new Person("李四", 24));
                        hs.add(new Person("李四", 24));
                        hs.add(new Person("李四", 24));
                        hs.add(new Person("李四", 24));
                       
                        System.out.println(hs);                //Person重写了equals()方法和hashCode()方法,所以 hs 去除了重复的元素
                }
                public class Person {                        //Person里面 Eclipse自动生成了 equals()方法和hashCode()方法
                        private String name;
                        private int age;
                        public Person() {
                                super();                       
                        }
                        public Person(String name, int age) {
                                super();
                                this.name = name;
                                this.age = age;
                        }
                        public String getName() {
                                return name;
                        }
                        public void setName(String name) {
                                this.name = name;
                        }
                        public int getAge() {
                                return age;
                        }
                        public void setAge(int age) {
                                this.age = age;
                        }
                        @Override
                        public String toString() {
                                return "Person [name=" + name + ", age=" + age + "]";
                        }                       
                        /*
                         * 为什么是31?
                         * 1,31是一个质数,质数是能被1和自己本身整除的数
                         * 2,31这个数既不大也不小
                         * 3,31这个数好算,2的五次方-1,2向左移动4位
                         */
                        @Override
                        public int hashCode() {
                                final int prime = 31;
                                int result = 1;
                                result = prime * result + age;
                                result = prime * result + ((name == null) ? 0 : name.hashCode());
                                return result;
                        }
                        @Override
                        public boolean equals(Object obj) {
                                if (this == obj)                                //调用的对象和传入的对象是同一个对象
                                        return true;                                //直接返回true
                                if (obj == null)                                //传入的对象为null
                                        return false;                                //返回false
                                if (getClass() != obj.getClass())                //判断两个对象对应的字节码文件是否是同一个字节码
                                        return false;                                //如果不是直接返回false
                                Person other = (Person) obj;                        //向下转型
                                if (age != other.age)                                //调用对象的年龄不等于传入对象的年龄
                                        return false;                                //返回false
                                if (name == null) {                                //调用对象的姓名为null
                                        if (other.name != null)                        //传入对象的姓名不为null
                                                return false;                        //返回false
                                } else if (!name.equals(other.name))                //调用对象的姓名不等于传入对象的姓名
                                        return false;                                //返回false
                                return true;                                        //返回true
                        }               
                }


        二:LinkedHashSet(☆☆☆):直接父类是 HashSet
                特点:存取有序  存储的元素不能重复
               
                代码演示:
                LinkedHashSet<String> lhs = new LinkedHashSet<>();
                lhs.add("a");
                lhs.add("a");
                lhs.add("a");
                lhs.add("a");
                lhs.add("b");
                lhs.add("c");
                lhs.add("d");
               
                System.out.println(lhs);//[a,b,c,d]  去除了重复的元素 同时又保证了存取有序


0 个回复

您需要登录后才可以回帖 登录 | 加入黑马