一、equals方法介绍

1.1.通过下面的例子掌握equals的用法

 1 package cn.galc.test;
2
3 public class TestEquals {
4 public static void main(String[] args) {
5 /**
6 * 这里使用构造方法Cat()在堆内存里面new出了两只猫,
7 * 这两只猫的color,weight,height都是一样的,
8 * 但c1和c2却永远不会相等,这是因为c1和c2分别为堆内存里面两只猫的引用对象,
9 * 里面装着可以找到这两只猫的地址,但由于两只猫在堆内存里面存储在两个不同的空间里面,
10 * 所以c1和c2分别装着不同的地址,因此c1和c2永远不会相等。
11 */
12 Cat c1 = new Cat(1, 1, 1);
13 Cat c2 = new Cat(1, 1, 1);
14 System.out.println("c1==c2的结果是:"+(c1==c2));//false
15 System.out.println("c1.equals(c2)的结果是:"+c1.equals(c2));//false
16 }
17 }
18
19 class Cat {
20 int color, weight, height;
21
22 public Cat(int color, int weight, int height) {
23 this.color = color;
24 this.weight = weight;
25 this.height = height;
26 }
27 }

1.2.画出内存分析图分析c1和c2比较的结果

程序:

Cat c1 = new Cat(1,1,1);

Cat c2 = new Cat(1,1,1);

执行完之后内存之中的布局如下图所示,

  c1指向一个对象,c2也指向一个对象,c1和c2里面装着的是这两只Cat对象在堆内存里面存储的地址,由于这两只Cat对象分别位于不同的存储空间,因此c1和c2里面装着的地址肯定不相等,因此c1和c2这两个引用对象也肯定不相等。因此执行:“System.out.println(c1==c2);”打印出来的结果肯定是false。因此你new出来了两个对象,你放心,这两个对象的引用永远不一样,一样的话就会把其中一个给覆盖掉了,这个可不成。c1是不是等于c2比较的是c1和c2这两个引用里面装着的内容,因为new出来的两个对象的它们的引用永远不一样,因此c1和c2这两个引用的内容也永远不一样,因此c1永远不可能等于c2。因此通过比较两个对象的引用是永远无法使得两个对象相等的,一模一样的。

  要想判断两个对象是否相等,不能通过比较两个对象的引用是否相等,这是永远都得不到相等的结果的,因为两个对象的引用永远不会相等,所以正确的比较方法是直接比较这两个对象,比较这两个对象的实质是不是一样的,即这两个对象里面的内容是不是相同的,通过比较这两个对象的属性值是否相同而决定这两个对象是否相等。

  Object类提供了一个equals()方法来比较两个对象的内容是否相同,因此我们可以采用这个方法去比较两个对象是否在逻辑上“相等”。如:c1.equals(c2);这里是调用从Object类继承下来的equals()方法,通过查阅API文档得到Object类里的equals方法的定义如下:

public boolean equals(Object obj)

  在Object这个类里面提供的Equals()方法默认的实现是比较当前对象的引用和你要比较的那个引用它们指向的是否是同一个对象,即和“c1==c2”这种写法是一样的,“c1.equals(c2)”与“c1==c2”是完全等价的。因此直接使用继承下来的equals()方法也是无法直接比较两个对象的内容是否相同的,为此,我们必须得重写equals()方法,改变这个方法默认的实现。

下面在Cat类里面重写这个继承下来的equals()方法

 1 class Cat {
2 int color, weight, height;
3
4 public Cat(int color, int weight, int height) {
5 this.color = color;
6 this.weight = weight;
7 this.height = height;
8 }
9
10 /**
11 * 这里是重写相等从Object类继承下来的equals()方法,改变这个方法默认的实现,
12 * 通过我们自己定义的实现来判断决定两个对象在逻辑上是否相等。
13 * 这里我们定义如果两只猫的color,weight,height都相同,
14 * 那么我们就认为这两只猫在逻辑上是一模一样的,即这两只猫是“相等”的。
15 */
16 public boolean equals(Object obj){
17 if (obj==null){
18 return false;
19 }
20 else{
21 /**
22 * instanceof是对象运算符。
23 * 对象运算符用来测定一个对象是否属于某个指定类或指定的子类的实例。
24 * 对象运算符是一个组合单词instanceof。
25 * 该运算符是一个双目运算符,其左边的表达式是一个对象,右边的表达式是一个类,
26 * 如果左边的对象是右边的类创建的对象,则运算结果为true,否则为false。
27 */
28 if (obj instanceof Cat){
29 Cat c = (Cat)obj;
30 if (c.color==this.color && c.weight==this.weight && c.height==this.height){
31 return true;
32 }
33 }
34 }
35 return false;
36 }
37 }

