String补习笔记

作为一名Java程序员,String是我们使用频率非常高的一种对象类型,虽然常用,但是了解只是皮毛,于是补习一下

先来看一下String的源码,再汇总一些关于String的典型问题

String的存储结构和一些常用方法

以主流的JDK 1.8为例

String的内部实际存储结构为 char 数组,用final修饰,源码如下

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    // 用于存储字符串的值 
    private final char value[];
    // 用于缓存字符串的hash code 
    private int hash; // Default to 0 
    ...
}

1.构造方法

String有很多构造方法,其中列举4个重要的构造方法


(1).以String为参数的构造方法

public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
}

(2).以char []为参数的构造方法

public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
}

(3).以StringBuffer为参数的构造方法

public String(StringBuffer buffer) {
        synchronized(buffer) {
            this.value = Arrays.copyOf(buffer.getValue(), buffer.length());
        }
    }

(4).以StringBuilder为参数的构造方法

public String(StringBuilder builder) {
       this.value = Arrays.copyOf(builder.getValue(), builder.length());
}

其中,比较容易被忽略的是以 StringBuffer 和 StringBuilder 为参数的构造函数

2. equals() 方法

看源码之前,先来补习一下equals() 方法 与  ‘==’  的区别

java中的数据类型,可分为两类: 

(1)基本数据类型,也称原始数据类型,byte,short,char,int,long,float,double,boolean 

        基本数据类型比较, == 和 equals() 两者都是比较值

(2)复合数据类型(引用数据类型)

        复合数据类型使用 == 进行比较的时候,比较的是他们在内存中的存放地址是否相同

        JAVA当中所有的类都是继承于Object这个基类的,在Object中的基类中定义了一个 equals() 的方法,这个方法的初始行为是比较对象的内存地址,对于复合数据类型之间进行 equals() 比较,在没有覆写 equals() 方法的情况下,他们之间的比较还是基于他们在内存中的存放位置的地址值的

        但在一些类库当中这个方法被覆盖掉了,如String,Integer,Date,在这些类当中equals() 有其自身的实现,而不再是比较类在堆内存中的存放地址了

        所以,在String中,equals() 方法是比较对象的内容相等,即比较两个字符串是否相等

源码如下

