Java初学者日志_集合_Set

于 2021-03-08 22:23:03 发布
阅读量271 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： java日记 文章标签： java 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/dream_start_/article/details/114519900
这篇博客探讨了Java中的Set接口及其主要实现类，包括HashSet、LinkedHashSet和TreeSet。HashSet是线程不安全的，存储无序且不可重复的数据。LinkedHashSet通过双向链表保持插入顺序。TreeSet则基于二叉树，可按对象属性排序。文章还解释了Set接口中数据的无序性和不可重复性的概念，并讨论了equals()和hashCode()在数据添加过程中的作用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Set接口的框架结构
-----Collection接口:单列集合，用来存储一个一个的对象
–Set接口：存储无序的，不可重复的数据(高中讲的“集合”)
-----HashSet:Set接口的主要实现类；线程不安全，可以存储null
-----LinkedSet：作为HashSet的子类，特点是加了一个Linked，使得遍历内部数据时，可以按照添加的顺序遍历
-----TreeSet:使用二叉树存储，放入其中的数据是同一类的，进而可以按照添加对象的指定属性进行排序

如何理解无序的，不可重复的数据：
1：无序性
无序性不等于随机性(HashSet为例)，HashSet底层也是按照数组存的，存储的数据在底层数组中并非按照数组索引的顺序添加(添加的时候与程序中元素的顺序无关)，根据数据的Hash值决定的

2：不可重复性
在Set中的数据是不能重复的，使用equals判断 ，相同的元素只能添加一个

添加数据的过程：以HashSet为例
首先计算第一个元素的Hash值(使用对象的属性计算)，算出之后进行一些操作，得到在数组中的位置，然后将他存储在数组中(数组的长度默认为16)，然后计算第二个元素的Hash值，进行与第一个元素相同的操作，得到位置之后先查看该位置有没有元素，没有之后再存入数组中，依次进行，如果接下来有个元素在数组中的位置已经被占领了，先比较两个元素的Hash值，如果不一样，则使用链表进行连接，如果Hash值一样，则使用equals比较两个元素是否相同

在这里插入图片描述
链表：
JDK 7 ：新的元素放在数组中指向旧的元素
JDK 8 ：与JDK 7 相反

User：


import java.beans.IntrospectionException;
import java.util.Objects;

public class User implements Comparable {
    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    public User(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        System.out.println("User equals");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age &&
                Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(age, name);
    }


    //按照姓名从小到大排列,年龄从小到大排列

    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user=(User)o;
            //return this.name.compareTo(user.name);
            //从大到小
            //return -this.name.compareTo(user.name);
            int  compare = this.name.compareTo(user.name);
            if(compare!=0){
                return compare;

            }else {
                return Integer.compare(this.age,user.age);
            }
        }else{
            throw new RuntimeException("输入的类型不匹配");
        }
    }
}


package com.jihe.java1.SetTest;
/*Set接口的框架结构
  -----Collection接口:单列集合，用来存储一个一个的对象
        *      --Set接口：存储无序的，不可重复的数据(高中讲的“集合”)
        *         -----HashSet,LinkedSet,TreeSet
*/
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
//Set接口中没有额外定义的新方法，使用的都是Collection中的方法
//要求：1.向Set中添加的数据其所在的类一定要重写HashCode() equals()
//      2.重写的HashCode() equals()尽可能保持一致性，相等的对象必须具有相等的Hash值
public class HashSetTese_1 {
    public void test1() {
        Set set = new HashSet();
        set.add(456);
        set.add(123);
        set.add(759);
        set.add("AA");
        set.add("BB");
        set.add(new User(20, "JOJO"));
        set.add(new User(20, "JOJO"));
        System.out.println(set);
        System.out.println("使用iterator迭代器进行遍历输出");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
    public static void main(String[] args) {
        HashSetTese_1 s=new HashSetTese_1();
        s.test1();
    }
}

在这里插入图片描述

LinkedHashSet：
为什么LinkedHashSet的输出和程序中元素的顺序相同？
LinkedHashSet是在HashSet的基础上，使用了双向链表，记录添加顺序
优点：对于频繁地遍历操作，LinkedHashSet的效率高于HashSet；

在这里插入图片描述

package com.jihe.java1.SetTest;
//LinkedHashSet

import java.util.LinkedHashSet;
import java.util.Set;

public class LinkedHashSetTest {
    public void test1(){
        Set set=new LinkedHashSet();
        set.add(456);
        set.add(123);
        set.add(759);
        set.add("AA");
        set.add("BB");
        set.add(new User(20, "JOJO"));
        set.add(new User(20, "JOJO"));
        System.out.println(set);
    }

