HashSe、LinkedHashSet、TreeSet(java基础知识十七)

1.HashSet存储字符串并遍历

* 特点：无序、无索引、无重复

HashSet存储字符串并遍历
            HashSet<String> hs = new HashSet<>();
            hs.add("a");
            hs.add("b");
            hs.add("a");
            hs.add("c");
            hs.add("c");
            hs.add("d");
            boolean b = hs.add("d");//返回的是boolean类型,储存不成功时，返回false。
            System.out.println(b);
            System.out.println(hs);//[d, b, c, a]
    * 存储字符串，是无序的，且无重复存储。  

2.HashSet存储自定义对象保证元素唯一性

存储自定义对象，并保证元素唯一性。
        HashSet<Person> hs = new HashSet<>();
        hs.add(new Person("张三",23));
        hs.add(new Person("张三",23));
        hs.add(new Person("李四",24));
        hs.add(new Person("王五",25));
        hs.add(new Person("王五",25));
        hs.add(new Person("王五",25));
        hs.add(new Person("赵六",26));
        hs.add(new Person("赵六",26));
        System.out.println(hs);

* 存储自定义对象，要使对象有一定的顺序输出，且不重复，必须重写HashCode()和equals()方法，系统自带，选择添加即可：shirt + alt +s + h;生成的结果是：
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + age;
            result = prime * result + ((name == null) ? 0 : name.hashCode());
            return result;
        }
        * 为什么是31？
        * 1,31是一个质数(只能被1和本身整除)
         * 2,31这个数既不大,也不小
         * 3,31是2的5次方-1(2向左移动5次再减一)
        public boolean equals(Object obj) {
            if (this == obj)                            //调用的对象和传入的对象是同一个对象
                return true;                            //直接返回true
            if (obj == null)                            //传入的对象为null
                return false;                            //返回false
            if (this.getClass() != obj.getClass())        //调用的对象对应的字节码对象和传入对象对应的字节码对象不是同一个对象
                return false;                            //返回false
            Person other = (Person) obj;                //向下转型,可以调用子类特有的属性和行为
            if (age != other.age)                        //如果调用的对象的age不等于传入对象的age
                return false;                            //返回false
            if (name == null) {                            //如果调用的name为null
                if (other.name != null)                    //而传入的对象name不为
                    return false;                        //返回false
            } else if (!name.equals(other.name))        //如果调用对象的name和传入对象的name不是同一个name
                return false;                            //返回false
            return true;                                //返回true
        }
* 为了减少比较，优化hashCode()代码写法。
* 最终版就是自动生成即可。

3.HashSet如何保证元素唯一性的原理

* 1.HashSet原理
    * 我们使用Set集合都是需要去掉重复元素的, 如果在存储的时候逐个equals()比较, 效率较低,哈希算法提高了去重复的效率, 降低了使用equals()方法的次数
    * 当HashSet调用add()方法存储对象的时候, 先调用对象的hashCode()方法得到一个哈希值, 然后在集合中查找是否有哈希值相同的对象
        * 如果没有哈希值相同的对象就直接存入集合
        * 如果有哈希值相同的对象, 就和哈希值相同的对象逐个进行equals()比较,比较结果为false就存入, true则不存
* 2.将自定义类的对象存入HashSet去重复
    * 类中必须重写hashCode()和equals()方法
    * hashCode(): 属性相同的对象返回值必须相同, 属性不同的返回值尽量不同(提高效率)
    * equals(): 属性相同返回true, 属性不同返回false,返回false的时候存储

4.LinkedHashSet的概述和使用

* 特点：怎么存就怎么取，去重复，但是存入的顺序就是输出的顺序。

需求：编写一个程序，获取10个1至20的随机数，要求随机数不能重复。并把最终的随机数输出到控制台。
        public static void main(String[] args) {
            HashSet<Integer> hs = new HashSet<>();        //创建集合对象
            Random r = new Random();                    //创建随机数对象
            while(hs.size() < 10) {
                int num = r.nextInt(20) + 1;            //生成1到20的随机数
                hs.add(num);
            }
            for (Integer integer : hs) {                //遍历集合
                System.out.println(integer);            //打印每一个元素
            }
        }

* 使用Scanner从键盘读取一行输入,去掉其中重复字符, 打印出不同的那些字符
    * aaaabbbcccddd
    * Scanner sc = new Scanner(System.in);                //创建键盘录入对象
    *    System.out.println("请输入一行字符串:");
    *    String line = sc.nextLine();                    //将键盘录入的字符串存储在line中
    *    char[] arr = line.toCharArray();                //将字符串转换成字符数组
    *    HashSet<Character> hs = new HashSet<>();        //创建HashSet集合对象
    *    for(char c : arr) {                                //遍历字符数组
    *        hs.add(c);                                    //将字符数组中的字符添加到集合中
    *    }
    *    for (Character ch : hs) {                        //遍历集合
    *        System.out.println(ch);
    *    }

