equals和==的区别（理解java数据存储原理）

最新推荐文章于 2024-07-21 15:25:30 发布

ruanlinghao

最新推荐文章于 2024-07-21 15:25:30 发布

阅读量1.1k

点赞数 1

文章标签： java

本文链接：https://blog.csdn.net/cjd_cn/article/details/81091151

版权

总之，==比较的是引用类型的址或基本数据类型的值，java中的==是用来判断对象所使用的内存地址是不是同一个，进而判断是不是同一个对象。equals()是Oblect类的一个方法，如果子类重写了，比较的是值，否者它和==相同比较的是址，就是比较两个变量是否引用的是同一对象。例如String，Integer重写了equals()方法

注意到：特殊。。。如下。。引用类型String的变量，用==比较a和b是相等的，a和d是不相等的。只有new会创建一个新的对象，为其分配内存空间。 Integer int1=128;Integer int2=128; int1==int2结果是false。 Integer int1=127;Integer int2=127; int1==int2结果是true。128以内的数进行自动封箱会激发对象池操作

java数据的存储原理（栈和堆）

如int a = 3；这里的a是一个指向int类型的引用，指向3这个字面值。出于追求速度的原因，就存在于栈中，栈有一个很重要的特殊性，就是存在栈中的数据可以共享。

比如：我们同时定义：

int a=3; int b=3;

编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找有没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，然后将a指向3的地址。接着处理int b = 3；在创建完b这个引用变量后，由于在栈中已经有3这个字面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的情况。

定义完a与b的值后，再令a = 4；那么，b不会等于4，还是等于3。在编译器内部，遇到时，它就会重新搜索栈中是否有4的字面值，如果没有，重新开辟地址存放4的值；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。

在java中，创建一个对象包括对象的声明和实例化两步，声明一个对象rect时，将在栈内存为对象的引用变量rect分配内存空间，但Rectangle的值为空，称rect是一个空对象。空对象不能使用，因为它还没有引用任何”实体”。 (2)对象实例化时的内存模型当执行rect=new Rectangle(3,5)；时，会做两件事：在堆内存中为类的成员变量width,height分配内存，并将其初始化为各数据类型的默认值；接着进行显式初始化（类定义时的初始化值）；最后调用构造方法，为成员变量赋值。返回堆内存中对象的引用（相当于首地址）给引用变量rect,以后就可以通过rect来引用堆内存中的对象了。一个类通过使用new运算符可以创建多个不同的对象实例，这些对象实例将在堆中被分配不同的内存空间，改变其中一个对象的状态不会影响其他对象的状态。

Rectangle r1=new Rectangle(3,5);
Rectangle r2=r1;

则在堆内存中只创建了一个对象实例，在栈内存中创建了两个对象引用，两个对象引用同时指向一个对象实例。

String是一个特殊的包装类数据。可以用以下两种方式创建：String str = new String(“abc”)；String str = “abc”; 第一种创建方式，和普通对象的的创建过程一样；第二种创建方式，java内部将此语句转化为以下几个步骤： (1)先定义一个名为str的对String类的对象引用变量：String str； (2)在栈中查找有没有存放值为”abc”的地址，如果没有，则开辟一个存放字面值为”abc” 地址，接着创建一个新的String类的对象o，并将o的字符串值指向这个地址，而且在栈这个地址旁边记下这个引用的对象o。如果已经有了值为”abc”的地址，则查找对象o，并回o的地址。 (3)将str指向对象o的地址。值得注意的是，一般String类中字符串值都是直接存值的。但像String str = “abc”；这种合下，其字符串值却是保存了一个指向存在栈中数据的引用。为了更好地说明这个问题，我们可以通过以下的几个代码进行验证。

String str1="abc"；
String str2="abc"；
System.out.println(s1==s2)；//true

注意，这里并不用 str1.equals(str2)；的方式，因为这将比较两个字符串的值是否相等。==号，根据JDK的说明，只有在两个引用都指向了同一个对象时才返回真值。而我们在这里要看的是，str1与str2是否都指向了同一个对象。我们再接着看以下的代码。

String str1= new String("abc")；
String str2= "abc"；
System.out.println(str1==str2)；//false

创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。以上两段代码说明，只要是用new()来新建对象的，都会在堆中创建，而且其字符串是单独存值的，即使与栈中的数据相同，也不会与栈中的数据共享。

String a="aaa";   Java中存在一个串池，
       String b="aaa"; a和b引用的是同一个字符串对象.这两句只会创建一个"aaa"字符串放入串池里面,a和b只是这个字符    串的两个引用而已.

       String c=a;
       String d=new String("aaa");   new 出来的String类型和a这种“常量型”声明不同，在内存上也放在的不同的地方，在Java 中String里面的==判断，是在内存地址上是不同的，不是同一个对象，==比较的就是不是同一个对象。任何new出来的类型变量都不会“相等”。
       System.out.println(a.equals(b));==>true
       System.out.println(a==b);==>true

       System.out.println(a.equals(c));==>true
       System.out.println(a==c);==>true

       System.out.println(a.equals(d));==>true
       System.out.println(a==d);==>false

