string的equals方法源码（在java中String中的equals方法的源代码有很多不懂啊求大神解惑！！）

本文目录

• 在java中String中的equals方法的源代码有很多不懂啊求大神解惑！！
• C# string类型的Equals方法
• 为什么重写equals
• .equals（）到底是什么意思
• 两个输出结果为什么不一样

在java中String中的equals方法的源代码有很多不懂啊求大神解惑！！

anObject instanceof String；
首先上边的语句，先判断anObject是不是String类的一个实例，如果是运行下边的语句
String anotherString = (String)anObject;
字符串是一个引用数据类型，本身是String个对象，
在这里把传进来的anObject这个对象，赋给anotherString （需要类型转换）
他当然可以调用String类里的成员，你说的count、value、offset都是String的成员
int n = count;//这个count是原始字符串的长度
if (n == anotherString.count) { //把字符串长度和要比较的字符串长度对比，长度都不同的话就不用比字符串内容了
char v1 = value;//把原始字符串义字符形式存入数组
char v2 = anotherString.value; //把要比较字符串义字符形式存入数组
int i = offset;//数组下标
int j = anotherString.offset; //????
while (n-- != 0) { //遍历数组，比较 数组元素是否相同
if (v1)
return false;//在遍历的过程中如果有不同的就返回false；
} //你如果用过equals这个方法应该知道它返回的是boolean值
return true;
}
}
return false;
}

C# string类型的Equals方法

比较的是值。下面是用Reflector反编译出来的String类的部分源码，供参考:
[ReliabilityContract(Consistency.WillNotCorruptState,
Cer.MayFail)]
public
bool
Equals(string
value)
{
if
((value
==
null)
&&
(this
!=
null))
{
return
false;
}
return
EqualsHelper(this,
value);
}
主要的是EqualsHelper这个方法的实现，具体如下:
[ReliabilityContract(Consistency.WillNotCorruptState,
Cer.MayFail)]
private
static
unsafe
bool
EqualsHelper(string
strA,
string
strB)
{
int
length
=
strA.Length;
if
(length
!=
strB.Length)
{
return
false;
}
fixed
(char*
str
=
((char*)
strA))
{
char*
chPtr
=
str;
fixed
(char*
str2
=
((char*)
strB))
{
char*
chPtr2
=
str2;
char*
chPtr3
=
chPtr;
char*
chPtr4
=
chPtr2;
while
(length
》=
10)
{
if
((((*(((int*)
chPtr3))
!=
*(((int*)
chPtr4)))
||
(*(((int*)
(chPtr3
+
2)))
!=
*(((int*)
(chPtr4
+
2)))))
||
((*(((int*)
(chPtr3
+
4)))
!=
*(((int*)
(chPtr4
+
4))))
||
(*(((int*)
(chPtr3
+
6)))
!=
*(((int*)
(chPtr4
+
6))))))
||
(*(((int*)
(chPtr3
+
8)))
!=
*(((int*)
(chPtr4
+
8)))))
{
break;
}
chPtr3
+=
10;
chPtr4
+=
10;
length
-=
10;
}
while
(length
》
0)
{
if
(*(((int*)
chPtr3))
!=
*(((int*)
chPtr4)))
{
break;
}
chPtr3
+=
2;
chPtr4
+=
2;
length
-=
2;
}
return
(length
《=
0);
}
}
}
可见比较的绝对是值，而不是引用。
比较引用的话
strA
==
strB就行了(其实呢，==运算符重载也是调用了下面的静态Equals方法)，下面的源码就比较典型，比较引用(引用相同，值必相同)也比较值。
public
static
bool
Equals(string
a,
string
b)
{
return
((a
==
b)
||
(((a
!=
null)
&&
(b
!=
null))
&&
EqualsHelper(a,
b)));
}
public
static
bool
operator
==(string
a,
string
b)
{
return
Equals(a,
b);
}
不知这个回答可以否?
更正一点，Contains方法中没有用到Equals方法，源码如下:
public
bool
Contains(string
value)
{
return
(this.IndexOf(value,
StringComparison.Ordinal)
》=
0);
}
不过确实也是逐字符比较的，比较的是值。

为什么重写equals

先说一说 == 比较

对于基本数据类型 == 比较的是数值
对于引用数据类型 == 比较的是地址

