请大家点评一下我对堆栈的了解谢谢

倒只有new出来的对象才在堆中应该是字符常量池中又 aaaa aa 然后栈中有2个引用

new 是创建一个新的对象，存放在堆中·~
上面有两个引用，都是在字符常量池

请问大家有会java实现单点登录的吗？愿意有偿学习想学的或者可以教授的朋友可以联系我的群：35783676 请注明：java

什么叫堆？你用十几个麻将牌竖直叠成一摞这叫堆，你可以从上面、下面、中间任意抽出一张牌，也可以任意插入一张。什么叫栈？AK-47的弹匣就是一个栈，在上面的子弹没被取出之前，你无法取出下面的子弹——尽管你可以从边上的透明部分读出里面装的是什么型号、颜色的子弹。堆很灵活，但是不安全。对于对象，我们要动态地创建、销毁，不能说后创建的对象没有销毁，先前创建的对象就不能销毁，那样的话我们的程序就寸步难行，所以Java中用堆来存储对象。而一旦堆中的对象被销毁，我们继续引用这个对象的话，就会出现著名的 NullPointerException，这就是堆的缺点——错误的引用逻辑只有在运行时才会被发现。栈不灵活，但是很严格，是安全的，易于管理。因为只要上面的引用没有销毁，下面引用就一定还在，所以，在栈中，上面引用永远可以通过下面引用来查找对象，同时如果确认某一区间的内容会一起存在、一起销毁，也可以上下互相引用。在大部分程序中，都是先定义的变量、引用先进栈，后定义的后进栈，同时，区块内部的变量、引用在进入区块时压栈，区块结束时出栈，理解了这种机制，我们就可以很方便地理解各种编程语言的作用域的概念了，同时这也是栈的优点——错误的引用逻辑在编译时就可以被发现。

String aa="aaaa"; String bb=aa;
只有一个对象"aaaa"在常量池里
aa和bb这两个变量是引用，在栈里。

如果你还能引用这个对象的话，堆会把该对象该销毁吗？
NullPointerException不是这么出现的。

引用下前人的内容：
×××××××××××××××××××××××××××××××××××××××××××××××××××
public class Test {
    public static void main(String[] args) {
        String s1 = "sss111";
        String s2 = "sss111";
    }
}在上面程序中存在2个相同的常量"sss111",对于n个值相同的String常量,在Constant Pool中
只会创建一个,所以在编译好的class文件中,我们只能找到一个对"sss111"的表示:
000000abh: 08 00 11 01 00 06 73 73 73 31 31 31             ; ......sss111
在程序执行的时候,Constant Pool会储存在Method Area,而不是heap中.另外,对于""内容为空的字符串常量,会创建一个长度为0,内容为空的字符串放到Constant Pool中,
而且Constant Pool在运行期是可以动态扩展的.
关于String类的说明
1.String使用private final char value[]来实现字符串的存储,也就是说String对象创建之后,就不能
再修改此对象中存储的字符串内容,就是因为如此,才说String类型是不可变的(immutable).2.String类有一个特殊的创建方法,就是使用""双引号来创建.例如new String("i am")实际创建了2个
String对象,一个是"i am"通过""双引号创建的,另一个是通过new创建的.只不过他们创建的时期不同,
一个是编译期,一个是运行期!3.java对String类型重载了+操作符,可以直接使用+对两个字符串进行连接.4.运行期调用String类的intern()方法可以向String Pool中动态添加对象.String的创建方法一般有如下几种
1.直接使用""引号创建.
2.使用new String()创建.
3.使用new String("someString")创建以及其他的一些重载构造函数创建.
4.使用重载的字符串连接操作符+创建.例1
    /*
    * "sss111"是编译期常量,编译时已经能确定它的值,在编译
    * 好的class文件中它已经在String Pool中了,此语句会在
    * String Pool中查找等于"sss111"的字符串(用equals(Object)方法确定),
    * 如果存在就把引用返回,付值给s1.不存在就会创建一个"sss111"放在
    * String Pool中,然后把引用返回,付值给s1.
    *
    */
    String s1 = "sss111";     //此语句同上
    String s2 = "sss111";    /*
    * 由于String Pool只会维护一个值相同的String对象
    * 上面2句得到的引用是String Pool中同一个对象,所以
    * 他们引用相等
    */
    System.out.println(s1 == s2); //结果为true
