equals与==号异同 String的字符串池

工作能像if语句可以选择干，也可以不选择干多棒！

if与if表并列，if与else表否则；if的if表包含(注：if包含嵌套有递增或递减顺序);

if与else if表选择。

三种常见执行方式。

1、流程结构：顺序执行，条件分支，循环。

2、运算结构：八种基本数据的7中运算符对栈地址操作，与引类型的对象引用转换运算。

3、逻辑结构：...................................................................................................................

进入主题：1、equals与==的区别？如果是String，那么String创建了几个对象？

首先遇到此类问题一般由两部分解释，慨念部分与示例代码部分；再就是堆、栈、字符串池三者内存图来判断。

1概念：同：1) 都可以比较变量是否相等
2) 在equals方法没有重写时, 在比较引用类型时的方式与==一致, 都是比较对象的地址是否相同
注: ==比较的是变量的栈值。

异：1）==是运算符, 基本数据类型和引用数据类型都可以使用，equals是方法, 只有引用数据类型才能使用。

2）equals方法可以通过重写, 改变比较方式, 根据程序需要, 比较对象的内容是否相同

原理分析：

双"=="号java的九种数据都能比较，比较的是栈里面的地址值。因为栈里面的地址与地址值在声明定义时就已经确定时唯一且地址号与地址号里面的值时固定不变的。所以当使用==去判断两个对象或者两个基本数据时只要地址相等，那么它两就一定相等。

在equals没有重写时：因为所有类默认继承Object.使用时都是常规JDK提供的equals.

例如： int s1=5； int s2=5; s1==s2 等于true;

但是：如果 User user1=new User("小名"，"15岁")； User user2=new User("小明","15");

user1==user2 等于false; user1.equals (user2) 等于false;

解释1：在内存中JVM在占用操作系统内存时也是从优从简而行的，但是由于是new的肯定是两个房间。一旦进入栈里面那么就是两个地址在初始化存在两个唯一性的，否则你要改变我那么你就再来个地址装改变后的值，之前的值就永远对应之前地址号。

所以用双==号就为 false;

解释2：而equals是一个方法，方法其实就是类的一个成员，还是默认来源于java.Object类。

并且equals也只能比较应用类型。再度并且它的比较方式是与==一模一样的 "形式"。形式一样判断就是如果user1与user2的地址也是一样那么user1与user2就相等，而实际引用数据都存放在堆中，存放的形式是以 new 这个关键字建立的。每创建一个数据存储的对象都是在堆中划分一个新的空间。既然是新的空间，那么他们怎么可能同地址（房间号）。

所以用user1.equlas(user2)就为false;

在有重写的时候（前提要知道String是一种非常常用,才成为一种特殊的类。所以被JDK资源默认重写，并且还划分了内存池）。

//分下下面用eclipse测试结果

package com.bean;

       public class Userq {

           public int id;
           public String name;
           public Userq(int id, String name) {
               this.id = id;
               this.name = name;
           }
           public Userq(int id) {
               this.id = id;
}
       }

package com.bean;

public class StringBuferApend {

       public static void main(String[] args) {
           Userq us1=new Userq(5,"小明");
           Userq us2=new Userq(5,"小明");
           Userq us3=new Userq(5);
           Userq us4=new Userq(5);

// 引用类型间的比较，，new出来的不管你拿什么比结果都是false，除非重写比较规则。
System.out.println((us1==us2)+"\t"+us1.equals(us2)); false false
System.out.println((us3==us4)+"\t"+us3.equals(us4)); false false

   //基本类型与默认重写的String比较
           int s1=5,s2=5;
           System.out.println(s1==s2); true
           String a="55555";
           String b="55555";
           String a1=new String("55555");
           String b1=new String("55555");

    //因为特殊内存是jvm给的为了精简内存认为只要值一样就是同地址，因为默认重写比较了
           System.out.println(a==b);
           System.out.println(a.equals(b)); //true(因为被默认重写)

System.out.println(a1==b1); //false new 地址不一样了
System.out.println(a.equals(b)); //true(因为被默认重写)

}

下面我们在看内存图：

左边为栈，右边为堆，下边String池，且String内只要内容文本一致就默认在栈中地址一样这就是重写效果与堆不一样

String S2=hell, String S3=hell; 那么S2==S3 S2.equals(S1) 都为true.

eclipse，中的重写equals 原理的核心代码如下：

//常规的重写

public boolean equals(Object obj){

//仔细看也是用==比较

if(this==obj) return true;

if(obj instanceof User) return true;

User user=(User)obj;

if(this.id==user.id) return true；

return false；

}

//字符串

public boolean equals(Object anObject) {
if (this == anObject)
return true;

if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;

//首先至少长度相等
if (n == anotherString.value.length) {

//将字符串拆成单个字符的数组，
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;
}

写的可能很混乱但是很详细！谅解