将集合中的重复元素去掉，还保证了原来的顺序
        public static void getSingle(List<String> list) {
            LinkedHashSet<String> lhs = new LinkedHashSet<>();
            lhs.addAll(list);                                    //将list集合中的所有元素添加到lhs
            list.clear();                                        //清空原集合
            list.addAll(lhs);                                    //将去除重复的元素添回到list中
        }

5.TreeSet存储Integer类型的元素并遍历

* TreeSet 自动升序排序，Integer,String类型，无重复
    * 1.自定义对象时，先实现Comparable接口，然后重写compareTo方法，
    *   class Person implements Comparable<Person>{
    *   /*@Override
    *        public int compareTo(Person o) {                //按照年龄排序
    *        int num = this.age - o.age;                    //年龄作为主要条件比较
    *        return num == 0 ? this.name.compareTo(o.name) : num;//姓名作为次要条件,只有年龄相同的时候比较姓名
    *     }*/
    * /*@Override
    * public int compareTo(Person o) {                //按照姓名排序
    *        int num = this.name.compareTo(o.name);        //姓名作为主要条件
    *        return num == 0 ? this.age - o.age : num;    //年龄是次要条件
    * }*/
    * @Override
    * public int compareTo(Person o) {                //按照姓名的长度排序
    *    int num = this.name.length() - o.name.length();    //长度作为主要条件
    *    int num2 = num == 0 ? this.name.compareTo(o.name) : num;//姓名的内容作为次要条件
    *    return num2 == 0 ? this.age - o.age : num2;        //年龄作为次次要条件
    * }
    *}
    * 2.利用比较器进行比较：Comparator,compare
    * TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {    //定义比较器(new Comparator(){}是Comparator的子类对象)
    *        @Override
    *        public int compare(String s1, String s2) {                //重写compare方法
    *            int num = s1.compareTo(s2);                            //比较内容
    *            return num == 0 ? 1 : num;                            //如果内容一样返回一个不为0的数字即可
    *        }
    *    });

* TreeSet存储Integer类型的元素并遍历
    * TreeSet<Integer> ts = new TreeSet<>();
    * ts.add(5);
    * ts.add(8);
    * ts.add(3);
    * ts.add(4);
    * System.out.println(ts);//3，4，5，8

6.TreeSet原理

* 1.特点
    * TreeSet是用来排序的, 可以指定一个顺序, 对象,存入之后会按照指定的顺序排列
* 2.使用方式
    * a.自然顺序(Comparable)
        * TreeSet类的add()方法中会把存入的对象提升为Comparable类型
        * 调用对象的compareTo()方法和集合中的对象比较
        * 根据compareTo()方法返回的结果进行存储
    * b.比较器顺序(Comparator)
        * 创建TreeSet的时候可以制定一个Comparator
        * 如果传入了Comparator的子类对象, 那么TreeSet就会按照比较器中的顺序排序
        * add()方法内部会自动调用Comparator接口中compare()方法排序
    * c.两种方式的区别
        * TreeSet构造函数什么都不传, 默认按照类中Comparable的顺序(没有就报错ClassCastException)(类型转换异常)
        * TreeSet如果传入Comparator, 就优先按照Comparator。

7.注意：

* 1.List
    * a.普通for循环, 使用get()逐个获取
    * b.调用iterator()方法得到Iterator, 使用hasNext()和next()方法
    * c.增强for循环, 只要可以使用Iterator的类都可以用
    * d.Vector集合可以使用Enumeration的hasMoreElements()和nextElement()方法
* 2.Set
    * a.调用iterator()方法得到Iterator, 使用hasNext()和next()方法
    * b.增强for循环, 只要可以使用Iterator的类都可以用
* 3.普通for循环,迭代器,增强for循环是否可以在遍历的过程中删除
    * 普通的for循环：可以删除元素，但是索引要--
        * for (int i = 0; i < list.size(); i++) {
        *    if (list.get(i).equals("b")) {
        *        list.remove(i--);//普通的for循环可以删除，但是索引要i--，索引不--相邻元素相同时，只能删除前面的，不能删除后面的，
        *    }
        * }
    * 迭代器 ： 不能用集合的删除方法，否则会出现并发修改异常；但可以用迭代器的删除方法。
    * 增强for循环： 不可以删除的，会出并发修改异常。