JAVA String介绍、常量池及String、StringBuilder和StringBuffer得区别. 以及8种基本类型的包装类和常量池得简单介绍

一、概述

　　String是代表字符串的类，本身是一个最终类，使用final修饰，不能被继承。

二、定义方式

　　方式一：直接赋值法

String str1 = "hello";

　　方式二：创建法

String str2 = new String("hello");

　　方式三：创建一个字符数组ch，new String ( ch )

char chs[] = {'h','e','l','l','l','o'};
String str3 = new String(chs);

三、内存

　　字符串在内存中是以字符数组的形式来存储的。

　　在此之前我们要先引入一个概念常量是在编译期存放在常量池中的。

我们常说的常量池，就是指方法区中的运行时常量池。

运行时常量池在jvm内存结构的方法区中。

因为常量是编译期可以得知的，在编译期会执行全是常量的计算式（编译器优化），把常量以及计算结果值（也是常量）存放在常量池中，减轻运行期的负担。

方法调用和new是编译期无法得知的，不会放在常量池，而是在运行期放在堆内存中。

　　接下来我们通过一系列的练习来熟悉字符串常量池以及字符串类型数据在内存中的存放。

    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = new String("hello");
        System.out.println(str1 == str2);

        String str3 = "hello";
        System.out.println(str1 == str3);
    }

　　以上代码得运行结果是什么呢？

　　这个时候大家会不会疑惑这不都是hello吗？怎么会不相同呢？不要着急，接下来我来给画图讲解一下

　　“hello” 如果存放在常量池当中，就会占用内存，假如这个hello得空间地址为aaa，那么str1存放得就是hello得地址aaa
　　str2创建一个String对象，那么这个时候肯定在堆上面开辟一块空间，假设这个地址是bbb,在这个String 对象中，存在一个value[] 保存着 orginal传入的字符串，这个val ==“hello”,因为在字符串常量池中已经有了"hello",所以val 直接指向常量池中的"hello".但是str2 指向的依然是 bbb在堆中的空间。所以 System.out.println(str1 == str2) 为false
　　之后呢,str3 也等于"hello",他也准备把hello放在常量池当中.此时常量池中已经存在"hello",那么之后str3 在存放"hello"地址的时候，就指向的是常量池中原来hello的地址。所以 System.out.println(str1 == str3); 为true

注：此为String得源码
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;

    /**
     * Class String is special cased within the Serialization Stream Protocol.
     *
     * A String instance is written into an ObjectOutputStream according to
     * <a href="{@docRoot}/../platform/serialization/spec/output.html">
     * Object Serialization Specification, Section 6.2, "Stream Elements"</a>
     */
    private static final ObjectStreamField[] serialPersistentFields =
        new ObjectStreamField[0];

    /**
     * Initializes a newly created {@code String} object so that it represents
     * an empty character sequence.  Note that use of this constructor is
     * unnecessary since Strings are immutable.
     */
    public String() {
        this.value = "".value;
    }

    /**
     * Initializes a newly created {@code String} object so that it represents
     * the same sequence of characters as the argument; in other words, the
     * newly created string is a copy of the argument string. Unless an
     * explicit copy of {@code original} is needed, use of this constructor is
     * unnecessary since Strings are immutable.
     *
     * @param  original
     *         A {@code String}
     */
    public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }
}

　　再看另一组练习

public static void main(String[] args) {

        String str1 = "hello";
        String str2 = "hel"+"lo";
        System.out.println(str1==str2);

        String str3 = new String("hel")+"lo";
        System.out.println(str1==str3);

    }

　　请判断两次打印结果是什么？

str1 指向字符串常量池中的 “hello”
str2 是"hel"与"lo" 组合而成的，常量在编译的时候就已经确定了,所以在编译时，已经被处理为"hello",所以也指向常量池中的"hello"。
str3 首先new 了一个String(“hel”)对象，在堆中开辟一块空间，这个对象中的"hel"同时存放在常量池中，之后又在常量池中开辟一块空间存放 “lo”。两块部分之间的"+",将 String 的对象与常量池中的 "lo"结合在堆中再次开辟一块新的空间，这块内存中的val ==“hello”，str3指向的是合并之后的对象，地址为ddd.

四、字符串常量池

在上面的例子中, String类的两种实例化操作, 直接赋值和 new 一个新的 String.

　　String类的设计使用了共享设计模式

　　在JVM底层实际上会自动维护一个对象池（字符串常量池)

　　如果现在采用了直接赋值的模式进行String类的对象实例化操作，那么该实例化对象（字符串内容）将自动保存到这个对象池之中.

　　如果下次继续使用直接赋值的模式声明String类对象，此时对象池之中如若有指定内容，将直接进行引用

　　如若没有，则开辟新的字符串对象而后将其保存在对象池之中以供下次使用
　　

　　理解 “池” (pool)

　　“池” 是编程中的一种常见的, 重要的提升效率的方式, 我们会在未来的学习中遇到各种 “内存池”, “线程池”, “数据库连接池” …然而池这样的概念不是计算机独有, 也是来自于生活中.

String str = new String("hello");

这样的做法有两个缺点:

1. 如果使用String构造方法就会开辟两块堆内存空间，并且其中一块堆内存将成为垃圾空间(字符串常量 “hello” 也是一个匿名对象, 用了一次之后就不再使用了, 就成为垃圾空间, 会被 JVM 自动回收掉).