特殊==============

   Integer int1=128;
       Integer int2=128;

       System.out.println(int1.equals(int2));==>true
       System.out.println(int1==int2);==>false

Integer int1=127;
Integer int2=127;

       System.out.println(int1.equals(int2));==>true
       System.out.println(int1==int2);==>true 128以内的数进行自动封箱会激发对象池操作

附：

Java中基本数据类型的存储方式和相关内存的处理方式（java程序员必读经典）

https://www.cnblogs.com/xiohao/p/4278173.html

java中数据在内存中是如何存储的

a)基本数据类型

java的基本数据类型共有8种，即int,short,long,byte,float,double,boolean,char(注意，并没有String的基本类型 )。这种类型的定义是通过诸如int a = 3；long b = 255L；的形式来定义的。如int a = 3；这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，由于大小可知，生存期可知(这些字面值定义在某个程序块里面，程序块退出后，字段值就消失了)，出于追求速度的原因，就存在于栈中。

另外，栈有一个很重要的特殊性，就是存在栈中的数据可以共享。比如：我们同时定义：

int a=3; int b=3;

b)对象

在java中，创建一个对象包括对象的声明和实例化两步，下面用一个例题来说明对象的内存模型。假设有类Rectangle定义如下：

public class Rectangle {
double width;
double height;
public Rectangle( double w, double h){
w = width;
h = height;
}
}

(1)声明对象时的内存模型用Rectangle rect；声明一个对象rect时，将在栈内存为对象的引用变量rect分配内存空间，但Rectangle的值为空，称rect是一个空对象。空对象不能使用，因为它还没有引用任何”实体”。 (2)对象实例化时的内存模型当执行rect=new Rectangle(3,5)；时，会做两件事：在堆内存中为类的成员变量width,height分配内存，并将其初始化为各数据类型的默认值；接着进行显式初始化（类定义时的初始化值）；最后调用构造方法，为成员变量赋值。返回堆内存中对象的引用（相当于首地址）给引用变量rect,以后就可以通过rect来引用堆内存中的对象了。

c)创建多个不同的对象实例

一个类通过使用new运算符可以创建多个不同的对象实例，这些对象实例将在堆中被分配不同的内存空间，改变其中一个对象的状态不会影响其他对象的状态。例如：

Rectangle r1= new Rectangle(3,5);
Rectangle r2= new Rectangle(4,6);

此时，将在堆内存中分别为两个对象的成员变量 width 、 height 分配内存空间，两个对象在堆内存中占据的空间是互不相同的。如果有：

Rectangle r1=new Rectangle(3,5);
Rectangle r2=r1;

则在堆内存中只创建了一个对象实例，在栈内存中创建了两个对象引用，两个对象引用同时指向一个对象实例。

d)包装类

基本类型都有对应的包装类：如int对应Integer类，double对应Double类等，基本类型的定义都是直接在栈中，如果用包装类来创建对象，就和普通对象一样了。例如：int i=0；i直接存储在栈中。Integer i（i此时是对象）= new Integer(5)；这样，i对象数据存储在堆中，i的引用存储在栈中，通过栈中的引用来操作对象。

e)String

String str1="abc"；
String str2="abc"；
System.out.println(s1==s2)；//true

String str1= new String("abc")；
String str2= "abc"；
System.out.println(str1==str2)；//false

f)数组

当定义一个数组，int x[]；或int[] x；时，在栈内存中创建一个数组引用，通过该引用（即数组名）来引用数组。x=new int[3]；将在堆内存中分配3个保存 int型数据的空间，堆内存的首地址放到栈内存中，每个数组元素被初始化为0。

g)静态变量

用static的修饰的变量和方法，实际上是指定了这些变量和方法在内存中的”固定位置”－static storage，可以理解为所有实例对象共有的内存空间。static变量有点类似于C中的全局变量的概念；静态表示的是内存的共享，就是它的每一个实例都指向同一个内存地址。把static拿来，就是告诉JVM它是静态的，它的引用（含间接引用）都是指向同一个位置，在那个地方，你把它改了，它就不会变成原样，你把它清理了，它就不会回来了。

那静态变量与方法是在什么时候初始化的呢？对于两种不同的类属性，static属性与instance属性，初始化的时机是不同的。instance属性在创建实例的时候初始化，static属性在类加载，也就是第一次用到这个类的时候初始化，对于后来的实例的创建，不再次进行初始化。

我们常可看到类似以下的例子来说明这个问题：