String类【JDK源码分析】

String类【JDK源码分析】

• ​​前言​​
• ​​推荐​​
• ​​说明​​
• ​​String类​​

• ​​基本信息​​
• ​​属性​​
• ​​部分方法​​

• ​​charAt​​
• ​​equals​​
• ​​getBytes​​
• ​​hashCode​​
• ​​intern​​
• ​​matches​​
• ​​split​​
• ​​toCharArray​​
• ​​valueOf​​
• ​​从类 java.lang.Object 继承的方法​​

• ​​测试​​
• ​​另外​​
• ​​总结​​
• ​​最后​​

前言

2022/10/24

路漫漫其修远兮,吾将上下而求索

本文是根据jdk学习所做笔记

仅供学习交流使用，转载注明出处

推荐

JDK API 1.6 中文版

说明

以下内容是结合很多资料进行编写的
源码为jdk1.8的
斜体样式 为自己的思考
下划线为自己所画的重点

String类

基本信息

java.lang
类 String

java.lang.Object
继承者 java.lang.String

所有已实现的接口：
Serializable, CharSequence, Comparable

public final class Stringextends Objectimplements Serializable, Comparable, CharSequenceString 类代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。

字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。例如：

String str = "abc";

等效于：

char data[] = {'a', 'b', 'c'};
 String str = new String(data);

下面给出了一些如何使用字符串的更多示例：

System.out.println("abc");
 String cde = "cde";
 System.out.println("abc" + cde);
 String c = "abc".substring(2,3);
 String d = cde.substring(1, 2);

String 类包括的方法可用于检查序列的单个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本并将所有字符全部转换为大写或小写。大小写映射基于 Character 类指定的 Unicode 标准版。

Java 语言提供对字符串串联符号（“+”）以及将其他对象转换为字符串的特殊支持。字符串串联是通过 StringBuilder（或 StringBuffer）类及其 append 方法实现的。字符串转换是通过 toString 方法实现的，该方法由 Object 类定义，并可被 Java 中的所有类继承。有关字符串串联和转换的更多信息，请参阅 Gosling、Joy 和 Steele 合著的 The Java Language Specification。

除非另行说明，否则将 null 参数传递给此类中的构造方法或方法将抛出 NullPointerException。

String 表示一个 UTF-16 格式的字符串，其中的增补字符 由代理项对 表示（有关详细信息，请参阅 Character 类中的 Unicode 字符表示形式）。索引值是指 char 代码单元，因此增补字符在 String 中占用两个位置。

String 类提供处理 Unicode 代码点（即字符）和 Unicode 代码单元（即 char 值）的方法。

从以下版本开始：
JDK1.0

另请参见：
Object.toString(), StringBuffer, StringBuilder, Charset, 序列化表格

属性

