当前位置: 代码迷 >> Java相关 >> Java 内存机制(堆和栈
  详细解决方案

Java 内存机制(堆和栈

热度:378   发布时间:2011-07-21 20:11:45.0
Java 内存机制(堆和栈
Java 内存机制(堆和栈),内存地址,==,equals,hashCode

问题的引入:

问题一:
String str1 = "abc";
String str2 = "abc";
System.out.println(str1==str2); //true

问题二:
String str1 =new String ("abc");
String str2 =new String ("abc");
System.out.println(str1==str2); // false

问题三:
String s1 = "ja";
String s2 = "va";
String s3 = "java";
String s4 = s1 + s2;
System.out.println(s3 == s4);//false
System.out.println(s3.equals(s4));//true

由于以上问题让我含糊不清,于是特地搜集了一些有关java内存分配的资料,以下是网摘:

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="JAVA";
这 种语法是在堆而不是在常量池中创建对象,并将s2指向它,然后去字符串常量池中看看,是否有与之相同的内容的对象,如果有,则将new出来的字符串对象与 字符串常量池中的对象联系起来,如果没有,则在字符串常量池中再创建一个包含该内容的字符串对象,并将堆内存中的对象与字符串常量池中新建出来的对象联系 起来。
这就是字符串的一次投入,终生回报的内存机制,对字符串的比较带来好处。
http://blog.csdn.net/xyz1982510/archive/2008/09/12/2916467.aspx

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 以下的整数是相等的  128以上就作为不同对象处理了

Integer i=100;   
Integer j=100;   
System.out.println(i==j);  // 打印 true

Integer i=200;   
Integer j=200;   
System.out.println(i==j);  //打印false

Java中的==和equals浅见
java中的数据类型,可分为两类:
1.基本数据类型,也称原始数据类型。byte,short,char,int,long,float,double,boolean
  他们之间的比较,应用双等号(==),比较的是他们的值。
2.复合数据类型(类)
  当他们用(==)进行比较的时候,比较的是他们在内存中的存放地址,所以,除非是同一个new出来的对象,他们的比较后的结果为true,否则比较后结果为false。
  对于复合数据类型之间进行equals比较,在没有覆写equals方法的情况下,他们之间的比较还是基于他们在内存中的存放位置的地址值的,因为Object的equals方法也是用双等号(==)进行比较的,所以比较后的结果跟双等号(==)的结果相同。
//Object中的equals方法   
public boolean equals(Object obj) {
    return (this == 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) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = count;
        if (n == anotherString.count) {
        char v1[] = value; //字符串的值,用字符数组表示
        char v2[] = anotherString.value;
        int i = offset;
        int j = anotherString.offset;
        while (n-- != 0) {
            if (v1[i++] != v2[j++])
            return false;
        }
        return true;
        }
    }
    return false;
    }
   
    //返回的值是基于字符串的值运算出来的,
    //字符串值相等则他们的hashCode值也相等,否则,不相等
public int hashCode() {
    int h = hash;
    if (h == 0) {
        int off = offset;
        char val[] = value; //字符串的值,用字符数组表示
        int len = count;
            //基于字符串的值产生hash值
            for (int i = 0; i < len; i++) {
                h = 31*h + val[off++];
            }
            hash = h;
        }
        return h;
    }

问:对象的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()的要求如下,这些要求是必须遵循的。否则,你就不该浪费时间:
    * 对称性:如果x.equals(y)返回是“true”,那么y.equals(x)也应该返回是“true”。
    * 反射性:x.equals(x)必须返回是“true”。
    * 类推性:如果x.equals(y)返回是“true”,而且y.equals(z)返回是“true”,那么z.equals(x)也应该返回是“true”。
    * 还有一致性:如果x.equals(y)返回是“true”,只要x和y内容一直不变,不管你重复x.equals(y)多少次,返回都是“true”。
    * 任何情况下,x.equals(null),永远返回是“false”;x.equals(和x不同类型的对象)永远返回是“false”。

hashCode():
这 个函数返回的就是一个用来进行赫希操作的整型代号,请不要把这个代号和前面所说的参阅变量所代表的代号弄混了。后者不仅仅是个代号还具有在内存中才查找对 象的位置的功能。hashCode()所返回的值是用来分类对象在一些特定的收集对象中的位置。这些对象是HashMap, Hashtable, HashSet,等等。这个函数和上面的equals()函数必须自己设计,用来协助HashMap, Hashtable, HashSet,等等对自己所收集的大量对象进行搜寻和定位。

这些收集对象究竟如何工作的,想象每个元对象hashCode是一个箱子的 编码,按照编码,每个元对象就是根据hashCode()提供的代号归入相应的箱子里。所有的箱子加起来就是一个HashSet,HashMap,或 Hashtable对象,我们需要寻找一个元对象时,先看它的代码,就是hashCode()返回的整型值,这样我们找到它所在的箱子,然后在箱子里,每 个元对象都拿出来一个个和我们要找的对象进行对比,如果两个对象的内容相等,我们的搜寻也就结束。这种操作需要两个重要的信息,一是对象的 hashCode(),还有一个是对象内容对比的结果。

hashCode()的返回值和equals()的关系如下:

    * 如果x.equals(y)返回“true”,那么x和y的hashCode()必须相等。
    * 如果x.equals(y)返回“false”,那么x和y的hashCode()有可能相等,也有可能不等。

为 什么这两个规则是这样的,原因其实很简单,拿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方法。这显然会大大降低效率。    于是,Java采用了哈希表的原理。哈希(Hash)实际上是个人名,由于他提出一哈希算法的概念,所以就以他的名字命名了。哈希算法也称为散列算法,是 将数据依特定算法直接指定到一个地址上。如果详细讲解哈希算法,那需要更多的文章篇幅,我在这里就不介绍了。初学者可以这样理解,hashCode方法实 际上返回的就是对象存储的物理地址(实际可能并不是)。    这样一来,当集合要添加新的元素时,先调用这个元素的hashCode方法,就一下子能定位到它应该放置的物理位置上。如果这个位置上没有元素,它就可以 直接存储在这个位置上,不用再进行任何比较了;如果这个位置上已经有元素了,就调用它的equals方法与新元素进行比较,相同的话就不存了,不相同就散 列其它的地址。所以这里存在一个冲突解决的问题。这样一来实际调用equals方法的次数就大大降低了,几乎只需要一两次。所以,Java对于 eqauls方法和hashCode方法是这样规定的:1、如果两个对象相同,那么它们的hashCode值一定要相同;2、如果两个对象的 hashCode相同,它们并不一定相同,上面说的对象相同指的是用eqauls方法比较。你当然可以不按要求去做了,但你会发现,相同的对象可以出现在 Set集合中。同时,增加新元素的效率会大大下降。

我们知道,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()函数必须开发者自己定义。” (括号为笔者添加)
搜索更多相关的解决方案: 内存  java  equals  false  Java  

----------------解决方案--------------------------------------------------------
问题一:
String str1 = "abc";
String str2 = "abc";
System.out.println(str1==str2); //true

有些书上说str1 == str2的返回值跟JVM有关,有些JVM对相同的字符串常量都返回相同的引用,另一些JVM可能对相同的字符串常量返回不同的引用(有点不太可能,大家都知道浪费可耻,你懂的),应该说基本上所有的JVM对相同字符串常量都返回相同的引用,所以System.out.println(str1 == str2);输出true是正常的。

问题二:
String str1 =new String ("abc");
String str2 =new String ("abc");
System.out.println(str1==str2); // false

这道题还用说吗?不知道LZ是怎么想的,也许看到两个相同的"abc"吧,虽然String的构造器接收到的都是两个相同的引用,但返回的都是一个新对象的引用吧,不同对象的引用怎么可能相同呢?所以System.out.println(str1 == str2);当然输出false

问题三:
String s1 = "ja";
String s2 = "va";
String s3 = "java";
String s4 = s1 + s2;
System.out.println(s3 == s4);//false
System.out.println(s3.equals(s4));//true

s3和s4引用的对象都包含相同的字符串,"java",但是它们仍然是两个对象,所以System.out.println(s3 == s4);输出false,而String类已经覆盖了equals()方法,它才是真正执行比较的方法,就算是两个不同的对象,只要包含的字符串相同,那么它就会返回true,所以System.out.println(s3.equals(s4));输出true

LZ可以去学C,然后自己搞一个数据结构出来,做一个自己的类库,学Java就像是别人写了一个很大的类库,我正在想如何使用这个类库,可是总是会忘。




[ 本帖最后由 lz1091914999 于 2011-7-21 21:06 编辑 ]
----------------解决方案--------------------------------------------------------
问题1:
String str1 = "abc";
String str2 = "abc";
System.out.println(str1==str2); //true

因为“abc”是常量字符串,在常量区储存中,
任何对象指向该常量字符串时,编译器都分一个同样的对象给他们

问题二三,
二楼讲解的很给力!
----------------解决方案--------------------------------------------------------
回复 3楼 yong718100
你应该这样解释:对相同的字符串常量应该共享,这样才能节约。
----------------解决方案--------------------------------------------------------
  相关解决方案