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]