public boolean equals(Object anObject) {
    // 如果对象引用相同,则直接返回true
    if (this == anObject) {
        return true;
    }
    // 判断是否为String类型,如果不是返回false
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            // 把两个String转换为char数组对比
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            // 循环对比两个字符串中的每一个字符
            while (n-- != 0) {
                // 如果其中有字符不相等,就返回false
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

3.compareTo() 方法

compareTo用于比较两个字符串,返回值为 int 类型

源码如下:

public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        // 获取到两个字符串长度最短的那个字符长度
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        // 对比每一个字符
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            // 有字符不相等就返回差值
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

还有一个和compareTo() 比较类似的方法compareToIgnoreCase(),用于忽略大小写后比较两个字符串

可以看出compareTo() 方法和equals() 方法都是用于比较两个字符串,但是他们有两点不同

(1)equals() 可以接收一个 Object 类型的参数,而 compareTo() 只能接收一个 String 类型的参数

(2)equals() 返回值为 Boolean,而 compareTo() 的返回值则为 int

它们都可以用于两个字符串的比较,当 equals() 方法返回 true 时,或者是 compareTo() 方法返回 0 时,则表示两个字符串完全相同

4.其他方法

一些其他常用的方法

indexOf():查询字符串首次出现的下标位置

lastIndexOf():查询字符串最后出现的下标位置

contains():查询字符串中是否包含另一个字符串

toUpperCase():把字符串全部转换成大写

length():查询字符串的长度

trim():去掉字符串首尾空格

replace():替换字符串中的某些字符

split():把字符串分割并返回字符串数组

join():把字符串数组转为字符串


String 如果再延伸一下,还会涉及到一些更多的知识细节

列举了一些常见的延伸问题:

1.创建String时,直接赋值和new有什么区别?

2.为什么 String 类型要用 final 修饰?

3.String 和 StringBuilder、StringBuffer 有什么区别?

4.String == 和 equal() 的区别是什么?(上文已提到)

5.String 的 intern() 方法有什么含义?

下面分别回答每个问题


1.创建String时,直接赋值和new有什么区别?

我们在日常创建Java对象时,一般用两种方式

  1. 采用字面值的方式赋值
  2. 采用new关键字新建一个字符串对象

这两种方式在性能和内存占用方面存在着差别

JVM为了提升性能和减少内存开销,其维护了一块特殊的内存空间,即字符串池,字符串池的作用:避免字符串的重复创建,节省了内存同时,还省去了创建相同字符串的时间,提高了效率

JDK 1.6字符串池位于方法区,JDK 1.7以后位于堆

字面量方式赋值

采用字面值方式创建如下

String str1 = "java";

采用字面值的方式创建一个字符串时,JVM首先在字符串池中查找是否存在 “java” 这个字符串对象

  • 如果不存在,则在字符串池中创建 “java” 这个字符串对象,然后将池中 “java” 这个字符串对象的引用地址返回给字符串常量str1,这样str1会指向池中 “java” 这个字符串对象
  • 如果存在,则不创建任何对象,直接将字符串池中 “java” 这个字符串对象的引用地址返回,赋给字符串常量

我们再创建一个str2,用 == 判断他们的引用地址是否相同

String str1 = "java";
String str2 = "java";
System.out.println(str1 == str2);

输出结果:true

这是因为,创建字符串对象str2时,字符串池中已经存在 “java” 这个对象,直接把对象 “java” 的引用地址返回给str2,这样str2指向了池中 “java” 这个对象,也就是说str1和str2指向了同一个对象

new关键字方式创建

下面使用new关键字方式来创建,如下所示

String str1 = new String("java");

采用new关键字创建一个字符串对象时,JVM首先在字符串池中查找是否存在 java” 这个字符串对象

  • 如果不存在,则首先在字符串池中创建一个 java” 字符串对象,然后再在堆中创建一个 java” 字符串对象,然后将堆中这个 java” 字符串对象的地址返回赋给str1引用,这样,str1指向了堆中创建的这个 java” 字符串对象
  • 如果存在,则不在字符串池中再去创建 “java” 这个对象了,直接在堆中创建一个 “java” 字符串对象,然后将堆中的这个 “java” 对象的地址返回赋给引用str1,这样,str1就指向了堆中创建的这个 “java” 字符串对象

我们再创建一个str2,用 == 判断他们的引用地址是否相同

String str2 = new String("java");
System.out.println(str1 == str2);

输出结果:false

这是因为,采用new关键字创建对象时,每次new出来的都是一个新的对象,即在堆上会开辟一块新的空间,也即是说引用str1和str2指向的 “java” 是两个不同的对象

所以,建议在平时的使用中,尽量使用字面量方式进行赋值,为了节省堆空间,同时字面量赋值方式双引号 “” 采用了String interning(字符串驻留)进行了优化,效率比构造方法高

2.为什么 String 类要用 final 修饰?

我们可以理解将String的immutable是一种设计,设计思想都会遵守一些既定的规则,这样才能体现一致性,所以String类需要final修饰

(1)安全 :当你在调用其他方法时,比如调用一些系统级操作指令之前,可能会有一系列校验,如果是可变类的话,可能在你校验过后,它的内部的值又被改变了,这样有可能会引起严重的系统崩溃问题,这是迫使SString 类设计成不可变类的一个重要原因

(2)高效

(3)为了实现字符串池

将(2)(3)特点与上一个问题:“1.创建String时,直接赋值和new有什么区别?” 结合,我们在创建String时,只有字符串是不可变时,我们才能实现字符串常量池,如果字符串是可变的,那么一个引用操作改变了对象的值,对其他引用会有影响,这样显然是不合理的

String str1 = "java";
String str2 = "java";

再结合字符串池的特点,就能够理解了String这么设计的原因


3.String 和 StringBuilder、StringBuffer 有什么区别?

String : 不可变

StringBuffer :可变 (线程安全),速度慢

StringBuilder :可变 (线程不安全),速度快

共同点:类都用 final 进行修饰

因为String类型是不可变的,所以在字符串拼接的时候如果使用String的话性能会很低,因此我们就需要使用另一个数据类型StringBuffer,它提供了 append 和 insert 方法可用于字符串的拼接,它使用 synchronized 来保证线程安全

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

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

因为它使用了 synchronized 来保证线程安全,所以性能不是很高,于是在 JDK 1.5 就有了 StringBuilder
它同样提供了 append 和 insert 的拼接方法,但它没有使用 synchronized 来修饰,因此在性能上要优于StringBuffer,所以在非并发操作的环境下可使用StringBuilder

 @Override
    public StringBuilder append(Object obj) {
        return append(String.valueOf(obj));
    }

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

5.String 的 intern() 方法有什么含义?

intern() 是一个Native方法,底层调用C++的 StringTable::intern方法实现

intern() 方法在JDK 1.7版本 和 1.6 及之前的版本有差异,我们这里仅关注JDK 1.7 以后的版本

intern() 方法的作用是:

如果常量池存在该字面量的字符串,返回这个常量池的对象的引用

如常量池不存在字面量的对象,在常量池中记录首次出现的实例引用,调用intern()返回这个引用

举个例子

String str1 = new String("Java");
String str2 = str1.intern();
String str3 = "Java";
System.out.println(str1 == str2); // false
System.out.println(str2 == str3); // true

它们在JVM上的位置如下图所示


至此,关于String的相关知识整理完毕,我们下篇文章见~

赫墨拉

我是一个喜爱大数据的小菜鸡,这里是我分享我的成长和经历的博客

You may also like...

发表评论

电子邮件地址不会被公开。