2. 字符串共享问题. 同一个字符串可能会被存储多次, 比较浪费空间.

intern(),手动入池

String str1 = "hello";
String str2 = new String("hello").intren();

传入构造方法的字符串在字符串常量池中是否存在，如果有的话，就把常量池中的引用传给当前的引用类型变量。

五、理解字符串不可变

public static void main(String[] args) {
        String str = "hello" ;
        str = str + " world" ;
        str += "!!!" ;
        System.out.println(str);
    }

对于这种代码，乍一看我们以为成功的将str 每次与其他的字符串拼接，但是这样是不可以的， str 原来指向的是"hello",但是在与" world"拼接之后，又会产生一个新的对象"helll world",再次拼接一个"!!!",那么又会产生一个新的对象"hello world!!!",在内存中就会产生多个对象。

我们最后需要的是"hello world!!!",但是却开辟了5块内存空间。

如果在一个循环中拼接，那么会开辟更多的内存空间！！

所以这样的代码是极为不可取的！！！

那么如何拼接呢，具体在之后的StringBuff、StringBuilder中介绍。

六、StringBuffer 和 StringBuilder

StringBuffer 和 StringBuilder 又是一种新的字符串类型。

  通常来讲String的操作比较简单，但是由于String的不可更改特性，为了方便字符串的修改，提供 StringBuffer 和 StringBuilder 类。

  StringBuffer 和 StringBuilder 在功能上大部分是相同的，在这里我们着重介绍 StringBuffer.

（1）append 方法

在String中使用"+"来进行字符串连接，但是这个操作在StringBuffer类中需要更改为append()方法。

String和StringBuffer最大的区别在于：String的内容无法修改，而StringBuffer的内容可以修改。频繁修改字符串的情况考虑使用 StingBuffer。

 public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("a");
        sb.append("b");
        sb.append("c");
        System.out.println(sb);
    }

最后返回的是 this，在字符串本身拼接字符串。同时StringBuffer 有自己重写的 toString 方法，可以直接进行打印。

//我们将此代码进行反编译
 public static void main(String[] args) {
       String str1 = "abc";
       String str2 = "def";
       String str3 = str1+str2;
       System.out.println(str3);

    }

在编译的过程中，我们发现StringBuilder.append 方法的出现；说明：String 的“+” 拼接，会被底层优化为一个 StringBuilder ，拼接的时候会用到 append 方法，也就是说String得“+”拼接就是StringBuilder。

区别

String 和 StringBuilder 及 StringBuffer 的区别

String 进行拼接时，底层会被优化为StringBuilder

String的拼接会产生临时对象，但是后两者每次都只是返回当前对象的引用。

String的内容不可修改，StringBuffer与StringBuilder的内容可以修改.

StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作 synchronized

StringBuilder得源码：

    @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }

StringBuffer得源码：

    @Override
    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
    }

8种基本类型的包装类和常量池

Java 基本类型的包装类的大部分都实现了常量池技术，即Byte,Short,Integer,Long,Character,Boolean；这5种包装类默认创建了数值[-128，127]的相应类型的缓存数据，但是超出此范围仍然会去创建新的对象。•两种浮点数类型的包装类 Float,Double 并没有实现常量池技术。

/**
*此方法将始终缓存-128到127（包括端点）范围内的值，并可以缓存此范围之外的其他值。
*/
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

 public static Double valueOf(double d) {
        return new Double(d);
    }

        Integer i1 = 33;
        Integer i2 = 33;
        System.out.println(i1 == i2);// 输出true
        Integer i11 = 333;
        Integer i22 = 333;
        System.out.println(i11 == i22);// 输出false  因为333 不在-128到127之间，所以他不再常量池当中， 每次都是进行得new 在堆当中创建对象得操作，==相当于比较他们得引用地址，所以为false
        Double i3 = 1.2;
        Double i4 = 1.2;
        System.out.println(i3 == i4);// 输出false     double没有常量池 所以都是在内存中开辟一块空间。所以他们得应用地址不同

  Integer i1 = 40;
  Integer i2 = 40;
  Integer i3 = 0;
  Integer i4 = new Integer(40);
  Integer i5 = new Integer(40);
  Integer i6 = new Integer(0);

  System.out.println("i1=i2   " + (i1 == i2));      //true
  System.out.println("i1=i2+i3   " + (i1 == i2 + i3));    //true
  System.out.println("i1=i4   " + (i1 == i4));   //false
  System.out.println("i4=i5   " + (i4 == i5));   //fasle
  System.out.println("i4=i5+i6   " + (i4 == i5 + i6));    //true     语句i4 == i5 + i6，因为+这个操作符不适用于Integer对象，首先i5和i6进行自动拆箱操作，进行数值相加，即i4 == 40。然后Integer对象无法与数值进行直接比较，所以i4自动拆箱转为int值40，最终这条语句转为40 == 40进行数值比较。
  System.out.println("40=i5+i6   " + (40 == i5 + i6));      //true

posted @ 2021-06-10 14:53 —阿峰— 阅读(170) 评论(0) 编辑收藏举报

刷新页面返回顶部

Mr丶Zhang

学习记录，有兴趣的可以一起学习沟通