面试时和平时的工作中经常会使用==和equals，那么它们二者之间有什么区别呢？总结一下
先上代码
package com.test;
public class TestEquals {
public static void main(String[] args) {
//对于基本数据类型的变量,"=="和"equals"的区别
int t1 = 1;
int t2 = 2;
int t3 = 3;
int t4 = 3;
//"=="对于基本数据类型，判断两个变量的值是否相等。
boolean result1=(t1==t2);
boolean result2=((t1+t2)==t3);
boolean result3=(t3==t4);
System.out.println("-----【t1==t2】"+result1+"-----【(t1+t2)=t3】"+result2+"-----【t3=t4】"+result3);
//"equals"不能用于基本数据类型。只能用于类变量。对于基本数据类型要用其包装类。
Integer i1=new Integer(t1);
Integer i2=new Integer(t2);
Integer i3=new Integer(t3);
Integer i4=new Integer(t4);
boolean ri1=i1.equals(i2);
boolean ri2=i3.equals(i1+i2);
boolean ri3=i3.equals(i4);
System.out.println("-----【i1.equals(i2)】"+ri1+"-----【i3.equals(i1+i2)】"+ri2+"-----【i3.equals(i4)】"+ri3);
//对于对象变量，"=="和"equals"的区别
//因为对象变量的存储的是对象在内存中的路径，即内存地址。
//所以用"=="比较时，即使对象的值相等，但是他们的内存地址不同，所以==的结果为false。
//故"=="用于比较两个变量的值是否相等，而不是变量引用的对象是否相等
String st1="ab";
String st2="c";
String st3="abc";
String st4="abc";
boolean b1=(st1==st2);
boolean b2=(st1+st2)==st3;
boolean b3=(st3==st4);
System.out.println("-----【st1==st2】"+b1+"-----【(st1+st2)==st3】"+b2+"-----【st3==st4】"+b3);
//equals用于比较两个对象是否相同。
boolean r1=st1.equals(st2);
boolean r2=(st1+st2).equals(st3);
boolean r3=st3.equals(st4);
System.out.println("-----【st1.equals(st2)】"+r1+"----【(st1+st2).equals(st3)】"+r2+"-----【st3.equals(st4)】"+r3);
}
}
运行结果：
-----【t1==t2】false-----【(t1+t2)=t3】true-----【t3=t4】true
-----【i1.equals(i2)】false-----【i3.equals(i1+i2)】true-----【i3.equals(i4)】true
-----【st1==st2】false-----【(st1+st2)==st3】false-----【st3==st4】true
-----【st1.equals(st2)】false-----【(st1+st2).equals(st3)】true-----【st3.equals(st4)】true
总之：
对于基本数据类型“==”比较的是值是否相等；对于对象变量"=="比较的是地址【变量(栈)内存中存放的对象的(堆)内存地址】
equal用于比较两个对象的值是否相同【不是比地址】
【特别注意】Object类中的equals方法和“==”是一样的，没有区别，而String类，Integer类等等一些类，是重写了equals方法，才使得equals和“==不同”，所以，当自己创建类时，自动继承了Object的equals方法，要想实现不同的等于比较，必须重写equals方法。
"=="比"equal"运行速度快,因为"=="只是比较引用.
其次，在new的时候以及字符串拼接时要注意==和equals的结果
两条new语句创建了两个对象，然后用c/g这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即c和g中存储的数值是不相同的，所以，表达式c==g将返回false，而这两个对象中的内容是相同的，所以，表达式c.equals(g)将返回true。
package com.test;
public class StringEquals {
public static void main(String[] args) {
String a = "abc";
String b = "abc";
String c = new String("abc");
String g = new String("abc");
String d = "ab" + "c";
String h = "ab";
String i = "c";
System.out.println(c==g);//***false
System.out.println(c.equals(g));//true
System.out.println(h+i==d);//***false
System.out.println(a==b);//true
System.out.println(c==b);***false
System.out.println(c==d);//***false
System.out.println(a==d);***true
System.out.println(a.hashCode());//a,b,c,d的hashCode相等
System.out.println(b.hashCode());//***这里说明一下hashCode并不是内存地址
System.out.println(c.hashCode());
System.out.println(d.hashCode());
System.out.println(a.equals(b));//true
System.out.println(c.equals(b));//true
System.out.println(c.equals(d));//true
System.out.println(a.equals(d));//true
}
}
接下来，就详细的讲一下java中堆栈
Java把内存划分成两种：一种是栈内存，一种是堆内存。
在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。
当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。
堆内存用来存放由new创建的对象和数组。
在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。
在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。
引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。
具体的说：
栈与堆都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。
Java的堆是一个运行时数据区,类的对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。
栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量（int, short, long, byte, float, double, boolean, char）和对象句柄。
栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：
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=4；那么编译器会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b, 它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。
String是一个特殊的包装类数据。可以用：
String str = new String("abc");
String str = "abc";
两种的形式来创建，第一种是用new()来新建对象的，它会在存放于堆中。每调用一次就会创建一个新的对象。
而第二种是先在栈中创建一个对String类的对象引用变量str，然后查找栈中有没有存放"abc"，如果没有，则将"abc"存放进栈，并令str指向”abc”，如果已经有”abc” 则直接令str指向“abc”。
比较类里面的数值是否相等时，用equals()方法；当测试两个包装类的引用是否指向同一个对象时，用==，下面用例子说明上面的理论。
String str1 = "abc";
String str2 = "abc";
System.out.println(str1==str2); //true
可以看出str1和str2是指向同一个对象的。
String str1 =new String ("abc");
String str2 =new String ("abc");
System.out.println(str1==str2); // false
用new的方式是生成不同的对象。每一次生成一个。
因此用第二种方式创建多个”abc”字符串,在内存中其实只存在一个对象而已. 这种写法有利与节省内存空间. 同时它可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。
另一方面, 要注意: 我们在使用诸如String str = "abc"；的格式定义类时，总是想当然地认为，创建了String类的对象str。担心陷阱！对象可能并没有被创建！而可能只是指向一个先前已经创建的对象。只有通过new()方法才能保证每次都创建一个新的对象。由于String类的immutable性质，当String变量需要经常变换其值时，应该考虑使用StringBuffer类，以提高程序效率。
java中内存分配策略及堆和栈的比较
1、内存分配策略
按照编译原理的观点,程序运行时的内存分配有三种策略,分别是静态的,栈式的,和堆式的.
静态存储分配是指在编译时就能确定每个数据目标在运行时刻的存储空间需求,因而在编译时就可以给他们分配固定的内存空间.这种分配策略要求程序代码中不允许有可变数据结构(比如可变数组)的存在,也不允许有嵌套或者递归的结构出现,因为它们都会导致编译程序无法计算准确的存储空间需求.
栈式存储分配也可称为动态存储分配,是由一个类似于堆栈的运行栈来实现的.和静态存储分配相反,在栈式存储方案中,程序对数据区的需求在编译时是完全未知的,只有到运行的时候才能够知道,但是规定在运行中进入一个程序模块时,必须知道该程序模块所需的数据区大小才能够为其分配内存.和我们在数据结构所熟知的栈一样, 栈式存储分配按照先进后出的原则进行分配。
静态存储分配要求在编译时能知道所有变量的存储要求,栈式存储分配要求在过程的入口处必须知道所有的存储要求,而堆式存储分配则专门负责在编译时或运行时模块入口处都无法确定存储要求的数据结构的内存分配,比如可变长度串和对象实例.堆由大片的可利用块或空闲块组成,堆中的内存可以按照任意顺序分配和释放.
2、堆和栈的比较
上面的定义从编译原理的教材中总结而来,除静态存储分配之外,都显得很呆板和难以理解,下面撇开静态存储分配,集中比较堆和栈:
从堆和栈的功能和作用来通俗的比较,堆主要用来存放对象的，栈主要是用来执行程序的.而这种不同又主要是由于堆和栈的特点决定的:
在编程中，例如C/C++中，所有的方法调用都是通过栈来进行的,所有的局部变量,形式参数都是从栈中分配内存空间的。实际上也不是什么分配,只是从栈顶向上用就行,就好像工厂中的传送带(conveyor belt)一样,Stack Pointer会自动指引你到放东西的位置,你所要做的只是把东西放下来就行.退出函数的时候，修改栈指针就可以把栈中的内容销毁.这样的模式速度最快, 当然要用来运行程序了.需要注意的是,在分配的时候,比如为一个即将要调用的程序模块分配数据区时,应事先知道这个数据区的大小,也就说是虽然分配是在程序运行时进行的,但是分配的大小多少是确定的,不变的,而这个"大小多少"是在编译时确定的,不是在运行时.
堆是应用程序在运行的时候请求操作系统分配给自己内存，由于从操作系统管理的内存分配,所以在分配和销毁时都要占用时间，因此用堆的效率非常低.但是堆的优点在于,编译器不必知道要从堆里分配多少存储空间，也不必知道存储的数据要在堆里停留多长的时间,因此,用堆保存数据时会得到更大的灵活性。事实上,面向对象的多态性,堆内存分配是必不可少的,因为多态变量所需的存储空间只有在运行时创建了对象之后才能确定.在C++中，要求创建一个对象时，只需用 new命令编制相关的代码即可。执行这些代码时，会在堆里自动进行数据的保存.当然，为达到这种灵活性，必然会付出一定的代价:在堆里分配存储空间时会花掉更长的时间！这也正是导致我们刚才所说的效率低的原因,看来列宁同志说的好,人的优点往往也是人的缺点,人的缺点往往也是人的优点(晕~).
3、JVM中的堆和栈
JVM是基于堆栈的虚拟机.JVM为每个新创建的线程都分配一个堆栈.也就是说,对于一个Java程序来说，它的运行就是通过对堆栈的操作来完成的。堆栈以帧为单位保存线程的状态。JVM对堆栈只进行两种操作:以帧为单位的压栈和出栈操作。
我们知道,某个线程正在执行的方法称为此线程的当前方法.我们可能不知道,当前方法使用的帧称为当前帧。当线程激活一个Java方法,JVM就会在线程的 Java堆栈里新压入一个帧。这个帧自然成为了当前帧.在此方法执行期间,这个帧将用来保存参数,局部变量,中间计算过程和其他数据.这个帧在这里和编译原理中的活动纪录的概念是差不多的.
从Java的这种分配机制来看,堆栈又可以这样理解:堆栈(Stack)是操作系统在建立某个进程时或者线程(在支持多线程的操作系统中是线程)为这个线程建立的存储区域，该区域具有先进后出的特性。
每一个Java应用都唯一对应一个JVM实例，每一个实例唯一对应一个堆。应用程序在运行中所创建的所有类实例或数组都放在这个堆中,并由应用所有的线程共享.跟C/C++不同，Java中分配堆内存是自动初始化的。Java中所有对象的存储空间都是在堆中分配的，但是这个对象的引用却是在堆栈中分配,也就是说在建立一个对象时从两个地方都分配内存，在堆中分配的内存实际建立这个对象，而在堆栈中分配的内存只是一个指向这个堆对象的指针(引用)而已。
JVM运行时，将内存分为堆和栈，堆中存放的是创建的对象，JAVA字符串对象内存实现时，在堆中开辟了一快很小的内存，叫字符串常量池，用来存放特定的字符串对象。
关于String对象的创建，两种方式是不同的，第一种不用new的简单语法，即
String s1="JAVA";
创建步骤是先看常量池中有没有与"JAVA"相同的的字符串对象，如果有，将s1指向该对象，若没有，则创建一个新对象，并让s1指向它。
第二种是new语法
String s2=new String("JAVA");
这种语法是在堆而不是在常量池中创建对象，并将s2指向它，然后去字符串常量池中看看，是否有与之相同的内容的对象，如果有，则将new出来的字符串对象与字符串常量池中的对象联系起来，如果没有，则在字符串常量池中再创建一个包含该内容的字符串对象，并将堆内存中的对象与字符串常量池中新建出来的对象联系起来。
这就是字符串的一次投入，终生回报的内存机制，对字符串的比较带来好处。
1. 栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。
2. 栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据可以共享，详见第3点。堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。
3. Java中的数据类型有两种。
一种是基本类型(primitive types)出于追求速度的原因，就存在于栈中。
出于追求速度的原因，就存在于栈中。
另一种是包装类数据，如Integer, String, Double等将相应的基本数据类型包装起来的类。这些类数据全部存在于堆中，Java用new()语句来显示地告诉编译器，在运行时才根据需要动态创建，因此比较灵活，但缺点是要占用更多的时间。
4. String是一个特殊的包装类数据。即可以用String str = new String("abc");的形式来创建，也可以用String str = "abc"；的形式来创建。前者是规范的类的创建过程，即在Java中，一切都是对象，而对象是类的实例，全部通过new()的形式来创建。
值得注意的是，一般String类中字符串值都是直接存值的。但像String str = "abc"；这种场合下，其字符串值却是保存了一个指向存在栈中数据的引用！
用new()来新建对象的，都会在堆中创建，而且其字符串是单独存值的，即使与栈中的数据相同，也不会与栈中的数据共享。
使用String str = "abc"；的方式，可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。
字符串池在DataSegument里。既不在堆也不再栈中。 用+创建应该是在堆里。
应该说是 特殊的堆
因为相对于其他堆中的对象一旦失去引用就可能会被当做垃圾回收掉
但是字符串对象就算失去唯一的引用也不会被回收
127 以下的整数是相等的
Integer i=100;
Integer j=100;
System.out.println(i==j);
Integer i=200;
Integer j=200;
System.out.println(i==j);
Java中的==和equals浅见
java中的数据类型，可分为两类：
1.基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean
2.复合数据类型(类)
//Object中的equals方法
public boolean equals(Object obj) {
}
当然，你也可以重写Object的equals方法，这儿就有个问题啦，参加公司笔试的时候相信N多人都被要求回答过这样的问题：在重写了对象的equals方法后，还需要重写hashCode方法吗？为什么？
我认为，出于程序完整性的考虑，在重写了对象的equals方法后，是有必要重写对象的hashCode方法的。
因为，你重写了equals方法，你调用它来进行对象间的比较，你可以达到你的比较目的，但是，当你想将你的对象存入类似HashSet这类对象中时，问题就出现了（没有重写hashCode方法的情况下）。
Set(集)中是不允许有重复的值的，而判断值是否重复，是通过比较他们的hashCode值的。你通过你重写后的equals比较对象，结果是相等，但用hashCode值比较他们时是不相等的，所以，为了比较结果的一致性，需要重写hashCode方法。
下面是String类重写了的equals方法和hashCode方法：
//此方法的目的是，实现在不同的String对象之间比较，比较的是他们的字符串值
public boolean equals(Object anObject) {
public int hashCode() {
问：对象的hashcode是用来干什么的？
简答：容器类经常用到hascode,比如说set判断重复值，比如说hashmap散列。等等。
解析Java对象的equals()和hashCode()的使用
文章分类:Java编程
前言
在Java语言中，equals()和hashCode()两个函数的使用是紧密配合的，你要是自己设计其中一个，就要设计另外一个。在多数情况下，这两个函数是不用考虑的，直接使用它们的默认设计就可以了。但是在一些情况下，这两个函数最好是自己设计，才能确保整个程序的正常运行。最常见的是当一个对象被加入收集对象（collection object）时，这两个函数必须自己设计。更细化的定义是：如果你想将一个对象A放入另一个收集对象B里，或者使用这个对象A为查找一个元对象在收集对象B里位置的钥匙，并支持是否容纳，删除收集对象B里的元对象这样的操作，那么，equals()和hashCode()函数必须开发者自己定义。其他情况下，这两个函数是不需要定义的。
equals():
它是用于进行两个对象的比较的，是对象内容的比较，当然也能用于进行对象参阅值的比较。什么是对象参阅值的比较？就是两个参阅变量的值得比较，我们都知道参阅变量的值其实就是一个数字，这个数字可以看成是鉴别不同对象的代号。两个对象参阅值的比较，就是两个数字的比较，两个代号的比较。这种比较是默认的对象比较方式，在Object这个对象中，这种方式就已经设计好了。所以你也不用自己来重写，浪费不必要的时间。
对象内容的比较才是设计equals()的真正目的，Java语言对equals()的要求如下，这些要求是必须遵循的。否则，你就不该浪费时间：
hashCode():
这个函数返回的就是一个用来进行哈希操作的整型代号，请不要把这个代号和前面所说的参阅变量所代表的代号弄混了。后者不仅仅是个代号还具有在内存中才查找对象的位置的功能。hashCode()所返回的值是用来分类对象在一些特定的收集对象中的位置。这些对象是HashMap, Hashtable, HashSet，等等。这个函数和上面的equals()函数必须自己设计，用来协助HashMap, Hashtable, HashSet，等等对自己所收集的大量对象进行搜寻和定位。
这些收集对象究竟如何工作的，想象每个元对象hashCode是一个箱子的编码，按照编码，每个元对象就是根据hashCode()提供的代号归入相应的箱子里。所有的箱子加起来就是一个HashSet，HashMap，或 Hashtable对象，我们需要寻找一个元对象时，先看它的代码，就是hashCode()返回的整型值，这样我们找到它所在的箱子，然后在箱子里，每个元对象都拿出来一个个和我们要找的对象进行对比，如果两个对象的内容相等，我们的搜寻也就结束。这种操作需要两个重要的信息，一是对象的 hashCode()，还有一个是对象内容对比的结果。
hashCode()的返回值和equals()的关系如下：
为什么这两个规则是这样的，原因其实很简单，拿HashSet来说吧，HashSet可以拥有一个或更多的箱子，在同一个箱子中可以有一个或更多的独特元对象（HashSet所容纳的必须是独特的元对象）。这个例子说明一个元对象可以和其他不同的元对象拥有相同的hashCode。但是一个元对象只能和拥有同样内容的元对象相等。所以这两个规则必须成立。
设计这两个函数所要注意到的：
如果你设计的对象类型并不使用于收集性对象，那么没有必要自己再设计这两个函数的处理方式。这是正确的面向对象设计方法，任何用户一时用不到的功能，就先不要设计，以免给日后功能扩展带来麻烦。
如果你在设计时想别出心裁，不遵守以上的两套规则，那么劝你还是不要做这样想入非非的事。我还没有遇到过哪一个开发者和我说设计这两个函数要违背前面说的两个规则，我碰到这些违反规则的情况时，都是作为设计错误处理。
当一个对象类型作为收集型对象的元对象时，这个对象应该拥有自己处理equals()，和/或处理hashCode()的设计，而且要遵守前面所说的两种原则。equals()先要查null和是否是同一类型。查同一类型是为了避免出现ClassCastException这样的异常给丢出来。查 null是为了避免出现NullPointerException这样的异常给丢出来。
如果你的对象里面容纳的数据过多，那么这两个函数 equals()和hashCode()将会变得效率低。如果对象中拥有无法serialized的数据，equals()有可能在操作中出现错误。想象一个对象x，它的一个整型数据是transient型（不能被serialize成二进制数据流）。然而equals()和hashCode()都有依靠这个整型数据，那么，这个对象在serialization之前和之后，是否一样？答案是不一样。因为serialization之前的整型数据是有效的数据，在serialization之后，这个整型数据的值并没有存储下来，再重新由二进制数据流转换成对象后，两者（对象在serialization 之前和之后）的状态已经不同了。这也是要注意的。
知道以上这些能够帮助你：
1. 进行更好的设计和开发。
2. 进行更好的测试案例开发。
3. 在面试过程中让面试者对你的学识渊博感到满意。
hashCode的作用
总的来说，Java中的集合（Collection）有两类，一类是List，再有一类是 Set。你知道它们的区别吗？前者集合内的元素是有序的，元素可以重复；后者元素无序，但元素不可重复。那么这里就有一个比较严重的问题了：要想保证元素不重复，可两个元素是否重复应该依据什么来判断呢？这就是Object.equals方法了。但是，如果每增加一个元素就检查一次，那么当元素很多时，后添加到集合中的元素比较的次数就非常多了。也就是说，如果集合中现在已经有1000个元素，那么第1001个元素加入集合时，它就要调用1000次 equals方法。这显然会大大降低效率。
我们知道，equals()函数是用来做比较的。java中的比较有两种：一种是内存地址的比较，一种是内容的比较。而比较个体也有两种：一种是简单类型（这类简单说来无所谓内存地址的比较或者内容比较的区别）；还有一种是对象的比较，本文中说的主要是后者
在java中，（对象）内存地址的比较，是通过==完成的。比如
这样的语句中，我们认为，如果obj1和obj2的内存地址相同，则返回true
而equals()通常是比较内容的。这里说“通常” ，是因为在最根本的Object类中，equal()函数做的是地址的比较。而在其他几乎所有的类中，equals()都经过重载，进行内容的比较。
而在说equals()的时候我们还涉及hashCode()是因为在有些应用中（比如，HashMap的key是对象），必须在重载equals()的同时重载hashCode()。因为java中默认(Object)的hashCode是根据对象的地址计算得到的。
我们通常不会注意到这个问题，因为我们通常所使用的key都是简单类型，或者是String, Long等一些特殊的对象（其特殊性请参看笔者在写java 浅拷贝和深拷贝时的讨论），这时候，这个问题被我们无意间绕过了
有人已经概括了这种我们忽略了的情况：“如果你想将一个对象A放入另一个收集（集合）对象B里，或者使用这个对象A为查找一个元对象在收集对象B里位置的钥匙（key），并支持是否容纳（isContains()），删除收集对象B里的元对象（remove()?）这样的操作，那么，equals()和hashCode()函数必须开发者自己定义。”
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
