缓冲池和String池

在内存中虚拟出了一个池子，

在栈内存中有一个x1,他就会指向池中的一个对象，池子的作用是当在出项一个x2是，则会指向池中寻找，看是否有这个对象。缓存的大小是：-128-127，这时一个字节。即一个ASCll表。

 

由方法返回的都在对内存中的。

 

 

package toto.learn1;

 

publicclass StringDemo {

 

    /**

     * Java为了优化字符串的操作，提供了一个缓冲池

     * 1、String str="abc";和String str=new String();

     * 2、String str=new String("abc");创建了几个对象(2个或1个)

     * 3、String str="a"+"b"+"c"+"d";创建了几个对象

     * 4、String s1="a"; Strings2="b"; String s3=s1+s2; s3="ab";

     */

    publicstaticvoid main(String[] args) {

       // 1、首先会取出池里面有没有“abc”对象，通过（equals）

       //找到了，直接返回引用；没找到，会创建一个对象，缓冲到池里，返回引用

       /*String s1="abc";

       String s2="abc";

       System.out.println(s1==s2);*/  

      

       //2、String str=new String("abc");//不管池里有没有缓冲，都会在堆内存中创建

       //一个新的对象，返回引用。此时负责检查并维护缓冲池。实际上对内存创建的对象是缓冲到池中对象的一个拷贝。

       /*

       String s1=new String("abc");//创建了两个对象

       String s2=new String("abc");//创建了一个对象

       System.out.println(s1==s2);//此时结果为false.

       */

       //3、String str="a"+"b"+"c"+"d";

       //编译器有一个优化功能，并合并已知量（得是已知量），其在编译阶段就合并，

       //故上面创建了一个对象。

      

       /**

        * String s3=s1+s2;实际上通过：、

        * StringBuilder sb=newStringBuilder();

        * sb.append(s1);

        * sb.append(s2);

        * */

       String s1="a";

       String s2="b";

       String s3=s1+s2;//字符串是不能相加的。

       }

      

}

 

把一个对象存到集合中，这个对象的地址仍然没变，缓冲池就相当于一个集合。

 

内存中没有单独的一片地址表示池。缓冲池相当于一个集合，存放的是对象的地址。存多少个对象，取决于自己定义的池的大小。

 

 

2. 基本数据类型的包装类

int --> Integer

byte --> Byte

short --> Short

long --> Long

char --> Character

double --> Double

float --> Float

boolean --> Boolean

 

1) Integer x = 1; x = x + 1;  经历了什么过程？装箱à拆箱à装箱

2) 为了优化，虚拟机为包装类提供了缓冲池，Integer池的大小 -128~127 一个字节的大小

3) String池

/*1. String s = "abc"， 虚拟机首先会检查String池里有没有"abc"对象(通过equals方法)

       // 如果有，直接返回引用，如果没有，会在池里创建一个“abc”对象，并返回引用

       Strings1 = "abc";

       Strings2 = "abc";

       System.out.println(s1==s2); // result: true

       */

      

       /* 2.String str = new String("abc"); 不管缓冲池是否有"abc", 都会在堆内存创建一个"abc"对象，返回引用

       // 此时，负责检查并维护缓冲池，其实堆内存的对象是缓冲池中"abc"对象的一个拷贝

       Strings1 = new String("abc");

       Strings2 = new String("abc");

       System.out.println(s1==s2);// result: false

       */

      

       /* 3.String s = "a" + "b" + "c" + "d";  java编译器有个合并已知量的优化功能

       // 在编译阶段就把"a" + "b" + "c" + "d" 合并为”abcd“

       String s= "a" + "b" + "c" + "d";

    //  String s = "abcd";

       System.out.println(s=="abcd");//result: true

       */

      

       /*4.  String s1 = "a"; String s2= "b"; String s3 = s1 + s2;

       //String是常量，不能相加的，java如何实现的？

        StringBuilder sb = new StringBuidler(s1);

        sb.append(s2);

        s3 = sb.toString();

        

        也就是说实际上s3是方法返回的String对象

        凡是方法返回的字符串对象都是在堆内存的，并且不负责维护缓冲池

       */

        String s1 = "a";

        String s2 = "b";

        String s3 = s1 + s2; // 堆内存的对象

        

        System.out.println(s3=="ab");//result: false