此时在再main方法里面执行打印的命令:

 1 public static void main(String[] args) {
2 /**
3 * 这里使用构造方法Cat()在堆内存里面new出了两只猫,
4 * 这两只猫的color,weight,height都是一样的,
5 * 但c1和c2却永远不会相等,这是因为c1和c2分别为堆内存里面两只猫的引用对象,
6 * 里面装着可以找到这两只猫的地址,但由于两只猫在堆内存里面存储在两个不同的空间里面,
7 * 所以c1和c2分别装着不同的地址,因此c1和c2永远不会相等。
8 */
9 Cat c1 = new Cat(1, 1, 1);
10 Cat c2 = new Cat(1, 1, 1);
11 System.out.println("c1==c2的结果是:"+(c1==c2));//false
12 System.out.println("c1.equals(c2)的结果是:"+c1.equals(c2));//true
13 }

  这一次得到的结果就与上次没有重写equals()方法时得到的结果就不一样了:

  “System.out.println(c1 == c2);”打印出来的结果依然是false,因为这里是比较两个对象的引用里面的内容,这两个引用里面的内容当然不相等,而且永远不会相等,所以打印出来的结果肯定是false。

  “System.out.println(c1.equals(c2));”打印出来的结果为true,因为我们在Cat类里面重写了equals()方法,改变了这个方法默认的实现,我们把方法的实现改为只要这个两个对象是真的存在,并且都是猫,并且它们的颜色(color),身高(height)和体重(weight)都相同,那么这两只猫在逻辑上就是一模一样的,是完全相同的两只猫,即这两只猫是“相等”的。所以这里打印出来的结果是true。

1.3.如何比较两个字符串对象是否相等?

看下面的例子:

1 public class TestEquals {
2
3 public static void main(String args[]){
4 String s1 = new String("hello");
5 String s2 = new String("hello");
6 System.out.println("s1 == s2的结果是:"+(s1 == s2));//false
7 System.out.println("s1.equals(s2)的结果是:"+s1.equals(s2));//true
8 }
9 }

这一次是比较两个字符串对象是否相等:

  System.out.println(s1 == s2);

  打印出来的结果依然是fase,因为这里比较的是s1和s2两个字符串对象的引用,两个对象的引用永远不会相等,所以打印出来的结果为false。

  System.out.println(s1.equals(s2));

  打印出来的结果为true,因为在String类里面重写了从Object类继承(所有的类都是从Object类继承下来,String类当然也不例外,从父类继承下来就拥有了父类的一切属性与方法,所以Sting类里面也有equals()方法,并且还把这个继承下来的equals()方法重写了)下来的equals()方法,改变了这个方法默认的实现,

  在String类里面是这样重写equals()方法的实现的:用当前的这个字符串对象和指定的字符串对象比较,指定的字符串对象不能为空并且这个对象的字符序列和当前这个字符串对象的字符串序列一样,如果这些条件都满足,那么这两个字符串对象就是相等的。

因此这里的s2已经满足了条件,所以打印出来的结果是true。

  以后在某一个类里面比较两个对象是否相等时,首先去API文档里面查找这个类是否重写了从Object类继承下来的equals()方法。如果重写了equals()方法,那么在比较两个对象是否相等时调用的就是重写以后的equals()方法,如果没有重写,那么调用时就是直接调用从Object类里面的继承下来的那个equals()方法,并且采用equals()方法默认的实现去比较两个对象是否相等。因此每一个类都可以根据需要对从Object类继承下来的equals()方法进行重写。

  对于在API文档里面找某个类,如果一个类不用引入包就可以直接使用,那么这个类肯定是在java.lang这个包里面,如这里的String类,直接就可以使用了,所以String类一定是在java.lang这个包里面。使用某个类时看这个类引入的是哪个包,然后就去这个包里面找这个类,不用引入包的类一定是位于java.lang里面,直接去java.lang里面找就可以了。

  总结:比较两个对象是否相等,我们采用equals()方法,判断两个对象是否相等的条件是由我们重写equals()方法的实现后定义的,这样就可以比较灵活地使用equals()方法在不同的类里面比较位于同一类下的两个对象是否相等了。

