Java基础之Set集合的两个重要实现类

最新推荐文章于 2024-04-29 12:46:27 发布

小余学编程

最新推荐文章于 2024-04-29 12:46:27 发布

阅读量382

点赞数

分类专栏： Set集合文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/yushabuhui/article/details/126148373

版权

Set集合专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1、Object类

Object类是Java中所有类的基类

有构造方法，所以可以实例化，可以new对象

三个最重要的方法：

1.1 toString()
String   toString()  返回对象的字符串表示形式
    
    public String toString()
返回对象的字符串表示形式。一般来说， toString方法返回一个“textually代表”这个对象的字符串。结果应该是一个简明扼要的表达，容易让人阅读。建议所有子类覆盖此方法。

该toString类方法Object返回一个由其中的对象是一个实例，该符号字符的类的名称的字符串@` ”和对象的哈希码(内存地址)的无符号的十六进制表示。换句话说，这个方法返回一个等于下列值的字符串：
getClass().getName() + '@' +Integer.toHexString(hashCode()) 
结果

对象的字符串表现形式

class Person {
    String name;
    int age;
    //person类是Object类子类不？ 是！！！


    //
    @Override
    public String toString() {
        System.out.println("123");
        return
                "name=\"" + name + '\"' +
                ", age=" + age
                ;
    }
}
public class Demo1 {
    public static void main(String[] args) {
        Object obj = new Object();
        Person person = new Person();
        System.out.println(person);

    }
}

1.2equals()

boolean equals(Object obj) 指示一些其他对象是否等于此。

public boolean equals(Object obj) {
     return (this == obj);
 }

Object下面的equals()方法比较的是两个对象的地址。所以通常情况下，我们会重写equals() 方法。

import java.util.Objects;

class Student {
    String name;
    int age;

    public Student(String name, int age) {

        this.name = name;
        this.age = age;
    }
    //重写equlas,要求去比较内容，如果内容一样的额话，返回true


    //stu1.equals(stu2)
    //stu2赋值给了 o  向上转型 Object o =new Student();
    @Override
    public boolean equals(Object o) {
        if (this == o) {//比较是地址
            return true;
        }
        //如果地址不一样的话，再去比较内容，如果内容一样也返回true
        if (o instanceof Student) {
            //才去比较值 name  age
            Student stu = (Student)o;//向下转型
            //stu1.equals(stu2)  stu就是stu2  this 是stu1
            return stu.age == this.age && stu.name.equals(this.name);

        }
        return false;
    }


}
public class Demo2 {
    public static void main(String[] args) {
        Student stu1 = new Student("老邢", 89);
        Student stu2 = new Student("老邢", 89);
        //stu1是Object类子类，用的是object 类面的equals方法
        //Object类下面的equals方法比较是 地址  this==obj
        //System.out.println(stu1.equals(stu2));//false
        //现在我的需求是当两个对象的内容一致的时候返回的额是true
        //内容不一样的时候，返回是false
        //就意味着Object类的equals方法已经满足不了Student类的需求了
        //咋解决？ 重写equals方法
        System.out.println(stu1.equals(stu2));//true
    }
}

import java.util.Objects;

class Student1 {
    String name;
    int age;

    public Student1(String name, int age) {

        this.name = name;
        this.age = age;
    }
    //重写equlas,要求去比较内容，如果内容一样的额话，返回true
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || this.getClass() != o.getClass()){
            return false;
        }
        Student1 student1 = (Student1) o;
        return age == student1.age && Objects.equals(name, student1.name);
    }


}
public class Demo3 {
    public static void main(String[] args) {
        Student1 stu1 = new Student1("老邢", 89);
        Student1 stu2 = new Student1("老邢", 89);
        //stu1是Object类子类，用的是object 类面的equals方法
        //Object类下面的equals方法比较是 地址  this==obj
        //System.out.println(stu1.equals(stu2));//false
        //现在我的需求是当两个对象的内容一致的时候返回的额是true
        //内容不一样的时候，返回是false
        //就意味着Object类的equals方法已经满足不了Student1类的需求了
        //咋解决？ 重写equals方法
        System.out.println(stu1.equals(stu2));//true
    }
}

1.3 hashCode()

哈希码值：在Object类下面，将内存地址（十六进制的值）转为十进制的值，此时这个十进制的值就叫hash码。

返回对象的哈希码值。支持这种方法是为了散列表，如HashMap提供的那样。

hashCode的注意事项是：

只要在执行Java应用程序时多次在同一个对象上调用该方法， hashCode方法必须始终返回相同的整数，前提是修改了对象中equals比较中的信息。该整数不需要从一个应用程序的执行到相同应用程序的另一个执行保持一致。
如果根据equals(Object)方法两个对象相等，则在两个对象中的每个对象上调用hashCode方法必须产生相同的整数结果。
不要求如果两个对象根据equals(java.lang.Object)方法不相等，那么在两个对象中的每个对象上调用hashCode方法必须产生不同的整数结果。但是，程序员应该意识到，为不等对象生成不同的整数结果可能会提高哈希表的性能。

尽可能多的合理实用，由类别Object定义的hashCode方法确实为不同对象返回不同的整数。（hash码的值通常通过将对象的内部地址转换为整数来实现，但Java的编程语言不需要此实现技术。）

class Cat {}
public class Demo4 {
    public static void main(String[] args) {
        Cat cat1 = new Cat();
        Cat cat2 = new Cat();
        System.out.println(cat1.hashCode());
        System.out.println(cat2.hashCode());
        String str = new String("a");
        String str1 = new String("b");
        String str2 = new String("a");
        //现在真他娘的尴尬，Object类的hash值是内存地址十进制的转换
        //只要你内U存地址不一样，hash值一定不一样
        //但是你看看str和str2 ，内存地址不一样，但是
        //hash值是一样的？咋回事？在String类中重写了hashCode
        //方法
        System.out.println(str.hashCode());//97
        System.out.println(str1.hashCode());//98
        System.out.println(str2.hashCode());//97
    }
}

注意：

无论何时重写equals方法，通常需要重写hashCode方法，以便维护hashCode方法的通用合同，该方法规定相等的对象必须具有相等的哈希码。

import java.util.Objects;

class Dog {
    int id;
    String name;

    public Dog(int id, String name) {
        this.id = id;
        this.name = name;
    }
    public boolean equals (Object o) {
        if (this ==  o) {
            return  true;
        }
        if (o instanceof Dog) {
            Dog dog = (Dog)o;
            return this.id == dog.id && dog.name.equals(this.name);
        }
        return false;
    }

    @Override
    public int hashCode() {
        return name.hashCode() + id;
    }
}
public class Demo5 {
    public static void main(String[] args) {
        Dog dog1 = new Dog( 3, "a");
        Dog dog2 = new Dog( 2, "b");
        //现在关注的是内容，如果内容一样 调用equals方法的时候
        //必须返回一个true
        System.out.println(dog1.equals(dog2));//true
        //此时这个两个对象的hash值一样不一样？因为内存地址不一样的
        System.out.println(dog1.hashCode());
        System.out.println(dog2.hashCode());
        //现在hashCode不一样咋办？ 重写hashCode即可
//如果根据equals(Object)方法两个对象相等，
// 则在两个对象中的每个对象上调用hashCode方法必须产生相同的整数结果。
        //如果两个对象的hash值一样，对象是不一定一样的。但是如果两个对象相等
        //那么hash值一定相等
    }
}

import java.util.Objects;

class Panda {
    int id;
    String name;

    public Panda(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Panda panda = (Panda) o;
        return id == panda.id && Objects.equals(name, panda.name);
    }

    @Override
    public int hashCode() {
        return id;
    }
}
public class Demo6 {
    public static void main(String[] args) {
        String str1 = new String("ab");
        String str2 = new String("a");
        System.out.println(str1.equals(str2));//true
        //31 * 97+ 98
        System.out.println(str1.hashCode());//3105
        System.out.println(str2.hashCode());
        //STring类下面的hashCode重写的Object类下面的

        Integer i1 = new Integer(45);
        Integer i2 = new Integer(45);
        System.out.println(i1 == i2);//false
        System.out.println(i1.equals(i2));//true
        //大胆猜测一下 hash值是啥？
        System.out.println(i1.hashCode());
        System.out.println(i2.hashCode());

        Panda panda1 = new Panda(67, "狗蛋");
        Panda panda2 = new Panda(67, "狗蛋");
        System.out.println(panda2.equals(panda1));
        System.out.println(panda1.hashCode());
        System.out.println(panda2.hashCode());
    }
}

2、Set集合

Set集合用来存储数据，它也是一个接口，父接口是Collection

存储数据的特征：无序的不可重复的

Set接口有两个实现类：

HashSet：靠hash值进行存储的，如果两个元素hash值一样的话，就不再存储了

TreeSet：底层是二叉树，对存储数据进行自然排序

2.1hashSet 类

HashSet这个类的方法和Collection 接口和Set接口下面的方法是一样的

也有自己独有的方法，类似于ArrayList

import java.util.HashSet;
import java.util.Set;

public class Demo1 {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        //set集合存储的无序的  不可重复的
        set.add("b");
        set.add("a");
        set.add("d");
        set.add("c");
        set.add("a");
        set.add("ad");
        System.out.println(set);

        Set<Integer> set1 = new HashSet<>();
        set1.add(78);
        set1.add(23);
        set1.add(100);
        set1.add(56);
        System.out.println(set1);
        set1.remove(23);
        //循环
        for (Integer integer : set1) {
            System.out.println(integer);
        }

    }
}

2.2HashSet 集合村对象

使用HsshSet存取自定义对象时，需要用快捷键重写equals 方法和hashCode方法。

重写的目的：防止加入重复的元素



import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

class Person {
    int id;
    String name;

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return id == person.id && Objects.equals(name, person.name);
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Person person1 = new Person(1, "zhangsan");
        Person person2 = new Person(1, "李四");
        Person person3 = new Person(1, "李四");
        Person person4 = new Person(1, "李四");
        Set<Person> set = new HashSet<>();
        //在调用add方法的时候 底层在调用hashCode方法和equals
        set.add(person1);
        set.add(person2);
        set.add(person3);
        set.add(person4);
        System.out.println(set);
        //感觉不太合适，发现存的两个对象的内容是一样。真实开发的时候
        //只关注内容的，如果内容一样，我也让你存不进去。！！！
        //咋办

        //总结：以后set集合中如果想存对象的时候，要求对象的内容如果一样的
        //话，不能存到set集合中，咋办？重写equals方法和hahsCode方法


        //hash值不一样，对象一定不一样。
        //对象一样的话，hash只能一定一样
    }
}

2.3TreeSet集合

也是实现了Set集合，可以保证数据唯一性，存储也是无序的

import java.util.Set;
import java.util.TreeSet;

public class Demo1 {
    public static void main(String[] args) {
        //TreeSet在存储的数据的时候 会排序
        Set<Integer> set = new TreeSet<>();
        set.add(89);
        set.add(79);
        set.add(69);
        set.add(109);
        set.add(39);
        System.out.println(set);

        Set<String> set1 = new TreeSet<>();
        set1.add("d");
        set1.add("w");
        set1.add("a");
        set1.add("c");
        System.out.println(set1);
    }
}

2.4 TreeSet 集合中存储的是对象

如果想要在TreeSet集合中添加自定义对象时，需要实现Comparable接口

并且重写它的抽象方法：
int compareTo(T o) 将此对象与指定的对象进行比较以进行排序。
将此对象与指定的对象进行比较以进行排序。返回一个负整数，零或正整数，因为该对象小于，等于或大于指定对象。

调用方法：
stu1.comparetTo(stu2);
得有一个int类型数据进行比较

好好思考一个问题：你得给我返回一个int类型的数据

stu1有age变量 stu1的年龄减去 stu2的年领

如果年龄返回值是一个负数的话： stu1的年领小与 stu 2

如果年龄返回值是一个0的话，stu1的年龄和stu2年龄相等

如果年龄返回值是一个正整数的话： stu1的年领大于 stu 2
set.add(stu1);  第一次调用compareTo
stu1和stu1在比较   45-45 =0   只保留 stu1

set.add(stu2)的时候
又调用compareTo（） 第二次调用compareTo
o:stu1
this: stu2  35 - 45  = -10 负数  stu2 比stu1小  咋排  [stu2,  stu1]

set.add(stu3)的时候  第三次调用compareTo
this:  stu3
o: stu1
	[stu3, stu1]

		第四次调用compareTo
		this:stu3
		o:stu2  [stu3  stu2]
		[stu3 stu2 stu1]

import java.util.Set;
import java.util.TreeSet;

class Student implements Comparable<Student>{
    String name;
    int age;

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

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

    @Override
    public int compareTo(Student o) {
        System.out.println("123");
        int num = this.age - o.age;
        return num;
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Student stu1 = new Student("老邢", 45);
        Student stu2 = new Student("老邢", 35);
        Student stu3 = new Student("saolei", 25);
        Student stu4 = new Student("老万", 87);
        //按照年龄进行排序 存到TreeSet集合中
        Set<Student> set = new TreeSet<>();
        set.add(stu1);
        set.add(stu2);
        set.add(stu3);
        set.add(stu4);
        System.out.println(set);

        //  Exception in thread "main" java.lang.ClassCastException:
        //  com.qfedu.c_treeSet.Student cannot be cast to java.lang.Comparable
        //	at java.util.TreeMap.compare(TreeMap.java:1294)
        //类转换异常的错误，Student转换不了Comparable
        //y因为底层在进行排序的时候，实现了Comparable这个接口
        //为啥泛型String没有报错  Integer也没有报错
    }
}