Java基础之Object类

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的值进行了排序