例2
    /*
    * 在java中,使用new关键字会创建一个新对象,在本例中,不管在
    * String Pool中是否已经有值相同的对象,都会创建了一个新的
    * String对象存储在heap中,然后把引用返回赋给s1.
    * 本例中使用了String的public String(String original)构造函数.
    */
    String s1 = new String("sss111");

    /*
     * 此句会按照例1中所述在String Pool中查找
     */
    String s2 = "sss111";

    /*
     * 由于s1是new出的新对象,存储在heap中,s2指向的对象
     * 存储在String Pool中,他们肯定不是同一个对象,只是
     * 存储的字符串值相同,所以返回false.
     */
    System.out.println(s1 == s2); //结果为false
例3
    String s1 = new String("sss111");
    /*
    * 当调用intern方法时，如果String Pool中已经包含一个等于此String对象
    * 的字符串(用 equals(Object)方法确定),则返回池中的字符串.否则,将此
    * String对象添加到池中，并返回此String对象在String Pool中的引用.
    */
    s1 = s1.intern();

    String s2 = "sss111";

    /*
     * 由于执行了s1 = s1.intern(),会使s1指向String Pool中值为"sss111"
     * 的字符串对象,s2也指向了同样的对象,所以结果为true
     */
    System.out.println(s1 == s2);
例4
    String s1 = new String("111");
    String s2 = "sss111";

    /*
    * 由于进行连接的2个字符串都是常量,编译期就能确定连接后的值了,
    * 编译器会进行优化直接把他们表示成"sss111"存储到String Pool中,
    * 由于上边的s2="sss111"已经在String Pool中加入了"sss111",
    * 此句会把s3指向和s2相同的对象,所以他们引用相同.此时仍然会创建出
    * "sss"和"111"两个常量,存储到String Pool中.    */
    String s3 = "sss" + "111";

    /*
     * 由于s1是个变量,在编译期不能确定它的值是多少,所以
     * 会在执行的时候创建一个新的String对象存储到heap中,
     * 然后赋值给s4.
     */
    String s4 = "sss" + s1;

    System.out.println(s2 == s3); //true
    System.out.println(s2 == s4); //false
    System.out.println(s2 == s4.intern()); //true
例5
这个是The Java Language Specification中3.10.5节的例子,有了上面的说明,这个应该不难理解了
    package testPackage;
    class Test {
            public static void main(String[] args) {
                    String hello = "Hello", lo = "lo";
                    System.out.print((hello == "Hello") + " ");
                    System.out.print((Other.hello == hello) + " ");
                    System.out.print((other.Other.hello == hello) + " ");
                    System.out.print((hello == ("Hel"+"lo")) + " ");
                    System.out.print((hello == ("Hel"+lo)) + " ");
                    System.out.println(hello == ("Hel"+lo).intern());
            }
    }
    class Other { static String hello = "Hello"; }    package other;
    public class Other { static String hello = "Hello"; }输出结果为true true true true false true,请自行分析!
结果上面分析,总结如下:
1.单独使用""引号创建的字符串都是常量,编译期就已经确定存储到String Pool中.
2.使用new String("")创建的对象会存储到heap中,是运行期新创建的.
3.使用只包含常量的字符串连接符如"aa" + "aa"创建的也是常量,编译期就能确定,已经确定存储到String Pool中.
4.使用包含变量的字符串连接符如"aa" + s1创建的对象是运行期才创建的,存储在heap中.
6.使用"aa" + s1以及new String("aa" + s1)形式创建的对象是否加入到String Pool中我不太确定,可能是必须
调用intern()方法才会加入,希望高手能回答 @_@
还有几个经常考的面试题:1.
String s1 = new String("s1") ;
String s2 = new String("s1") ;
上面创建了几个String对象?
答案:3个 ,编译期Constant Pool中创建1个,运行期heap中创建2个.
2.
String s1 = "s1";
String s2 = s1;
s2 = "s2";
s1指向的对象中的字符串是什么?
答案: "s1"

