前言
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” 使用这些表达式可生成以下结果：
Regex 结果
{ “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。 * ———————————————— * 版权声明：本文为CSDN博主「HumoChen99」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 * 原文链接：https://blog.csdn.net/HumorChen99/article/details/117509952 */ }
另外
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
最后
开源=为爱发电