Java基础学习总结(1)——equals方法的更多相关文章

  1. Java基础之"=="和 和 equals 方法的区别

    一."=="操作符 ==操作符专门用来比较两个变量的值是否相等,也就是用于比较变量所对应的内存中所存储的数值是否相同,要比较两个基本类型的数据或两个引用变量是否相等,只能用==操作 ...

  2. java===java基础学习(12)---方法的重写和重载

    覆盖 / 重写(Override) 重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变.即外壳不变,核心重写! 重写的好处在于子类可以根据需要,定义特定于自己的行为. 也 ...

  3. java===java基础学习(9)---方法参数

    方法参数注意三要点: 一个方法不能修改一个基本数据类型的参数(数值型或者布尔型). 一个方法可以改变一个对象参数的状态. 一个方法不能让对象参数引用一个新的对象. package testbotoo; ...

  4. java基础解析系列(十一)---equals、==和hashcode方法

    java基础解析系列(十一)---equals.==和hashcode方法 目录 java基础解析系列(一)---String.StringBuffer.StringBuilder java基础解析系 ...

  5. 转载-java基础学习汇总

    共2页: 1 2 下一页  Java制作证书的工具keytool用法总结 孤傲苍狼 2014-06-24 11:03 阅读:25751 评论:3     Java基础学习总结——Java对象的序列化和 ...

  6. JAVA基础学习-集合三-Map、HashMap,TreeMap与常用API

    森林森 一份耕耘,一份收获 博客园 首页 新随笔 联系 管理 订阅 随笔- 397  文章- 0  评论- 78  JAVA基础学习day16--集合三-Map.HashMap,TreeMap与常用A ...

  7. 尚学堂JAVA基础学习笔记

    目录 尚学堂JAVA基础学习笔记 写在前面 第1章 JAVA入门 第2章 数据类型和运算符 第3章 控制语句 第4章 Java面向对象基础 1. 面向对象基础 2. 面向对象的内存分析 3. 构造方法 ...

  8. Java基础学习(2)

    Java基础学习(二) 面向对象 对象:客观存在的事物 面向对象:人具体关注的事物的某些信息 类:是模子,确定对象会拥有的特征(属性)和行为(方法) 对象的属性:对象具有的各种特征 对象的方法:对象能 ...

  9. Java基础学习笔记总结

    Java基础学习笔记一 Java介绍 Java基础学习笔记二 Java基础语法之变量.数据类型 Java基础学习笔记三 Java基础语法之流程控制语句.循环 Java基础学习笔记四 Java基础语法之 ...

  10. java基础学习总结——java环境变量配置(转)

    只为成功找方法,不为失败找借口! 永不放弃,一切皆有可能!!! java基础学习总结——java环境变量配置 前言 学习java的第一步就要搭建java的学习环境,首先是要安装 JDK,JDK安装好之 ...

随机推荐

  1. 【转】Retina 屏幕下,网页图片的显示兼容

    感谢 Apple,带来了 Retina 屏幕的革命,让我们可以在电子显示屏上享受到印刷级的分辨率.由于分辨率的提升,网页中的文字.Flash 和 SVG 内容显示得比原来更加精细,但网页中的图片却变得 ...

  2. HDU 4458 Shoot the Airplane( 判断点在多边形内外 )

    链接:传送门 题意:这个游戏是一个2D打飞机游戏,飞机以速度 v 水平飞行,它是一个简单的多边形,玩家从( 0 , 0 )向上射击,子弹有一个出速度 b ,子弹可以看作一个点,打中飞机边缘是无法击落飞 ...

  3. Linux下安装Solr7.5.0,并部署到Tomcat

    收藏地址:https://blog.csdn.net/qq_39135287/article/details/84260724

  4. debian 9 配置ati驱动

    可以参考debian wiki 1.识别自己显卡驱动 lspci -nn | grep VGA 2.添加源 # Debian "stretch" deb http://httpre ...

  5. db2 -- 存储过程01

    接下来项目在技能可能偏向数据库方面,补习下. 学习写第一个db2在存储过程,记录下. ---- stored procedures code CREATE OR REPLACE PROCEDURE & ...

  6. mysql局域网服务搭建

    首先配置电脑Mysql环境变量 新建 Mysql服务配置 CMD >命令 : mysql -u root -p 4. 创建用户 Mysql 用户权限分配 5 重启服务 如果还不能访问就一定是你的 ...

  7. POJ 3695

    可以用容斥原理来求.求两个矩形的并的时候可以使用条件 x1=max(p.x1,q.x1);y1=max(p.y1,q.y1);x2=min(p.x2,q.x2);y2=min(p.y2,q.y2); ...

  8. 小记 SqlHelper

    using System;using System.Collections.Generic;using System.Data;using System.Linq;using System.Web;u ...

  9. JVM的重排序

    重排序一般是编译器或执行时环境为了优化程序性能而採取的对指令进行又一次排序执行的一种手段.重排序分为两类:编译期重排序和执行期重排序,分别相应编译时和执行时环境. 在并发程序中,程序猿会特别关注不同进 ...

  10. python部分

    读取骨骼数据相关的多个json,拼接到一起 # -- coding: utf-8 -- import os path = "./test" #文件夹目录 files= os.lis ...