Object类和Set集合

最新推荐文章于 2022-12-05 21:09:38 发布

javaEE初学者日常分享

最新推荐文章于 2022-12-05 21:09:38 发布

阅读量1k

点赞数

文章标签： java servlet 开发语言

本文链接：https://blog.csdn.net/m0_73050509/article/details/126148361

版权

1、Object类

子类：toString equals hashCode

Object类是Java中所有类的基类(父类)

学习Object类就是在学习它的方法

构造方法，可以直接实例化：

Object()

我们只学习Object这个类中的的三个方法

1.1 toString方法

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

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

//包含了内存地址的一串代码
getClass().getName() + '@' + Integer.toHexString(hashCode())

//返回对象的字符串表示形式
publi String toString()

在方法中重写toString方法的结果就是返回对象的字符串表示形式

class Person {
    String name;
    int age;
//重写toString方法
    @Override
    public String toString() {
        System.out.println("123");
        return
                "name=\"" + name + '\"' +
                ", age=" + age
                ;
    }
}
main：
//重写toString方法后，在测试类中输出person这个对象，就可以让数据变得可视化（能看得懂）
        Object obj = new Object();
        Person person = new Person();
        System.out.println(person);

    }
}

1.2 equals 方法

equals方法的作用就是比较对象是否相等

Object中提供的方法只是比较两个对象的地址，不看内容。

//指示一些其他对象是否等于此对象
boolean   equals(Object obj)
    //返回布尔类型数据，比较两个对象的地址想不想等
    public boolean equals(Object obj) {
    	return (this == obj)
}

为了弥补equals只能通过地址判断对象想不想等的弊端，我们可以重写equals方法，使它同时具备判断地址和内容的功能

@Override
    public boolean equals(Object obj) {
        //如果地址一样，返回true
        if (this == obj){
            return true;
        }
        //如果对象的属性相等，返回true
        if (obj instanceof Person && this.age == ((Person) obj).age && this.name == ((Person) obj).name) {
            return true;
        }
        //如果地址跟属性都不一样，就返回false
        return false;
    }
main：
//用person1.equals和person2进行比较
Person person1 = new Person("坤把", 32);
Person person2 = new Person("坤把", 32);
//打印一下返回值的结果
System.out.println(person1.equals(person2));

1.3 hashCode方法

语法格式：

//返回对象的哈希码值
int hashCode();

注意事项【规则】：

1、若在一个对象上多次使用hashCode方法，hashCode方法的返回值必须是相等的整数，前提是修改了对象中使用equals比较中的信息。【就是重写hashCode方法，且给返回值定义想要的数据】

2、在用equals方法比较的两个对象相等，那么两个对象的hashCode值也必须相等，产生同样的整数结果。【其实通过定义hashCode的返回值后，如果对象相等，那么hashCode也就相等了】

3、如果用equals方法比较的两个对象不相等，那么两个对象的hashCode产生的整数结果也不可以相等。但是有时候会存在内容不一样哈希码值一样的情况，，，【其实跟第二条一样，返回值就用属性定义，属性相等了，那么哈希码值也就相等，属性不相等，那么由属性值定义的返回值也不相等】

对象之间作比较：

哈希码值相等，内容不一定相等。

内容相等，哈希码值一定相等。

举例说明：

//这个时候两个哈希码值就都是100
public Hxm (int num, String eng){
        this.num = num;
        this.eng = eng;
    }

@Override
public int hashCode() {
        return eng.hashCode() + num;
    }

main:
Hxm hxm1 = new Hxm(3, "a");
Hxm hxm2 = new Hxm(2, "b");
System.out.println(hxm1.hashCode());
System.out.println(hxm2.hashCode());

1.4 equals和hashCode要同时重写同时使用

使用hashCode的前提就是使用equals进行对象之间的比较，为了符合规则，一般hashCode的返回值和对象作比较的值都有直接关系。

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

例如：

//hashCode的返回值就是对象的属性值。。。
public int hashCode() {
        return eng.hashCode() + num;
    }

这样才能保证，相等的对象必须拥有一样的哈希码值

2、 Set集合

Set和List一样都是Collection的子接口

二者都是存储数据的

List：有序可重复的

Set：无序不可重复的

Ste的两个实现类：
HashSet：
	依靠hash进行存储的，如果两个元素的hash值一样，就不再进行存储
TreeSet：
	底层是二叉树，对存储数据进行自然排序

2.1 HashSet集合

继承了Collection接口和Set接口下面方法的同时，也有着自己独有的方法。和ArrauList很像

定义一个HashSte集合：

//存储数据不可重复，且无序
//数据的排序是通过hash值来排序，根本就不知道数据的hash值是多少！！！
Set<数据类型> set = new HashSet<>();

具体实现类的方法可在API学习

2.2 HashSet集合中存对象

语法格式：

//先有对象
Person person1 = new Person(1, "zhangsan");
Person person2 = new Person(1, "李四");
Person person3 = new Person(1, "李四");
Person person4 = new Person(1, "李四");
//定义HashSet的集合，以【类】为泛型
Set<Person> 集合名 = new HashSet<>();
//使用add添加元素，元素的内容就是对象
集合名.add(person1);
集合名.add(person2);
集合名.add(person3);
集合名.add(person4);

2.3 TreeSte集合

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

语法格式：

//创建一个集合
//存储数据不可重复，且无序
//数据的排序是通过hash值来排序，根本就不知道数据的hash值是多少！！！
Set<数据类型> set = new TreeSet<>();

2.4 TreeSet集合中存对象

在TreeSet集合中添加对象之前，要去【实现】Comparable接口

抽象方法：

//将此对象与指定的对象进行比较，决定在集合中的位置
int compareTo(T o)

//实现Comparable接口
class Holy implements Comparable<Holy>{
    int age;
    //给属性赋值
    public Holy(int age) {
        this.age = age;
    }
	//重写Comparable接口下的compareTo方法
    //用此方法对存储的对象进行排序存入
    //Holy有age变量
    //holy1.age减去holy.2是负数就把holy1.age放在holy2.age的左边，是正数就放在右边
    @Override
    public int compareTo(Holy o) {
        int age = this.age - o.age;
        return age;
    }
	//让对象变得可视化
    @Override
    public String toString() {
        return "Holy{" +
                "age=" + age +
                '}';
    }
}

main：
		//定义几个对象
        Holy holy1 = new Holy(1);
        Holy holy2 = new Holy(5);
        Holy holy3 = new Holy(8);
        Holy holy4 = new Holy(6);
		//定义TreeSet集合，类名作为泛型
        Set<Holy> set = new TreeSet<>();
		//往集合中存储对象
        set.add(holy1);
        set.add(holy2);
        set.add(holy3);
        set.add(holy4);
        System.out.println(set);

2.4.1 compareTo的底层

package com.qfedu.c_treeSet;

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也没有报错
    }
}

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]