目录
一、String类概述
java.lang.String 类代表字符串。String类中包含很多字符串方法，比如比较、搜索、提取等。
特点
1、String类是被final修饰的，所以字符串的值在创建后不能被更改,能改的是引用指向
String s1 = "abc";
s1 += "d"; // 或者 s1 = "abcd";
System.out.println(s1); // "abcd"
// 内存中有"abc"，"abcd"两个对象，s1从指向"abc"，改变指向，指向了"abcd"。
2、因为String对象是不可变的，所以它们可以被共享
String s1 = "abc";
String s2 = "abc";
// 内存中只有一个"abc"对象被创建，同时被s1和s2共享
3、 String底层是靠字符数组实现的，"abc" 等效于 char[] data={ 'a' , 'b' , 'c' } 。
String str = "abc";
相当于：
char data[] = {'a', 'b', 'c'};
String str = new String(data);
二、字符串的构造方法
public static void main(String[] args) {
char[] arr= {'n','a','c','b','t'};
// 第2和3个参数不能越界，否则会报越界异常
String s1 = new String(arr,1,3);
System.out.println(s1); // acb
String s2 = new String(s1);
System.out.println(s1); // acb
}
| 1 | String() |
| 2 | String(byte[] bytes) |
| 3 | String(byte[] bytes, int offset, int length) |
| 4 | String(char[] value) |
| 5 | String(char[] value, int offset, int count) |
| 6 | String(String original) |
| 7 | String(StringBuffer buffer） |
三、常用方法
获取字符串的子串
String str1 = newString("asdfzxc");
String str2 = str1.substring(2);//str2 ="dfzxc"
String str3 = str1.substring(2,5);//str3 ="dfz"
获取下标位置上的字符
String s = "www.runoob.com";
char result = s.charAt(6);
System.out.println(result); // n
获取首个字符的索引
String str1="012345";
String str2="23";
System.out.println( str1.indexOf(str2) ); // 2
获取首个字符的索引(从指定位置开始查)
String str1="012345012345";
String str2="23";
System.out.println( str1.indexOf(str2,5) ); // 8
String Str = new String("菜鸟教程:www.runoob.com");
String SubStr1 = new String("runoob");
String SubStr2 = new String("com");
System.out.print("查找字符 o 最后出现的位置 :" );
System.out.println(Str.lastIndexOf( 'o' )); // 17
System.out.print("从第14个位置查找字符 o 最后出现的位置 :" );
System.out.println(Str.lastIndexOf( 'o', 14 )); // 13
System.out.print("从第十五个位置开始搜索子字符串 SubStr1最后出现的位置 :" );
System.out.println( Str.lastIndexOf( SubStr1, 15 )); //9|
1 | public int length() | 字符串长度 |
| 2 | public char charAt(int index) | 获取某个位置对应的字符 |
| 3 | public String substring(int beginIndex) | 提取子串 |
| 4 | public String substring(int beginIndex, intendIndex) | |
| 5 | public int indexOf(String str) | 返回子串在此字符串第一次出现的位置 |
| 6 | public int indexOf(String str, intfromIndex) | |
| 7 | public int lastIndexOf(String str) | |
| 8 | public int lastIndexOf(String str, intfromIndex) | |
| 9 | indexOf(int ch) | 返回指定字符在此字符串中第一次出现处的索引。 |
| 10 | public boolean equals(Object obj) | 比较当前字符串和参数字符串，在两个字符串相等的时候返回true，否则返回false |
| 11 | public boolean equalsIgnoreCase(String str) | 忽略大小写 |
删除头尾空白
String Str = new String(" www.runoob.com ");
System.out.print("删除头尾空白 :" );
System.out.println( Str.trim() );// "www.runoob.com"
String str = new String("Welcome-to-Runoob");
System.out.println("- 分隔符返回值 :" );
for (String retval: str.split("-")){
System.out.println(retval);
}
// 结果
Welcome
to
Runoob
System.out.println("- 分隔符设置分割份数返回值 :" );
for (String retval: str.split("-", 2)){
System.out.println(retval);
}
// 结果
Welcome
to-Runoob
字符串转换为字符数组
String str = "Java Programming";
//创建一个char数组
char[] result;
result = str.toCharArray();
System.out.println(result); // Java Programming
格式化字符串
String str = String.format("%d",400/2); //200
String str2 = String.format("%b",3>5); //false
转化为字节数组
String str = "Java";
byte[] byteArray;
//将字符串转换为字节数组
//使用平台的默认字符集
byteArray = str.getBytes();
System.out.println(Arrays.toString(byteArray)); // [74, 97, 118, 97]
| 1 | String trim() | 字符串两端去空格 |
| 2 | String[] split(String str) | 将字符串分割成字符串数组 |
| 3 | char[] toCharArray() | 将此字符串转换为一个新的字符数组。 |
| 4 | public boolean contains(CharSequence s) | 当且仅当此字符串包含指定的 char 值序列时，返回 true。 |
| 5 | public boolean endsWith(String suffix) | 字符串是否以指定的后缀结束。 |
| 6 | public boolean startsWith(String prefix) | 字符串是否以指定的前缀开始。 |
| 7 | public boolean isEmpty() | 当且仅当 length() 为 0 时返回 true |
| 8 | 字符串拼接 | |
| 9 | 格式化 | |
| 10 | public byte[] getBytes() | 将结果存储到一个新的 byte 数组中
|
int a = 5;
long l = -2343834L;
float f = 23.4f;
double d = 923.234d;
//将数字转换为字符串
System.out.println(String.valueOf(a)); // "5"
System.out.println(String.valueOf(l)); // "-2343834"
System.out.println(String.valueOf(f)); // "23.4"
System.out.println(String.valueOf(d)); // "923.234"| 1 | public String toLowerCase(） | 转为小写 |
| 2 | public String toUpperCase() | 转为大写 |
| 3 | public String replace(char oldChar, char newChar) | 用字符newChar替换当前字符串中所有的oldChar字符， 并返回一个新的字符串。 |
| 4 | public String replaceFirst(String regex,String replacement) | 该方法用字符replacement的内容替换当前字符串中遇到的 第一个和字符串regex相匹配的子串，应将新的字符串返回。 |
| 5 | public String replaceAll(String regex,String replacement) | 该方法用字符replacement的内容替换当前字符串中遇到的所有 和字符串regex相匹配的子串，应将新的字符串返回 |
| 6 | static String valueOf(boolean b) | 返回 boolean 参数的字符串表示形式。 |
| static String valueOf(char c) | ||
| static String valueOf(char[] data) | ||
| static String valueOf(char[] data, int offset, int count) | ||
| static String valueOf(double d) | ||
| static String valueOf(float f) | ||
| static String valueOf(int i) | ||
| static String valueOf(long l) | ||
| static String valueOf(Object obj) |
|
1四、关于常量池的分类
1、class文件常量池
2、运行时常量池：
类加载器会加载对应的Class文件，class文件中的常量池会在类加载后进入方法区中的运行时常量池。
运行时常量池是全局共享的，多个类共用一个运行时常量池。并且class文件中常量池多个相同的字符串在运行时常量池只会存在一份。
注意运行时常量池存在于方法区中
3、 字符串常量池：
常量池中的文本字符串会在类加载时进入字符串常量池，字符串常量池存在于运行时常量池中。也就存在于方法区中。
不过JDK1.7时，字符串常量池就被移出了方法区，转移到了堆里了。
那么我们可以推断，JDK1.7以及之后的版本中，运行时常量池并没有包含字符串常量池，运行时常量池存在于方法区中，
而字符串常量池存在于堆中。
相关问题细节解析
String str1 = new String("abc");
str1.intern();
String str2 = "abc";
System.out.println(str1 == str2); // 结果是什么第一行分析：
创建了两个对象，在执行前会在常量池中创建一个"abc"的对象，然后执行该行代码时new一个"abc"的对象存放在堆中；
然后str1引用指向堆中的对象；
第二行分析：
该行代码首先查看"abc"字符串有没有存在在常量池中，存在则直接返回该常量，不存在会把堆中该对象的引用放在常量池中
第三行分析：
"abc"已经存在在常量池中，str2指向常量池中的对象；
第四行分析
str1指向堆区的对象，str2指向常量池中的对象，两个引用指向的地址不同，结果为false；
String str3 = new String("a") + new String("a");
str3 .intern();
String str4 = "aa";
System.out.println(str3 == str4);第一行分析：先使用StringBuffer的append方法将"a"和"a"进行拼接，然后调用toString方法new出“aa”；
所以字符串"aa" 在堆中创建,str3指向堆空间
第二行分析：此行代码执行时字符串常量池中没有"aa",会把堆中该对象的引用放在常量池中
第三行分析：此时的str4会指向堆区；
第四行分析 : 结果为true
1、 String str1 = "aaa";
str1指向方法区；
2、 String str2 = "bbb";
str2 指向方法区
3、 String str3 = "aaabbb";
str3指向方法区
4、 String str4 = str1 + str2;
str4指向堆区
5、 String str5 = "aaa" + "bbb";
这里jvm对其有优化处理，在编译阶段就会将这两个字符串常量进行拼接，也就是"aaabbb";
所以str5 指向方法区中的；
6、 System.out.println(str3 == str4);
结果为false， 一个指向堆 一个指向方法区
7、 System.out.println(str3 == str4.intern());
str4.intern会把“aaabbb”放在堆区，所以结果是false
8、System.out.println(str3 == str5);
都指向字符串常量区，字符串长常量区在方法区，相同的字符串只存在一份，结果为truetring t1 = new String("2");
创建了两个对象，t1指向堆区
String t2 = "2";
t2指向字符串常量池
t1.intern();
字符串常量池已经存在该字符串，直接返回"2"；
System.out.println(t1 == t2);
结果为false
String t3 = new String("2") + new String("2");
t3指向堆区
String t4 = "22";
t4指向方法区
t3.intern();
字符串常量池中已经存在该字符串 直接返回"22"
System.out.println(t3 == t4);
结果为false Integer a = 1;
Integer b = 2;
Integer c = 3;
Integer d = 3;
Integer e = 321;
Integer f = 321;
Long g = 3L;
System.out.println(c == d); // true
System.out.println(e == f); // false
System.out.println(c == (a + b)); // true
System.out.println(c.equals(a+b)); // true
System.out.println(g == (a + b)); // true
System.out.println(g.equals(a + b)); // false
知识点
1、内存中有一个java基本类型封装类的常量池。这些类包括Byte, Short, Integer, Long, Character, Boolean。需要注意的是，Float和Double这两个类并没有对应的常量池。
2、上面5种整型的包装类的对象是存在范围限定的；范围在-128~127存在在常量池，范围以外则在堆区进行分配。
3、Long的equals方法会先判断是否是Long类型
4、无论是Integer还是Long，他们的equals方法比较的是数值
5、包装类的“==”运行符在没有遇到算术运算的情况下不会自动拆箱，以及他们的equals()方法不处理数据类型的关系
System.out.println(c == d)。
由于常量池的作用，c与d指向的是同一个对象(注意此时的==比较的是对象，也就是地址，而不是数值)。
因此为true
System.out.println(e == f)。
由于321超过了127，因此常量池失去了作用，所以e和f数值虽然相同，但不是同一个对象，以此为false。
System.out.println(c == (a+b))。
此时==两边有算术运算，会进行拆箱，因此此时比较的是数值，而并非对象。因此为true。
System.out.println(c.equals(a+b))
c与a+b的数值相等，为true。
System.out.pirnln(g == (a + b))
由于==两边有算术运算，所以比较的是数值，因此为true。
System.out.println(g.equals(a+b))。
Long类型的equal在比较是时候，会先判断a+b是否为Long类型，显然a+b不是，因此false
intern()函数
先判断字符串常量是否在字符串常量池中，如果存在直接返回该常量，如果没有找到，说明该字符串常量在堆中，则处理是把堆区该对象的引用加入到字符串常量池中，以后别人拿到的是该字符串常量的引用，实际存在堆中；
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
