Java基础之Object类

Posted 2021-08-26 Ocean:)

Object类

Java中所有类的基类

Java中所有类都是间接或直接继承Object类

Object类的引用数据类型变量可以保存Java中任意数据类型空间的首地址

Object类内规定了一些方法：

• String toString();

  当前对象建议String类型描述，默认情况是当前类所属包名，类名@十六进制内存地址，如果对于数据类型展示有要求，可以重写toString方法，在暂时的方法中默认执行toString方法

• int hashCode();

  内存中当前对象的唯一索引值，默认情况下是当前对象所处空间首地址的十进制展示

• boolean equals();

  比较方法，判断两个对象是否一致，Object类内默认情况下比较方式的是地址比较,两个对象的地址一致（即hashCode值必须一致），表示是相同对象，如果期望修改equals比较规则，可以在当前类内重写

• 下三个方法与线程有关

• void wait();

• void notify();

• void notifyAll();

• 与反射有关的方法

• Class<?> getClass();

toString方法

鸡肋方法，用处不大

shift + alt + s 生成toString

在类中使用

效果如下

equals方法

比较两个对象是否一致，在Object类内默认情况下比较方式的是地址比较

根据项目需求重写equals

注意equals方法重写，hashCode也需要重写

	/*
	 * 重写equals方法
	 * 	1.判断两个对象是否是同一个对象，如果调用方法的类对象和传入参数类对象地址一致，就是同一个对象，返回true
	 * 	2.equals方法参数是Object类型，也就是任何类型的数据都可以作为参数
	 * 	需要首先判断数据类型是否一致，使用关键字instanceOf，相同数据类型再继续运行，非同类型返回false
	 * 	3.判断对象中保存的数据
	 */
	@Override
	public boolean equals(Object obj) {
		// 1.判断是不是同一个对象
		if (this == obj) {
			return true;
		}
		
		// 2.判断类型是否一致
		if(!(obj instanceof Student)) {
			return false;
		}
		
		
		// 数据类型强制转换
		Student stu = (Student) obj;
		return this.id == stu.id
				// 和Object的equals同名不同意
				&& this.name.equals(stu.name)
				&& this.age == stu.age
				&& this.gender == stu.gender;
	}

hashCode重写

在Object类内，hashCode方法，返回的内容是当前对象的首地址十进制展示方式

当前类重写equals方法之后，两个当前类对象比较结果为true，要求这两个对象的hashCode必须一致

hashCode在没有重写之前使用地址作为hashCode对应的数据，重写之后，不使用地址

可以直接使用eclipse或idea的自动补全来实现,这两个编辑器生成的形式不一样效果一样

没有重写之前

重写之后

package cn.ocean888;

public class Student {
	private int id;
	private String name;
	private int age;
	private char gender;
	
	
	public Student() {
		super();
	}


	public Student(int id, String name, int age, char gender) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.gender = gender;
	}


	public int getId() {
		return id;
	}


	public void setId(int id) {
		this.id = id;
	}


	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 char getGender() {
		return gender;
	}


	public void setGender(char gender) {
		this.gender = gender;
	}


	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + gender;
		result = prime * result + id;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}


	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		if (!(obj instanceof Student)) {
			return false;
		}
		Student other = (Student) obj;
		if (age != other.age) {
			return false;
		}
		if (gender != other.gender) {
			return false;
		}
		if (id != other.id) {
			return false;
		}
		if (name == null) {
			if (other.name != null) {
				return false;
			}
		} else if (!name.equals(other.name)) {
			return false;
		}
		return true;
	}
}

Set集合

特征：

• 无序

  添加顺序和存储顺序不一致，【不代表有排序效果】

• 不可重复

  在一个Set集合中不能出现相同元素

interface Set

​ class HashSet 底层是哈希表存储结构

​ class TreeSet 底层是一个平衡二叉树

实例:

Person类

package obj_set;

import java.time.Period;
import java.util.Objects;

import cn.ocean888.Student;

public class Person {
	int id;
	String name;
	double salary;
	
	public Person() {
	}
	
	public Person(int id, String name, double salary) {
		super();
		this.id = id;
		this.name = name;
		this.salary = salary;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

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

	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		if (!(obj instanceof Person)) {
			return false;
		}
		Person p = (Person)obj;
		return this.id == p.id
				&& this.name.equals(p.name)
				&& this.salary == p.salary;
	}