    public static void main(String[] args) {
        LinkedHashSetTest l=new LinkedHashSetTest();
        l.test1();
    }
}

在这里插入图片描述

TreeSet:

package com.jihe.java1.SetTest;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
//TreeSet中添加的数据，要求是同一个类提供的
//两种排序方式：自然排序：comparable  定制排序 ：comparetor
public class TreeSetTest {
    public void test(){
        Set set=new TreeSet();
        //不能添加不同类的数据
/*        set.add(456);
        set.add(759);
        set.add(123);
        set.add("AA");
        set.add("BB");
        set.add(new User(20, "JOJO"));*/
        /*//例子一：
        set.add(456);
        set.add(759);
        set.add(123);*/
        //例子二
        //先比较name中的值，后比较age
        set.add(new User(12,"D"));
        set.add(new User(13,"J"));
        set.add(new User(14,"O"));
        set.add(new User(15,"I"));
        System.out.println(set);
    }
    public void test2(){
        Comparator com=new Comparator() {
            //按照年龄从小到大排序
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1=(User)o1;
                    User u2=(User)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }else {
                    throw new RuntimeException("输入的数据类型不匹配");
                }
            }
        };
        TreeSet set=new TreeSet(com);
        set.add(new User(12,"D"));
        set.add(new User(13,"J"));
        set.add(new User(14,"O"));
        set.add(new User(14,"M"));
        set.add(new User(15,"I"));
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }


    public static void main(String[] args) {
        TreeSetTest t=new TreeSetTest();
        t.test();
        t.test2();
    }
}

重写equals() HashCode()

练习：

package com.jihe.java1.exer.TreeSet;

import com.jihe.java1.exer.TreeSet.Employee;
import com.jihe.java1.exer.TreeSet.Mydate;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class TreeSet_lx {
    //按照生日日期先后排序
    public void test2(){

        TreeSet set=new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Employee && o2 instanceof Employee){//判断o1,o2是否为Employee的一个实例或对象
                    Employee e1=(Employee)o1;
                    Employee e2=(Employee)o2;
                    Mydate b1 = e1.getBirthday();
                    Mydate b2 = e2.getBirthday();
                    //方式一
                    //比较年
                    int sumYear=b1.getYear()-b2.getYear();
                    if(sumYear!=0){
                        return sumYear;
                    }
                    //比较月
                    int summonth=b1.getMonth()-b2.getMonth();
                    if(summonth!=0){
                        return summonth;
                    }
                    //比较日
                    return b1.getDay()-b2.getDay();


                }
                //return 0;
                throw new RuntimeException("传入的数据类型不一样");
            }
        });
        Employee e1=new Employee("ldh",55,new Mydate(1964,12,24));
        Employee e2=new Employee("hg",50,new Mydate(1974,3,14));
        Employee e3=new Employee("zj",45,new Mydate(1969,4,28));
        Employee e4=new Employee("zxc",51,new Mydate(1970,6,5));
        Employee e5=new Employee("zgr",40,new Mydate(1970,6,25));
        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        set.add(e5);
        Iterator iterator=set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }


    //自然排序
    public void test(){
        TreeSet set=new TreeSet();
        Employee e1=new Employee("ldh",55,new Mydate(1964,12,24));
        Employee e2=new Employee("hg",50,new Mydate(1974,3,14));
        Employee e3=new Employee("zj",45,new Mydate(1969,4,28));
        Employee e4=new Employee("zxc",51,new Mydate(1972,5,5));
        Employee e5=new Employee("zgr",40,new Mydate(1970,6,25));
        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        set.add(e5);
        //增强for循环
        for(Object obj:set){
            System.out.println(obj);
        }
        //iterator迭代器
        /*Iterator iterator=set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }*/
    }

    public static void main(String[] args) {
        TreeSet_lx t=new TreeSet_lx();
        System.out.println("按照名字排序");
        t.test();
        System.out.println("按照生日排序");
        t.test2();
    }
}

package com.jihe.java1.exer.TreeSet;

class Mydate {
    private int year;
    private int month;
    private int day;



    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }

    public Mydate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public Mydate() {
    }

    @Override
    public String toString() {
        return "Mydate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }
}

package com.jihe.java1.exer.TreeSet;

public class Employee implements Comparable{
    private String name;
    private int age;
    private Mydate birthday;

    public Employee(String name, int age, Mydate birthday) {
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public Employee() {
    }

    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;
    }

    public Mydate getBirthday() {
        return birthday;
    }

    public void setBirthday(Mydate birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", birthday=" + birthday +//调用自己的toString,输出年月日
                '}';
    }
    //按照name排名
    @Override
    public int compareTo(Object o) {
        if(o instanceof Employee){//判断o是否为Employee的一个实例或对象
            Employee e=(Employee)o;
            return this.name.compareTo(e.name);
        }
        return 0;
    }
}

重要

package com.jihe.java1.exer.TreeSet;

import java.util.HashSet;

public class exer_ms {
    public void test1(){
        HashSet set=new HashSet();
        Person p1=new Person(1001,"aa");
        Person p2 =new Person(1002,"bb");
        set.add(p1);
        set.add(p2);
        System.out.println(set);//set通过p1,p2的Hash值进行索引，Hash值是根据p1中的属性计算得到的


        p1.name="cc";//将p1中的name改为cc之后，再计算p1的Hash值，此时的Hash值已经改变了，但是P1的存储位置没有改变
        System.out.println(set);

        set.remove(p1);//这里remove p1是根据p1的Hash值寻找的，但是因为p1的name已经改变了，所以Hash值也随之变化，所以set根据此时的Hash值寻找到的地址并不是最初p1的存储地址
        System.out.println(set);
        set.add(new Person(1001,"cc"));
        System.out.println(set);
        set.add(new Person(1001,"aa"));
        System.out.println(set);
    }

    public static void main(String[] args) {
        exer_ms e=new exer_ms();
        e.test1();
    }
}

Person类定义id，name，空构造器，带参构造器，toString方法，equals()和hashcode()

在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值