/** 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];

部分方法

charAt

public char charAt(int index)

返回指定索引处的 char 值。索引范围为从 0 到 length() - 1。序列的第一个 char 值位于索引 0 处，第二个位于索引 1 处，依此类推，这类似于数组索引。

如果索引指定的 char 值是代理项，则返回代理项值。

指定者：
接口 CharSequence 中的 charAt

参数：
index - char 值的索引。

返回：
此字符串指定索引处的 char 值。第一个 char 值位于索引 0 处。

抛出：
IndexOutOfBoundsException - 如果 index 参数为负或小于此字符串的长度。

public char charAt(int index) {
        if ((index < 0) || (index >= value.length)) {
            throw new StringIndexOutOfBoundsException(index);
        }
        return value[index];
    }

equals

public boolean equals(Object anObject)将此字符串与指定的对象比较。当且仅当该参数不为 null，并且是与此对象表示相同字符序列的 String 对象时，结果才为 true。

覆盖：
类 Object 中的 equals

参数：
anObject - 与此 String 进行比较的对象。

返回：
如果给定对象表示的 String 与此 String 相等，则返回 true；否则返回 false。

另请参见：
compareTo(String), equalsIgnoreCase(String)

public boolean equals(Object anObject) {
        if (this == anObject) {//如果对象==，直接返回true
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {//判断长度是否相同
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {//依次判断各个字符是否相同
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

getBytes

public byte[] getBytes()使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
当此字符串不能使用默认的字符集编码时，此方法的行为没有指定。如果需要对编码过程进行更多控制，则应该使用 CharsetEncoder 类。

返回：
所得 byte 数组

从以下版本开始：
JDK1.1

public byte[] getBytes() {
        return StringCoding.encode(value, 0, value.length);
    }

hashCode

public int hashCode()返回此字符串的哈希码。String 对象的哈希码根据以下公式计算：
s[0]*31^ (n-1) + s[1]*31^(n-2) + … + s[n-1]
使用 int 算法，这里 s[i] 是字符串的第 i 个字符，n 是字符串的长度，^ 表示求幂。（空字符串的哈希值为 0。）

覆盖：
类 Object 中的 hashCode

返回：
此对象的哈希码值。

另请参见：
Object.equals(java.lang.Object), Hashtable

public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

intern

public String intern()返回字符串对象的规范化表示形式。

一个初始为空的字符串池，它由类 String 私有地维护。

当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（用 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并返回此 String 对象的引用。

它遵循以下规则：对于任意两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true。

所有字面值字符串和字符串赋值常量表达式都使用 intern 方法进行操作。字符串字面值在 Java Language Specification 的 §3.10.5 定义。

返回：

一个字符串，内容与此字符串相同，但一定取自具有唯一字符串的池。

public native String intern();

matches

public boolean matches(String regex)告知此字符串是否匹配给定的正则表达式。
调用此方法的 str.matches(regex) 形式与以下表达式产生的结果完全相同：

Pattern.matches(regex, str)

参数：
regex - 用来匹配此字符串的正则表达式
返回：
当且仅当此字符串匹配给定的正则表达式时，返回 true
抛出：
PatternSyntaxException - 如果正则表达式的语法无效
从以下版本开始：
1.4
另请参见：
Pattern

split

public String[] split(String regex)根据给定正则表达式的匹配拆分此字符串。
该方法的作用就像是使用给定的表达式和限制参数 0 来调用两参数 split 方法。因此，所得数组中不包括结尾空字符串。

例如，字符串 “boo:and:foo” 使用这些表达式可生成以下结果：

{ “boo”, “and”, “foo” }

o { “b”, “”, “:and:f” }

参数：
regex - 定界正则表达式
返回：
字符串数组，它是根据给定正则表达式的匹配拆分此字符串确定的
抛出：
PatternSyntaxException - 如果正则表达式的语法无效
从以下版本开始：
1.4
另请参见：
Pattern

toCharArray

public char[] toCharArray()将此字符串转换为一个新的字符数组。

返回：
一个新分配的字符数组，它的长度是此字符串的长度，它的内容被初始化为包含此字符串表示的字符序列。

public char[] toCharArray() {
        // Cannot use Arrays.copyOf because of class initialization order issues
        char result[] = new char[value.length];
        System.arraycopy(value, 0, result, 0, value.length);
        return result;
    }

valueOf

从类 java.lang.Object 继承的方法

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

测试

package testlang;

/**
 * @author CSDN@日星月云
 * @date 2022/10/24 20:53
 */
public class TestString {
    public static void main(String[] args) {
        String str1 = new StringBuilder("58").append("tongcheng").toString();
        System.out.println(str1);
        System.out.println(str1.intern());
        System.out.println((str1 == str1.intern()));
        System.out.println();
        String str2 = new StringBuilder("ja").append("va").toString();
        System.out.println(str2);
        System.out.println(str2.intern());
        System.out.println((str2 == str2.intern()));

    }
    /*
     * 58tongcheng
     * 58tongcheng
     * true
     *
     * java
     * java
     * false
     */