由String看Java堆栈问题，包括==以及equal()。
首先看代码： public class TestString {
    public static void main(String[] args) {
         String a0 = "abc";
         String b0 = "abc";
        if (a0 == b0) {
             System.out.print("==");
         } else {
             System.out.print("!=");
         }
     }
}   执行结果为：
== public class TestString {
public static void main(String[] args) {
  String a0 = "abc";
  String b0 = "abc";
  if (a0 == b0) {
   System.out.print("==");
  } else {
   System.out.print("!=");
  }
}
}执行结果为：
==
public class TestString {
public static void main(String[] args) {
  String a0 = String.valueOf("abc");
  String b0 = String.valueOf("abc");
  if (a0 == b0) {
   System.out.print("==");
  } else {
   System.out.print("!=");
  }
}
}执行结果为：
== 3 public class TestString {
public static void main(String[] args) {
  String a0 = "abc"+"def";
  String b0 = "abcdef";
  if(a0==b0){
   System.out.print("==");
  }else{
   System.out.print("!=");
  }
}
}执行结果为：
== 4
  public class TestString {
public static void main(String[] args) {
                  String a0 = "abc";
  String b0 = "def";
  String c0 = "abcdef";
  String d0 = a0 + b0;
  if (c0 == d0) {
   System.out.print("==");
  } else {
   System.out.print("!=");
  }
}
}执行结果为：
!=
5
public class TestString {
public static void main(String[] args) {
  String a0 = new String("abc");
  String b0 = new String("abc");
  if (a0 == b0) {
   System.out.print("==");
  } else {
   System.out.print("!=");
  }
}
}执行结果为：
!= 6 public class TestString { public static void main(String[] args) {  String a0 = String.valueOf("abc")+String.valueOf("def");
  String b0 = String.valueOf("abcdef");  if (a0 == b0) {
   System.out.print("==");
  } else {
   System.out.print("!=");
  }
}}执行结果为：
!= 楼主你可以去研究一下

连个引用aa,bb存放在栈中
字符串aaaa存放在堆中
aa,bb指向堆中的同一块内存
上面的解释很准确的

aa和bb都只是指向了“aaaa”而已，只有“aaaa”才是在内存中占了一亩三分地的，呵呵

字符串有两种初始化方式，一种是在程序中直接出现“aaaa”，编译时就初始化放在常量池中，这种情况无论你在程序中出现多少个“aaaa”，都只会占一份内存。
另一种是new出来的，是运行时才初始化的。你new一个就在堆中开辟一个。

堆中是放new出来的东西的,String这个类还是有点特别的,在new
一个String类的时候会先去一个叫String pool的地方找有没有这么一个字符串,
而这个String pool也不是在堆中,是在数据区的!

哈哈，大家讨论都不错，不过我在提醒大家一点。我基本关注VC/C 程序的堆栈，不关注java的堆栈。
因为Windows是MS自己的，java只是向ms看齐，不可能超越MS的。
正所谓“工作向高标准看齐” -- 我就这么理解和做的。呵呵~~C语言中，变量和对象是否放在堆还是栈里，除了跟本身有关外，
还跟static有较大关系(或者说该变量，对象的生命周期有关)。所以，下面的Class a
{
   static
   {
     String aa="aaaa";
     String bb=aa;
   }   {
     String aa="aaaa";
     String bb=aa;
   }
}
应该是不同的，当然还有
String aa="aaaa";
const String aa="aaaa";
static const String aa="aaaa";作用域不可忽视。C语言参考：
    一般认为在c中分为这几个存储区
    1 栈 - 有编译器自动分配释放
    2 堆 - 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收
    3 全局区（静态区），全局变量和静态变量的存储是放在一块的，初始化的全局变量和静
           态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。
           - 程序结束释放
    4 另外还有一个专门放常量的地方。 - 程序结束释放

字符常量池中有“aaaa”
栈中有引用aa和bb，并且指向同一个字符常量池中的地址。

调试易

请大家点评一下我对堆栈的了解谢谢

解决方案 »

请大家点评一下我对堆栈的了解 谢谢

解决方案 »

请大家点评一下我对堆栈的了解谢谢