java中的object是对象_java中的Object对象

java把现实中的任何事物都当做一个对象(Object),java是面向对象的.此处Object在java中被定义为一个顶级父类,他是任何类的父类,我们可以显示继承它,也可以隐式继承

例:public class Dog extends Object{

}

等价

public class Dog{

}

Object的作用

1.equals(Object obj)

2.toString()

其中的方法会被高频率的使用,为了实现代码复用,java设计者就把这些常用的方法集中放到一个类中,这个类就是Object.

equals()

看equals之前 需要先看一下==,因为== 是判断相等,equals也是判断相等的,只是==是判断基本数据类型相等性,当然也可以直接判断两个对象,而equals主要判断对象内容,区别:

1.基本数据类型的比较==

public static void main(String[] args) {

int i = 1;

int j = 1;

boolean flag0 = true;

boolean flag1 = false;

System.out.println("i==j:"+(i==j));

System.out.println("flag0==flag1:"+(flag0==flag1));

}

//运行结果 i==j :true

//flag0==flag1 : false

2.对象的比较==

public static void main(String[] args){

Dog dog0=new Dog();

Dog dog1=new Dog();

System.out.println(("dog0==dog1")+(dog0==dog1))

}

//运行结果: dog0==dog1:false

以上== 比较的是dog0和dog1的内存首地址,由于dog0和dog1所指的对象实在内存在开辟的两个空间,所以地址是不一样的,所以打印出false

查看内存首地址

public static void main(String[] args) {

Dog dog0 = new Dog();

System.out.println(("dog0:")+dog0);

System.out.println(("dog0.toString():")+dog0.toString());

//运行结果 dog0:Dog@6b97fd

//dog0.toString():Dog@6b97fd

结果等价,也就是说直接输出引用与在引用上调用toString方法两者完全等价

目前看到的Dog@6b97fd对我们来说没有任何的意义，为了让其变得有意义，我们可以对它进行重写。比如以上实例打印dog引用时，把dog的dogName打印输出，修改以上实例如下：

public class Dog{

private String dogName;

public String getDogName() {

return dogName;

}

public void setDogName(String dogName) {

this.dogName = dogName;

}

public String toString() {

return "dog's name is:"+dogName;

}

}

入口函数

public class EqualsDemo {

public static void main(String[] args) {

Dog dog0 = new Dog();

dog0.setDogName("xiaobai");

System.out.println(("dog0:")+dog0);

}

}

//运行结果:dog0:dog's name is:xiaobai

在此有个特殊情况，如果直接定义两个内容相同的String常量，两者会指向同样一个对象：

public static void main(String[] args ){

String str0="hello";

String str1="hello";

System.out.println("str0=str1"+(str0=str1))

}

//运行结果 :str0=str1 true

但是如果通过new的方式产生String常量,则不会指向相同的对象,

public static void main(String[] args){

String str0="hello";

String str1=new String("hello");

Ststem.out.println("str0=str1"+(str0=str1)

}

//运行结果 str0=str1 false

Equals 方法主要比较的是对象的内容,但是在默认情况下,比较的是首地址内存,看实例:

创建两个类

public class Dog{

}

另一个类

public class EqualsDemo{

public static void main(String[] args){

Dog dog0=new Dog();

Dog dog1=new Dog();

System.out.println(("dog0.equals(dog1)"+dog0.equals(dog1)));

}

}

//运行结果:dog0.equals(dog1):false

可通过覆盖equals的方法来比较两个对象的内容

public class Dog {

private String dogName;

public String getDogName() {

return dogName;

}

public void setDogName(String dogName) {

this.dogName = dogName;

}

public boolean equals(Object obj) {

if (obj == null)

return false;

Dog other = (Dog) obj;

if (dogName.equals(other.dogName)){

return true;

}else{

return false;

}

}

}

入口函数

public static void main(String args[]){

Dog dog0 = new Dog();

dog0.setDogName("xiaobai");

Dog dog1 = new Dog();

dog1.setDogName("xiaobai");

System.out.println("dog0.equals(dog1):"+dog0.equals(dog1));

}

//运行结果: true

equals 比较的shineirong

==比较的是地址

在Object 中比较equals 需要重写方法 Alt+Insert

hashCode方法

HashSet和HashMap 使用后台数组(backing array)作为桶，并使用链表(linked list)存储键／值对。

桶的后台数组：如下所示

image.png

1)使用键(key)和值(value)将一个对象放入 map 中时，会隐式调用 hashCode() 方法，返回哈希值(hash code value)，比如 123。两个不同的键能够返回一样的哈希值。良好的哈希算法(hashing algorithm)能够将数值分散开。在上面的例子中，我们假设 (“John”,01/01/1956) 的键和 (“Peter”, 01/01/1995) 的键返回相同的哈希值，都是 123。

image.png

2)当返回一个 hashCode，例如是 123，初始的 HashMap 容量为 10，它如何知道存储到后台数组(backing array)的哪个索引(index)呢？HashMap 内部会调用 hash(int ) 和 indexFor(int h, int length) 方法。这被称为哈希函数(hashing function)。