    /**
     * String str1在方法里创建了一个变量，new StringBuilder(“58”)在堆内存中创建了对象，调用对象的append方法，把这个StringBuilder里的字符串加成了"58tongcheng"，然后调用toString创建并返回了一个String对象，这个返回的String对象仍然在堆内存里,str1指向了这个String对象。
     * 打印str1
     * 调用字符串的intern方法，前往常量池中查询是否存在这个字符串，发现没有存在，则将该字符串对象加入了常量池中，并返回了该字符串对象。（String对象，内容为：“58tongcheng”）
     * 判断str1和str1.intern()是否相等，也就是判断str1指向的对象和常量池中"58tongcheng"这个字符串对应的对象的地址是否相同，由于前面调用的时候把这个字符串对象加入进了常量池，因此这次返回的其实还是str1之前指向的那个String对象，判断这两个String对象地址是否相等返回true
     * 打印空行
     * String str2在方法里创建了一个变量，new StringBuilder(“ja”)在堆内存中创建了对象，调用对象的append方法，把这个StringBuilder里的字符串加成了"java"，然后调用toString创建并返回了一个String对象，这个返回的String对象仍然在堆内存里,str1指向了这个String对象。
     * 打印str1
     * 调用字符串的intern方法，前往常量池中查询是否存在这个字符串，发现存在，存在的原因是，java默认加载了java.lang包下的所有类，而String类就在这个包下，因此加载类的时候这个java字符串是一个包名，已经被加载进了String类的静态常量池了，那么这次打印的是常量池中的"java"字符串对应的String对象。（String对象，内容为：“java”）
     * 判断str1和str1.intern()是否相等，也就是判断str1指向的对象和常量池中"java"这个字符串对应的对象的地址是否相同，由于前面调用的时候这个字符串对象是新创建的存在于堆内存中的，调用intern方法返回的String对象是之前在加载java.lang下的String类时就已经被加载进了String类的常量池了的，因此两个String对象内存地址不相等返回false。
     * ————————————————
    
     */
}

另外

​​String类​​

String类基础

package com.day0209_1;

import org.junit.Test;

/**
 *String的使用
 */
public class StringTest {

    /*
    String的实例化方式
    方式一：通过字面量定义的方式
    方式二：通过new+构造器的方式

    面试题：String s =new String("abc");方式创建对象，在内存中创建了几个对象？
            两个：一个是堆空间中new结构，另一个是char[]对应的常量池中的数据："abc"

     */
    @Test
    public void test2(){

        //通过字面量定义的方式：此时的s1和s2的数据JavaEE声明在方法区中的字符串常量池中。
        String s1="javaEE";
        String s2="javaEE";
        //通过new+构造器的方式：此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
        String s3=new String("javaEE");
        String s4=new String("javaEE");

        System.out.println(s1==s2);//true
        System.out.println(s1==s3);//false
        System.out.println(s1==s4);//false
        System.out.println(s3==s4);//false

        System.out.println("**********");
        Person p1=new Person("Tom",12);
        Person p2=new Person("Tom",12);

        System.out.println(p1.name.equals(p2.name));//true
        System.out.println(p1.name==p2.name);//true

        p1.name="Jerry";
        System.out.println(p2.name);//Tom


    }


    /*
    String：字符串，使用一对“”引起来表示
    1.String声明为final的，不可被继承
    2.String实现了Serializable接口：表示字符串是支持序列化的。
            实现了Comparable接口：表示String可以比较大小
    3.String内部定义了final char[] value用于符串数据
    4.String：代表不可变的字符序列。简称：不可变性。
        体现：1.当对字符串重新赋值时，需要重新指定内存区存储字域赋值，不能使用原有的Value进行赋值。
             2.当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的Value进行赋值。
             3.当调用String的replace()方法修改指定的字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的Value进行赋值。
    5.通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。
    6.字符串常量池中是不会存储相同内容的字符串的。

     */
    @Test
    public void test1(){
        String s1="abc";//字面量
        String s2="abc";
//        s1="hello";

        System.out.println(s1 == s2);//比较s1和s2的地址值

        System.out.println(s1);//hello
        System.out.println(s2);//abc

        System.out.println("************");

        String s3="abc";
        s3+="def";
        System.out.println(s3);//abcdef
        System.out.println(s2);//abc

        String s4="abc";
        String s5 = s4.replace('a', 'm');

        System.out.println(s4);//abc
        System.out.println(s5);//mbc




    }
}

String类常用方法

package com.obj.test.string;