	@Override
	public String toString() {
		return "Person [id=" + id + ", name=" + name + ", salary=" + salary + "]";
	}	
}

Demo1.java

package obj_set;

import java.util.HashSet;

public class Demo1 {
	public static void main(String[] args) {
		HashSet<Person> hashSet = new HashSet<Person>();
		
		Person p1 = new Person(1, "one", 10);
		Person p2 = new Person(2, "two", 11);
		Person p3 = new Person(3, "three", 43);
		Person p4 = new Person(4, "four", 22);
		Person p5 = new Person(5, "five", 33);

		Person p6 = new Person(6, "six", 6);
		Person p7 = new Person(6, "six", 6);
		
		
		hashSet.add(p1);
		hashSet.add(p2);
		hashSet.add(p3);
		hashSet.add(p4);
		hashSet.add(p5);
		hashSet.add(p6);
		hashSet.add(p7);
		
		System.out.println(hashSet);
	}
}

运行结果

[Person [id=1, name=one, salary=10.0], Person [id=3, name=three, salary=43.0], Person [id=4, name=four, salary=22.0], Person [id=2, name=two, salary=11.0], Person [id=5, name=five, salary=33.0], Person [id=6, name=six, salary=6.0]]

有equals的限制,可以看到id相同的元素只能保存一个

TreeSet

Comparator和Comparable

例:使用Comparator接口完成排序算法

形式参数列表:(T[] arr, Comparator comparator

Person.java

package obj_comparable;

import java.util.Objects;

public class Person {
	int id;
	String name;
	double salary;
	
	public Person() {
	}
	
	public Person(int id, String name, double salary) {
		super();
		this.id = id;
		this.name = name;
		this.salary = salary;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public double getSalary() {
		return salary;
	}

	public void setSalary(double salary) {
		this.salary = salary;
	}

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

	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		if (!(obj instanceof Person)) {
			return false;
		}
		Person p = (Person)obj;
		return this.id == p.id
				&& this.name.equals(p.name)
				&& this.salary == p.salary;
	}

	@Override
	public String toString() {
		return "Person [id=" + id + ", name=" + name + ", salary=" + salary + "]";
	}
}

Demo.java

package obj_comparable;

import java.math.BigDecimal;
import java.security.PublicKey;
import java.util.Arrays;
import java.util.Comparator;

public class Demo {
	public static void main(String[] args) {
		Person person1 = new Person(1, "one", 101.11);
		Person person2 = new Person(2, "one", 21.22);
		Person person3 = new Person(3, "one", 342.22);
		Person person4 = new Person(4, "one", 22.89);
		
		Person[] persons = {person1, person2, person3, person4};
		
		selectSort(persons, new Comparator<Person>() {
			@Override
			public int compare(Person o1, Person o2) {
				// 因为浮点数在计算机内保存精度不定，所以需要用BigDecimal
				BigDecimal bd1 = new BigDecimal(o1.getSalary() + "");
				BigDecimal bd2 = new BigDecimal(o2.getSalary() + "");
				// subtract 减    multiply 乘
				return bd2.compareTo(bd1);
			};
		});
		
		System.out.println(Arrays.toString(persons));
	}
	
	
	// Comparator 可以自定义指定排序方法，而Comparable是自然排序顺序
	/**
	 * 满足任意类型数据进行排序操作的算法，但是要求用户根据当前数据类型数组提供对应的比较方法，借助Comparator接口实现类对象传入
	 * 
	 * @param <T> 自定义泛型
	 * @param arr 任意类型数组，同时约束当前泛型T对应的具体数据类型
	 * @param comparator Comparator接口的实现的类对象，对应的具体数据类型和数组一致
	 */
	public static <T> void selectSort(T[] arr, Comparator<T> comparator) {
		if(null == arr || null == comparator || arr.length == 0) {
			throw new NullPointerException();
		}
		
		for (int i = 0; i < arr.length - 1; i ++) {
			int index = i;
			for (int j = i + 1; j < arr.length; j ++) {
				if(comparator.compare(arr[index], arr[j]) > 0) {
					index = j;
				}
			}
			
			if (index != i) {
				T temp = arr[index];
				arr[index] = arr[i];
				arr[i] = temp;
			}
		}
	}
}

运行结果

[Person [id=2, name=one, salary=21.22], Person [id=4, name=one, salary=22.89], Person [id=1, name=one, salary=101.11], Person [id=3, name=one, salary=342.22]]

可以看出结果已经根据salary的值进行了排序