==，equals比较与内存分配

java 内存分配

1.java程序执行涉及内存区域

• 寄存器：JVM内部虚拟寄存器，存取速度非常快，程序不可控制。
• 栈：保存局部变量的值，包括：
  1.用来保存基本数据类型的值；
  2.保存类的实例，即堆区对象的引用(指针)。也可以用来保存加载方法时的帧。
• 堆：用来存放动态产生的数据，比如new出来的对象注意创建出来的对象只包含属于各自的成员变量，并不包括成员方法因为同一个类的对象拥有各自的成员变量，存储在各自的堆中，但是他们共享该类的方法，并不是每创建一个对象就把成员方法复制一次。
• 常量池：JVM为每个已加载的类型维护一个常量池，常量池就是这个类型用到的常量的一个有序集合.包括直接常量(基本类型，String)和对其他类型、方法、字段的符号引用。池中的数据和数组一样通过索引访问。由于常量池包含了一个类型所有的对其他类型、方法、字段的符号引用，所以常量池在Java的动态链接中起了核心作用。常量池存在于堆中。
• 代码段：用来存放从硬盘上读取的源程序代码。
• 数据段：用来存放static定义的静态成员。
• 内存表示图:
  
• 注意：
  无论是普通类型的变量还是引用类型的变量(俗称实例)，都可以作为局部变量，他们都可以出现在栈中。只不过普通类型的变量在栈中直接保存它所对应的值，而引用类型的变量保存的是一个指向堆区的指针，通过这个指针，就可以找到这个实例在堆区对应的对象。因此，普通类型变量只在栈区占用一块内存，而引用类型变量要在栈区和堆区各占一块内存。

2.java栈，堆要点

1.分清什么是实例什么是对象。Class a= new Class();此时a叫实例，而不能说a是对象。实例在栈中，对象在堆中，操作实例实际上是通过实例的指针间接操作对象。多个实例可以指向同一个对象。

2.栈中的数据和堆中的数据销毁并不是同步的。方法一旦结束，栈中的局部变量立即销毁，但是堆中对象不一定销毁。因为可能有其他变量也指向了这个对象，直到栈中没有变量指向堆中的对象时，它才销毁，而且还不是马上销毁，要等垃圾回收扫描时才可以被销毁。

3.以上的栈、堆、代码段、数据段等等都是相对于应用程序而言的。每一个应用程序都对应唯一的一个JVM实例，每一个JVM实例都有自己的内存区域，互不影响。并且这些内存区域是所有线程共享的。这里提到的栈和堆都是整体上的概念，这些堆栈还可以细分。

4.类的成员变量在不同对象中各不相同，都有自己的存储空间(成员变量在堆中的对象中)。而类的方法却是该类的所有对象共享的，只有一套，对象使用方法的时候方法才被压入栈，方法不使用则不占用内存。

==与equals的区别

==

• "= ="是基本数据类型的话比较的是存储在栈中的值是否相等；如果是引用类型则判断对象堆内存地址是否相等。

• 在此之前还要说明一点：jvm当中有一个存储区域叫做字符串常量池(在堆当中)，通过：String 对象名 =new String(“abc”); 我们知道在堆中会创建一个字符串对象， 返回的是堆数据地址(存储在栈中)。除此之外，在常量池中还会查看当前是否有存在这个字符串"abc"，如果没有，就在常量池中划分一片区域用于存储这个字符串。

• 例一：
  对象 str1和str2存储在堆当中,栈中存储的是对象在堆中的存储地址(用变量str1，str2指示)，同时在常量池中创建了一个存储字符串"abc"的空间。明显，对象str1和str2的在堆中的数据存储地址是不同的，那么栈中的值肯定是不同的，所以str1==str2（false）
  注意：
  1.Object的hashCode()默认是返回内存地址的，但是hashCode()可以重写，所以hashCode()不能代表内存地址的不同
  2.System.identityHashCode(Object)方法可以返回对象的内存地址,不管该对象的类是否重写了hashCode()方法。

String str1=new String("abc");
String str2=new String("abc");
System.out.println("str1="+System.identityHashCode(str1)+"   str2="+System.identityHashCode(str2));

结果：

• 例二：

//对于那些在编译时就能确定的字面量都会存放在运行时常量池中
String str1="hello"+"world";//JVM会将此代码优化为String c = "hello world";
String str2="helloworld";
System.out.println("str1="+System.identityHashCode(str1)+"   str2="+System.identityHashCode(str2));
System.out.println(str1==str2);  //true且地址一样