简要解释下这个函数：

hashCode() % capacity

123%10=3

456%10=6

这表示，“hashCode = 123”存储在备份数组的索引3上。

容量为 10 的情况下，你可能得到的数字在 0 到 9 之间。

一旦 HashMap 达到容量的 75%，也就是哈希因子(hash factor)默认值 0.75，后台数组(backing array)的容量就会加倍，发生重散列(rehashing)为新的 20 的容量重新分配桶。

hashCode() % capacity

123%20=3

456%20=16

如上图所示，键／值对以链表形式存储。两个不同的键可以产生一样的 hashCode，例如123，并存储在同一个 bucket 中，理解这点至关重要。例如，上面例子中的 “John, 01/01/1956” 和 “Peter, 01/01/1995“ 。你如何只检索 “John, 01/01/1956” 呢？此时你的 key 所属类的 equals() 方法会被调用。它遍历 bucket 为 “123” 的 LinkedList 中的每个条目，使用 equals() 方法找到并检索出键为 “John, 01/01/1956” 的条目。这就是在你的类中实现 hashCode() 和 equals() 方法重要性的原因。如果你使用一个现有的包装类，如 Integer 或 String 作为键，它们已经实现了这两个方法。如果你使用自己写的类作为键，如 “John, 01/01/1956” 这样含有名字和出生日期属性的“MyKey”，你有责任正确地实现这些方法。

不同的对象调用 hashCode() 方法应该返回不同的值。如果不同的对象返回相同的值，会导致更多的键／值对存储在同一个 bucket 中。这会降低 HashMap 和 HashSet 的性能。

image.png

package com.company;

import java.util.HashSet;

import java.util.Set;

/**

* Created by ttc on 2018/6/8.

*/

public class EqualsDemo {

public static void main(String[] args) {

// String str1 = "hello";

// String str2 = new String("hello");

// System.out.println(str1==str2);//false

// System.out.println(str1.equals(str2));//true

System.out.println(dog1==dog2);

// System.out.println(dog1.equals(cat));

// Integer n = new Integer(2450);

// System.out.println(n.hashCode());

// int hashCode = "System.out.println".hashCode();

// int hashCode2 = "world".hashCode();

// System.out.println(hashCode);

// System.out.println(hashCode2);

Dog dog1 = new Dog(5,"xiaobai");

Dog dog2 = new Dog(5,"xiaobai");

Dog dog3 = new Dog(5,"xiaobai");

// System.out.println(dog1.hashCode());

// System.out.println(dog2.hashCode());

Set dogSet = new HashSet<>();

dogSet.add(dog1);

dogSet.add(dog2);

// dogSet.add(dog3);

System.out.println(dogSet.size());

// Map

// String str1 = new String("lisi");

// String str2 = new String("lisi");

// Set strings = new HashSet<>();

// strings.add(str1);

// strings.add(str2);

// System.out.println(strings.size());

}

}

package com.company;

import java.util.Random;

/**

* Created by ttc on 2018/6/8.

*/

public class Dog extends Object {

int age;

String name;

public Dog(int age, String name) {

this.age = age;

this.name = name;

}

@Override

public boolean equals(Object o) {

if (this == o) return true;

if (o == null || getClass() != o.getClass()) return false;

Dog dog = (Dog) o;

if (age != dog.age) return false;

if (!name.equals(dog.name)) return false;

return true;

}

@Override

public int hashCode() {

int result = age;

result = 31 * result + name.hashCode();

return result;

}

// @Override

// public boolean equals(Object o) {

// System.out.println("equals");

// if (this == o) return true;

System.out.println(o.getClass());

// if (o == null || this.getClass() != o.getClass()) return false;

//

// Dog dog = (Dog) o;

//

// if (this.age != dog.age) return false;

// return this.name.equals(dog.name);

// }

// @Override

// public int hashCode() {

// System.out.println("hashCode");

// Random random = new Random();

// int n = random.nextInt(100);

// System.out.println(n);

// return n;

// int result = age;//magicnum

// result = 31 * result + name.hashCode();

// return result;

}

}