public class Test1 {
    public static void main(String[] args) {
        String str1 = new String("abcdefg");
        String str2 ="abcdefg";
        String str3 ="abcdEFG";
        String str4 = "def";

        System.out.println(str1==str2); //false
        System.out.println(str1);
        System.out.println(str2);
        //设计到字符串比较的时候，都用equals方法
        System.out.println(str1.equals(str2));  //true
        System.out.println(str1.length());      //7
        //
        System.out.println(str2.charAt(0));
        System.out.println(str2.charAt(6));     //str2.length-com.1
        System.out.println(str1.charAt(str2.length()-1));    //取字符串最后一个字符
        System.out.println(str2.equals(str3));
        System.out.println(str2.equalsIgnoreCase(str3));        //忽略大小写

        //从开头到结尾查找，返回找到的第一个子字符串位置。如未找到，返回-com.1
        System.out.println(str2.indexOf("def"));    //结果：3 //str2="abcdefg"
        System.out.println("abcdefg".indexOf("DF"));     //结果：-com.1
        //从末尾开始查找
        System.out.println("abcdefgdefg".lastIndexOf("def"));    //结果：7

        //字符串的替换
        String str5 = "abcdefg".replace('d','p');
        System.out.println(str5);
        String str6 = "abcdbcd".replace("cd","HELLO");
        System.out.println(str6);       //abHELLObHELLO



        System.out.println("sxt,i love u".startsWith("sxt"));//true
        System.out.println("sxt,i love u".endsWith("sxt"));//false

        //截取字符串
        String str7 = "abcdefghijklmnopqrstuvwxyz".substring(6);
        System.out.println(str7);       //ghijklmnopqrstuvwxyz
        String str8 = "abcdefghijklmnopqrstuvwxyz".substring(6,11);//6--（11-com.1）包头不包尾
        System.out.println(str8);       //ghijk

        System.out.println("abcdE".toUpperCase());//变大写
        System.out.println("abcdE".toLowerCase());//变小写

        String str9 = "  a b  ";//长度7 //用户名：gaoqi
        String str10=str9.trim();//去除首尾空格
        System.out.println(str10.length());
        System.out.println(str10);

        //String是不可变字符序列。所有的替换、截取子字符串、去空格、转换大小写等都是生成新字符串
        System.out.println(str9.replace(" ",""));//去空格
        System.out.println(str9);
    }
}

String类与其他类的转换

package com.day0216_1;

import org.junit.jupiter.api.Test;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

/**
 * 涉及到String类与其他类的转换
 */
public class StringTest1 {

    /*
    String与byte[]之间的转换

    编码：String-->byte[]:调用String的getBytes()
    解码：byte[]-->String:调用String的构造器
     */
    @Test
    public void test3() throws UnsupportedEncodingException {

        String str1="abc123中国";
        byte[] bytes = str1.getBytes();//使用默认的字符集，进行编码//UTF-8
        System.out.println(Arrays.toString(bytes));

        byte[] gbks=str1.getBytes("gbk");//使用gbk的字符集，进行编码
        System.out.println(Arrays.toString(gbks));

        System.out.println("*****************");

        String str2 = new String(bytes);//使用默认的字符集，进行解码//UTF-8
        System.out.println(str2);

        String str3 = new String(gbks);
        System.out.println(str3);//出现乱码，原因是编码集与解码集不一致！

        String str4 = new String(gbks, "gbk");
        System.out.println(str4);//没有出现乱码，原因是编码集与解码集一致！


    }



    /*
    String与char[]之间的转换

    String-->char[]:调用String的toCharArray()
    char[]-->String:调用String的构造器
     */
    @Test
    public void test2(){
        String str1="abc123";
        char[] charArray = str1.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            System.out.println(charArray[i]);
        }

        char[] arr=new char[]{'h','e','l','l','o'};
        String str2 = new String(arr);
        System.out.println(str2);
    }



    /*
    复习：
    String 与基本数据类型、包装类之间的转换。

    String -->基本数据类型、包装类:调用包装类的静态方法：parseXxx(str)
    基本数据类型、包装类--> String:调用String重载的ValueOf(xxx)
    */
    @Test
    public void test1(){
        String str1="123";//字符串常量池中
        int num=Integer.parseInt(str1);

        String str2=String.valueOf(num);//"123"
        String str3=num+"";//堆中

        System.out.println(str1=str3);//false

    }

}

总结

关键词：

• 常用方法
• intern

最后

开源=为爱发电