String a="hello ";
String b = a + "world";
System.out.println(b==a);//false
//a是变量，在编译时不能确定值，所以不会被放在运行时常量池中，而是在heap中重新new了一块儿内存。

注意:
在java内部是对+进行了重载，在处理String的过程中要创建一个StringBuffer对象，用StringBuffer对象的append方法对字符串进行连接，最后调用toString方法返回String字符串。所以这里的b指向的是堆中StringBuffer的地址。

• 例三

/通过String类直接创建一个字符串
String str1 = "abc";
String str2 = "abc";//在常量池中找到了"abc"，直接将地址给到str2栈中对应
String str3 = "10";
System.out.println(str1==str2);//true
System.out.println(str1==str3);//false

• 例四

String str = "abc";
String str1 = new String("abc");
String str2 = str1.intern();//取出str1常量池中的数据。
System.out.println(str2==str);//str与str2对应栈中的地址是相同的（为常量池中为abc的位置） // true
System.out.println(str==str1);//false 
//str对应栈中存储的是常量池中字符串"abc"的地址，str1对应栈中存储的是对象str1在堆中的存储地址。

对象str1和str2对应的栈中存储的都是常量池中字符串"abc"的地址。
str3对应栈中存储的是常量池中"10"的地址。

• == 对于引用类型是直接比较的两个对象的堆内存地址，如果相等，则说明这两个引用实际是指向同一个对象地址的。但是我们又常常碰到这样一个问题
  
  结果是 true，true，false
  解析：

1. 对于基本数据类型（byte，short，char，int，float，double，long，boolean）来说，他们是作为常量在方法区中的常量池里面以HashSet策略存储起来的，对于这样的字符串 “123” 也是相同的道理，在常量池中，一个常量只会对应一个地址，因此不管是再多的 123,“123” 这样的数据都只会存储一个地址，所以所有他们的引用都是指向的同一块地址，因此基本数据类型和String常量是可以直接通过== 来直接比较的。
2. 另外，对于基本数据的包装类型（Byte, Short, Character，Integer，Float, Double，Long, Boolean）除了Float和Double之外，其他的六种都是实现了常量池的，因此对于这些数据类型而言，一般我们也可以直接通过来判断是否相等。

结果是 true，false
解析：
因为 Integer 在常量池中的存储范围为[-128,127]，127在这范围内，因此是直接存储于常量池的，而128不在这范围内，所以会在堆内存中创建一个新的对象来保存这个值，所以m，n分别指向了两个不同的对象地址，故而导致了不相等。

equals

我们来看看在Object类中定义的equals方法 ↓

可以看到，在Object类型的equals方法是直接通过 = =来比较的，和==是没有任何区别的。

• 那么为什么又要说equlas和==的区别呢？是因为equals方法是可以由我们自己重写的。
  
  可以看出，eclipse还是很智能的，它首先是判断两个对象的地址是否相等，若不相等再进行下面的成员变量判断。

• 但是String、Date、File、包装类等都已经重写了Object类中的equals()方法。重写以后，就可以比较两个对象的"实体内容"是否相同。
  下面查看一下String类中被重写的equals方法

public boolean equals(Object anObject) {
        if (this == anObject) {    //首先还是做一个==判断，如果栈中的数据都相等的话                                                                                                                                                                                                                                                                                                                                                                                                                                                                         
            return true;                             
                 }
        if (anObject instanceof String) {               //现在重写之后，可以判断他们的字符串内容是否相等
            String anotherString = (String)anObject;     //A  instanceof B 判段B是否是A的相同类型或是他的子类
            int n = value.length;                            //   然后这里发生强制类型转换，进而判断字符串的内容   
            if (n == anotherString.value.length) {   //日常比较String类的对象，就记住equals()方法只比较内容，== 方法比较地址
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

可见String类对象调用equals方法，是判断两个字符串内容是否完全相等，完全相等就返回true。同理其他包装类equals方法也都已经被重写过了。
例：

	String str1="hello"+"world";
	String str2= new String("helloworld");
	System.out.println("str1="+System.identityHashCode(str1)+"   str2="+System.identityHashCode(str2));
	System.out.println(str1.equals(str2));

输出：str1=366712642 str2=1829164700 true

原文链接：
https://blog.csdn.net/lcsy000/article/details/82782864/
https://blog.csdn.net/weixin_46369022/article/details/118095530?spm=1001.2014.3001.5501