Java程序中判断两个变量是否相等有两种方式：
一、利用 == 运算符：
1.1、如果两个变量是基本类型变量，且都是数值型（不一定要求数值类型完全相同），则只要两个变量的值相同，就返回true
1.2、对于两个引用类型变量，只有它们指向同一个对象时，== 判断才会返回true
1.3、== 运算符不可用于比较类型上没有父子关系的对象
代码示例：
import static java.lang.System.*;
public class EqualTest{
public static void main(String[] args){
int it=65;
float f1=65.0f;
out.println("65和65.0f是否相等？"+(it==f1));
char ch='A';
out.println("65和A是否相等？"+(it==ch));
String str1=new String("hello");
String str2=new String("hello");
out.println("str1和str2是否相等？"+(str1==str2));
out.println("str1是否equals str2？"+(str1.equals(str2)));
//-由于java.lang.String与EqualTest类没有继承关系，下面代码会编译错误
//out.println("hello"==new EqualTest());
}
}
运行结果：
知识点拓展：
1、String str=“hello”；
2、String str=new String("hello");
如上两行代码中的两个变量str的区别：
1行代码中的“hello”被称为 字符串直接量（在编译时就计算出来的字符串值），JVM通过 常量池 来管理这些字符串
2行中的 new String("hello")，当使用这种定义方式时，JVM会先使用常量池来管理“hello”直接量，再调用String类的构造器来创建一个新的String对象，新创建的String对象被保存在堆内存中，
换句话说，new String("hello") 一共产生了两个字符串对象
常量池（constant pool）：专门用于管理在编译时被确定并被保存在已编译的.class文件中的一些数据，包括了关于类、方法、接口中的常量，还包括字符串常量，如下代码示例：
import static java.lang.System.*;
public class CompareTest{
public static void main(String[] args){
//-a直接引用常量池中的"张三李四"
String a="张三李四";
String b="张三";
String c="李四";
//-d后面的字符串值在编译时就确定下来了
//-d直接引用常量池中的"张三李四"
String d="张三"+"李四";
//-e后面的字符串值在编译时就确定下来了
//-e直接引用常量池中的"张三李四"
String e="张"+"三"+"李四";
//-f后面的字符串值不能在编译时就确定下来了
//-f不能直接引用常量池中的字符串
String f=b+c;
//-使用new调用构造器会重新创建一个新的String对象
//-g引用堆内存中新创建的String对象
String g=new String("张三李四");
out.println(a==d);//-true
out.println(a==e);//-true
out.println(a==f);//-false
out.println(a==g);//-false
}
}
总结：
1、JVM常量池保证相同的字符串直接量只有一个，不会产生多个副本
2、例如上面代码中a、d、e所引用的字符串可以在编译期就确定下来，因此他们都将引用常量池中同一个字符串对象，所以用 == 运算符计算是返回 true 的
3、使用 new String()创建的字符串对象是运行时创建出来的，它被保存在运行时内存区内（即堆内存内），不会放入常量池中
二、利用 equals()方法：
1、equals()方法是Object类提供的一个实例方法，所有引用变量都可以引用这个方法判断与其它引用变量是否相等
2、判断是否相等的标准与 == 没有区别，都是看引用变量是否指向相同的对象，从这个作用上来说equals()方法没有太大意义
3、equals()方法最大的意义是可通过重写该方法，实现自定义的相等判断，如：String类就重写了equals()方法：只要两个字符串所包含的字符序列相等，即判断相等，返回true
重写equals()方法，实现两个类相等：
class Person{
//-重写Object类的equals()方法
public boolean equals(Object o){
//-相等规则自己定义
return true;
}
}
class Dog{
//-空类
}
public class OverrideEquals{
public static void main(String[] args){
Person p=new Person();
System.out.println(p.equals(new Dog()));
System.out.println(p.equals(new String("张三")));
}
}
运行结果：
有意义的去判断两个类相等。代码示例：
class Penson{
private String name;
private String id;
public Penson(){
}
public Penson(String name,String id){
this.name=name;
this.id=id;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return this.name;
}
public void setId(String id){
this.id=id;
}
public String getId(){
return this.id;
}
public boolean equals(Object obj){
if(this==obj){
return true;
}
//-obj.getClass()==Penson.class用到了反射基础，暂时不用深究
if(obj!=null&&obj.getClass()==Penson.class){
//-强制转换，把将要比较的参数转换成Penson类，便于后面获取类变量id
Penson penson=(Penson)obj;
//-只有两个对象的id相等，才判定相等
if(this.getId().equals(penson.getId())){
return true;
}
}
return false;
}
}
public class OverrideEqualsRight{
public static void main(String[] args){
Penson p1=new Penson("张三","9527");
Penson p2=new Penson("李四","9527");
Penson p3=new Penson("王五","9526");
//-p1与p2的id相等，返回true
System.out.println(p1.equals(p2));
//-p1与p2的id不等，返回false
System.out.println(p1.equals(p3));
}
}
运行结果：
通常而言，重写equals()方法应满足下面的条件：
1、自反性：对任意x，x.equals(x)一定返回true
2、对称性：对任意x、y，如果x.equals(y)返回true，那么y.equals(x)一定返回true
3、传递性：对任意x、y、z，如果x.equals(y)返回true，y.equals(z)返回true，那么x.equals(z)一定返回true
4、一致性：对任意x、y，如果对象中用于等价比较的信息值没有发生改变，那么无论调用x.equals(y)多少次，返回的结果应该始终保持一致，要么一直true，要么一直false
5、对任何不是null的x，x.equals(null)一定返回false