Java集合之HashSet和TreeSet集合

青旅半醒 2022-11-27 15:55 228阅读 0赞

### **一、HashSet集合** ###

**存储特点：**无索引，不可以重复，无序。

**无索引、无序：**存储结构决定的（树）

**不能重复：      **HashSet在存储元素时，当存储到相同的元素时，这个元素会被剔除。原因：当用HashSet集合存储元素时，会使用add()方法，**该方法会从中调用equals方法来判断下次存储的元素是否相同，而equals方法又是根据对象的hashCode来判断的，**当存一个元素时，该元素会分配一个hashCode值，当存入下个相同的元素时，会和前面的hashCode值比较，如果相同，则不能存入。

**       不过在存储自定义对象时**，如自定义：student类的对象时，我们认为相同属性的学生为同一个人，但是存储时却不能把相同的学生剔除。因为HashSet在存储对象时，**存储的是对象的引用**，此时，hashCode值都是不同的。因此，HashSet怎样剔除重复的自定义对象呢？**重写hashCode方法**，将hashCode值设置为不同的值（默认31）。

--------------------

**LinkedHashSet**：底层是用链表实现的，是set集合中唯一一个保证怎么存就怎么取的集合对象， 因为是HashSet的子类，所以也保证了元素的唯一性，与HashSet原理一致 。如果要用Set集合实现有序存储可以用它。

例①：从键盘输入若干个字符，利用Set集合去除字符串中重复的字符

/*
    * ①先创建Scanner对象
    * ②创建LinkedHashSet对象，将字符存取，去掉重复
    * ③将字符串转化为字符数组，存入LinkedHashSet集合中
    * */  
    Scanner sc = new Scanner(System.in);
            System.out.print("请输入若干字符：");
            LinkedHashSet<Character> lhs = new LinkedHashSet<>();
            String s = sc.nextLine();
            char []arr = s.toCharArray();
            for(char c :arr){
                lhs.add(c);
            }
            System.out.print(lhs);

例②：去除集合中的重复元素

/*  分析：
        *  1、创建list集合存储若干个重复元素
        *  2、单独定义方法去除元素
        *  3、打印list集合
        * */
    public class TestRemoveRepeat02 {
        public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<>();
            list.add("a");
            list.add("b");
            list.add("b");
            list.add("c");
    
            System.out.print(getSingle(list));
        }
        /*去除list集合中的重复元素
        *1、创建一个LinkedHashSet集合
        * 2、将List集合中所有元素添加到LinkedHashSet集合中
        * 3、将list集合清空
        * 4、将LinkedHashSet集合中的元素添加会List集合
        * */
        public static List  getSingle(List<String> list){
            LinkedHashSet<String> lhs = new LinkedHashSet<>();
            /*for(String c :list){
                lhs.add(c);
            }*/
            lhs.addAll(list);   //不需要遍历，直接用addAll方法
            list.clear();        //将集合清空
            list.addAll(lhs);
            return list;
        }
    }

### **二、TreeSet集合** ###

**存储特点：**无索引，不可以重复

**主要作用：    **可以利用它对元素进行排序。因为在调用add()方法存储对象时，**会默认调用compareTo方法进行比较**，同样也保证了存储的唯一性。不过此外：

当compareTo方法返回零的时候只返回一个元素。（根据存储方式，改元素为树的根节点）

当compareTo方法返回正数的时候，集合会顺序存储。（保存在树的右子树）

当compareTo方法返回负数的时候，集合会倒序存取。（保存在树的左子树）

--------------------

例①：利用TreeSet集合存储若干个，自定义对象Person（属性有name、age）并根据年龄排序打印出对象。

分析：定一个Personal personal 对象，有name、age属性。因为要根据person.age来判断，默认的compareTo方法定不能满足要求，它只能实现对元素的排序，因此要重写compareTo方法，因此Personal要实现Compare<Personal>接口来实现该功能。

Persnal.java

public class Person implements Comparable<Person> {
        private String name;
        private int age;
    
        public Person() {
        }
    
        public Person(String name, int age) {
            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 + '\'' +
                    '}';
        }
        @Override
        public int compareTo(Person o) {
            int num = this.age-o.age;//年龄是比较的主要条件，姓名为次要条件
            return num==0 ? this.name.compareTo(o.name):num;
        }
    
    测试类
    public class Demo01_TreeSet {
        public static void main(String[] args) {
    
    
            /*TreeSet存储自定义对象*/
            TreeSet<Person> ts = new TreeSet<>();
            ts.add(new Person("张三",23));
            ts.add(new Person("李四",25));
            ts.add(new Person("王五",26));
            ts.add(new Person("赵六",29));
            ts.add(new Person("张三",23));
            ts.add(new Person("张3",23));
            /*按照年龄排序输出集合*/
            System.out.println(ts);
        }

--------------------

例②：在一个集合中存储了无序且重复的字符串，定义一个方法，让其有序（字典排序），且不能去重复

public class Test01 {
        public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<>();
            list.add("aaa");
            list.add("aaa");
            list.add("cc");
            list.add("ddda");
            list.add("vvvvaaa");
            list.add("ddda");
            sort(list);
            System.out.print(list);
        }
        /*
        * 定义方法：排序且去重复
        * 1、创建TreeSet集合对象，因为TreeSet集合本身具备比较功能
        * 2、将List集合中的所有元素添加到TreeSet集合中，对其排序，保留重复
        * 3、清空List集合
        * 4、将TreeSet集合排好序的集合添加至List集合中
        * */
        public static void sort(List<String> list){
            /*因为用TreeSet集合排序要去重复，因此我们必须重写它的compareTo方法来完成我们想要的功能
            * 我们采取匿名内部类的方式实现
            * */
            TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {
                @Override
                public int compare(String s1, String s2) {
                    int num = s1.compareTo(s2);//比较内容为主要条件
                    return num == 0 ? 1 : num;//当两个字符串一样时，我们把compare的值设置为1，使其保存
                }
            });
    
            ts.addAll(list);
            list.clear();
            list.addAll(ts);
        }
    }

例③：可以从键盘输入多个整数，查到输入quit时结束输入。把所有输入的数倒序排列输出

/* 可以从键盘输入多个整数，查到输入quit时结束输入。把所有输入的数倒序排列输出
        * 1、创建scanner对象
        * 2、创建TreeSet集合对象，TreeSet集合中传入比较器
        * 3、不断的接受整数，遇到quit退出.因为退出为quit，所以键盘录入时都以字符串的形式录取
        * 4、判断是quit退出，不是转化为Integer，添加到集合中
        * 5、遍历TreeSet集合
        * */
    public class Test03 {
       public static void main(String[] args) {
           Scanner sc = new Scanner(System.in);
           System.out.println("请输入数字，回车键为间隔：");
           TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {
               @Override
               public int compare(Integer i1, Integer i2) {
                   int num = i2-i1;
                   return num == 0 ? 1 : num;
               }
           });
    
           while(true){
               String line = sc.nextLine();
               if("quit".equals(line)){
                   break;
               }
               try {
                   Integer integer = Integer.parseInt(line);
                   ts.add(integer);
               }catch (Exception e){
                   System.out.println("请输入数字！");
               }
           }
           for(Integer i : ts){
               System.out.println(i);
           }
       }
    }