我们在初学Java时，String类我们会使用equals来比较两个字符串的值是否相等
有些同学就会误认为equals比较的是引用类型的值。

但实际上，所有对象继承自Object类。默认情况下，equals比较的仍然是地址。

我们来看一看Object中equals方法的源码

this代表代用该方法的对象，obj表示要比较的对象。
我们发现，equals方法又回到了两者用等于号比较。
即引用数据类型 == 比较的是地址。
那为什么String类调用equals比较的是值呢？
因为String类重写了equals方法

String类equals的源码：

首先还是用==号比较，如果地址相同。两者当然也相同。
然后下一步，将里面的值进行了比较。

对于大部分Java原生对象，大多都重写了equals方法。
如果不确定，可以ctrl+鼠标左键点击进行查看。

所以我们在自定义对象时，如果不重写equals方法。
那么比较的将是两个对象的地址，即使值相同。但两者地址不同，仍然会判断为不相等。

.equals（）到底是什么意思

.equals() 在Java中判断是否相等，与 == 的区别是 .equals() 只判断值是否相等，不管两者是否存在同一地址。而 == 则是判断值与存在地址都得相等

扩展资料：

由equals的源码可以看出这里定义的equals与==是等效的（Object类中的equals没什么区别），不同的原因就在于有些类（像String、Integer等类）对equals进行了重写，但是没有对equals进行重写的类（比如我们自己写的类）就只能从Object类中继承equals方法，其equals方法与==就也是等效的，除非我们在此类中重写equals。

另外，"=="比"equals"运行速度快,因为"=="只是比较引用。

两个输出结果为什么不一样

两次结果不一样的原因：

       表面上看都是使用equals方法在比较两个数组是否相等。

       其实是两个不同的比较方法，只是名字都相同而已。

       打个比方：人和鸟都有移动的方法，方法名一样都是移动。

       但是人移动主要是靠自己走路，鸟移动主要是靠自己飞行。

        所以方法名相同，未必都会使用同样的方式去完成。方式不一样，那么结果就很可能不一样

       Arrays.equals() 是数组工具类的比较数组是否相等，其实质是在比较数组里面的每一个元素是否相等。

String { "a", "b", "c" };
String { "a", "b", "c" };
String k = i;
// 此方法是调用的数组工具类Arrays的equals()方法，其实质依次比较里面的元素是否equals，返回true
System.out.println(Arrays.equals(i, j));
// 此方法实际在比较是不是同一个对象,返回false;
System.out.println(i.equals(j));
//此处返回true
System.out.println(i.equals(k));

       Arrays.equals() 的  源码：

    public static boolean equals(Object a2) {
        if (a==a2)
            return true;
        if (a==null || a2==null)
            return false;
        int length = a.length;
        if (a2.length != length)
            return false;
    //看到了吗？其实质是在依次比较两个数组的每一个元素是否相等。
        for (int i=0; i《length; i++) {
            Object o1 = a;
            Object o2 = a2;
            if (!(o1==null ? o2==null : o1.equals(o2)))
                return false;
        }
        return true;
    }

       i.equals(j)是调用的Object类的equals方法。判断是否是同一个对象

    public boolean equals(Object obj) {
        return (this == obj);
    }

给我们的启发：

      比如我们一个学生类，学生类有三个属性，姓名，年龄，id号。

     如果三个属性一样。我们就认为是同一个学生。

    但是我们通过new 关键字创建了两个属性一样的学生实例。调用系统的equals方法。却告诉我们两个学生，不是同一个，返回false；

    所以。我们自己写java实例的时候，建议重写继承自父类的equalse方法。

class Student {
String name;
int age;
String id;
public Student(String name, int age, String id) {
this.name = name;
this.age = age;
this.id = id;
}
        //重写继承自Object类的equals方法
@Override
public boolean equals(Object obj) {
if (this == null || obj == null) {
return false;
}
if (this == obj) {
return true;
}
if (obj instanceof Student) {
Student s = (Student) obj;
return this.name.equals(s.name) && this.age == s.age
&& this.id.equals(s.id);
}
return false;
}
}
public class StudentDemo {
public static void main(String args) {
Student s1 = new Student("张三", 20, "001");
Student s2 = new Student("张三", 20, "001");
//因为重写了equalse方法，所以返回true;
System.out.println(s1.equals(s2));
}
}