💕"不要同情自己，同情自己是卑劣懦夫的勾当！"💕
作者：Mylvzi
文章主要内容：JavaSE学习值之--String类
目录
1.String类有求字符串长度的方法通过：str.length()
2.indexOf方法，lastIndexOf 方法--》不止一个，有多个，构成了方法的重载
2.大小写互换--》toUpperCase toLowerCase
1.split方法--》返回值是String[],所以要用字符串数组接收
2.所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象
二.StringBuilder和StringBuffer的介绍
2.setCharAt(int index, char ch)-->将index位置的字符重置为ch
3.insert(int offset, String str) -->在offset位置插入：八种基类类型 & String类型 & Object类型数据
4.deleteCharAt(int index)--》删除index位置字符
5.replace(int start, int end, String str)--》将指定区间的字符串设置为str
6.StringBuffer reverse()-->倒置字符串
7.toString方法-->以字符串（String）类型返回
前言：
在C语言中我们已经接触过字符串，在C语言中不存在字符串类型，存储字符串往往是通过字符数组或字符指针，同时C语言的库中也提供了很多与字符串有关的函数，如strcpy,strcat,strstr等等，但是这种将数据和操作方法分割的做法不符合面向对象编程的思想，所以在Java中提供了字符串类型--》String
String类本质上是class,含有属性和方法，方法之中存放了大量且实用的与字符串有关的方法
下面就为大家详细讲解String类
一.String类
1.String类的属性
注意：Java中的字符串区别于C语言，并不存在“字符串以\0结尾”这种说法
2.字符串的构造
下面介绍常见的三种字符串构造方法：
/**
* 字符串构造
*/
// 1.直接构造
String str1 = "hello";
System.out.println(str1);
// 2.实例化一个String类对象
String str2 = new String("hello");
System.out.println(str2);
// 3.通过字符数组的转化
char[] arr = {'h','e','l','l','o'};
String str3 = new String(arr);
System.out.println(str3);注意Java中String类是一种引用数据类型，存放的引用对象的地址，而不存储对象本身
// String类是一种引用类型，存储的是对象的地址
// s1和s2引用的是不同对象 s1和s3引用的是同一对象
String s1 = new String("hello");
String s2 = new String("world");
String s3 = s1;
System.out.println(s1.length()); // 获取字符串长度---输出5
System.out.println(s1.isEmpty()); // 如果字符串长度为0，返回true，否则返回false
注意：
1.String类有求字符串长度的方法通过：str.length()
STtring类里面的length是一种方法，数组里面的是一种属性，方法有一个（）；
2.isEmpty方法用于判断字符串的长度是否为0
注意isEmpty判断的是字符串的长度，如果字符串是null,此时代表空引用，编译器会报错
String s1 = "";
System.out.println(s1.length());// 输出0
String s2 = null;
System.out.println(s2.length());// 报错
3.被" "引起来的就是字符串，可直接调用方法
System.out.println("hello".length());// 输出53.String类对象的比较
1.==判断是否是同一引用（地址相同)
==
左右两边都是基本数据类型，比较的是值的大小，根据值是否相等返回false/true
左右两边都是引用数据类型，比较的是引用对象的地址是否相同，也就是是否是同一引用
// String类是一种引用类型，存储的是对象的地址
// s1和s2引用的是不同对象 s1和s3引用的是同一对象
String s1 = new String("hello");
String s2 = new String("world");
String s3 = s1;
System.out.println(s1 == s2);// false
System.out.println(s2 == s3);// false
System.out.println(s1 == s3);// true来看一种特殊情况：
当我们直接引用字符串”hello“ 时，str1和str2却相等了？这是为什么？引用类型比较的不是地址吗？是的，比较的是地址。但对于"hello"这样的字符串来说，他是存储在堆区之中的”常量池“上，地址是固定的。也就是说，当第一次使用hello给str1赋值后，常量区上就已经存放了hello这个字符串，再次赋值是会先从常量池中的"hello"获取，获取的和str1是一样的"hello"(地址和值都是一样的)
2.equals 方法
==只能用来比较两个引用对象的地址是否相同，而大多数情况下我们是通过引用类型的内容来判断是否相等的，对于String类来说也是这样的，我们要比较的是字符串的具体内容，而String类中有一个自带的比较内容的方法-->equals(本质还是继承于Object类的
)
String str1 = "hello";
String str2 = "hello";
String str3 = "world";
System.out.println(str1.equals(str2));// true
System.out.println(str1.equals(str3));// false总结：
equals方法用来判断两个字符串的内容是否相同
3.compareTo以及他的接口
再来看String类的定义：
可以看见String类实现了Comparable接口，所以就要重写接口中的compareTo方法
比较思路：
如果两个字符串的长度不一样，先比较长度相同的部分，如果长度相同部分完全相同，则直接返回长度的差值（共同长度是最短字符串的长度）
代码示例：
String str1 = "hello";
String str2 = "hello";
String str3 = "world";
String str4 = "helloworld";
System.out.println(str3.compareTo(str1));// 15
System.out.println(str1.compareTo(str2));// 0
System.out.println(str4.compareTo(str1));// 输出5
System.out.println("====================");
String str5 = "abc";
String str6 = "acc";
System.out.println(str5.compareTo(str6));// 输出-1compareToIgnoreCase方法
在一些情况下，我们认为大写和小写只是形式上的不同，内容却是相同的，比如"hello"=="HELLO",在不考虑大小写的情况下进行比较，就可以利用方法
compareToIgnoreCase
String str1 = "hello";
String str2 = "HELLO";
String str3 = "HEllo";
System.out.println(str1.compareToIgnoreCase(str2));// 0
System.out.println(str1.compareToIgnoreCase(str3));// 0总结：
1.compareTo方法返回的Int类型的数据，本质上是对应字符串在字典上的顺序（字典中，前面的字母是小的，后面的字母大，小写比所有大写大）2.忽略大小写带来的形式上的不同，我们可以利用compareToIgnoreCase方法
3.自定义类型一定要重写equals方法和hashcode方法，因为你的逻辑是根据自定义类型的内容进行比较的
4. 字符串查找
字符串查找也是字符串中非常常见的用法，String类中也提供了很多字符串查找的方法
1.charAt方法--》返回对应索引上的字符
String str1 = "abcdef";
System.out.println(str1.charAt(0));// 输出a
System.out.println(str1.charAt(1));// 输出b
System.out.println(str1.charAt(2));// 输出c
System.out.println(str1.charAt(-1));// 异常
System.out.println(str1.charAt(100));// 异常2.indexOf方法，lastIndexOf 方法--》不止一个，有多个，构成了方法的重载
1.单个字符（从前往后找）
String str1 = "abcdefghcde";
System.out.println(str1.indexOf('a'));// 0
System.out.println(str1.indexOf('b'));// 1
System.out.println(str1.indexOf('c'));// 2
System.out.println("==================");
System.out.println("从指定index开始访问");
System.out.println(str1.indexOf('c', 3));// 8 返回的是第二个c出现的位置
System.out.println(str1.indexOf('a', 1));// -1 1代表从b开始，后面不含有a
System.out.println("==================");
System.out.println("从后往前找");
System.out.println(str1.lastIndexOf('c'));// 8
System.out.println(str1.lastIndexOf('e'));// 10
System.out.println(str1.lastIndexOf('c', 4));// 2 
注意：indexOf方法只返回第一次出现的下标（从左往右）
2.查找子字符串（从前往后找）
String str1 = "abcdefghcde";
// 返回子字符串第一次出现位置的下标
System.out.println(str1.indexOf("ab"));
System.out.println(str1.indexOf("cd"));
System.out.println(str1.indexOf("de"));
System.out.println("===================");
System.out.println("从指定索引位置之后返回子字符串出现的位置");
System.out.println(str1.indexOf("cd", 4));// 8
System.out.println(str1.indexOf("de",6));// 9
System.out.println("===================");
System.out.println("从后往前查找");
/**
* 注意返回都是第一个字符的下标
*/
System.out.println(str1.lastIndexOf("cd"));// 8
System.out.println(str1.lastIndexOf("de"));// 9
System.out.println(str1.lastIndexOf("cd", 5));// 25.字符串的转化
1.数值和字符串之间的转化
class Student {
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}
public class Test1 {
public static void main(String[] args) {
/**
* 其他类型转字符串（布尔类型和引用类型也能转化）
* String.valueOf方法
*/
String s1 = String.valueOf(1234);
String s2 = String.valueOf(12.34);
String s3 = String.valueOf(true);
String s4 = String.valueOf(new Student("Hanmeimei", 18));
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println(s4);
System.out.println("=======================");
/**
* 字符串转其他类型
* 通过其他类型的包装类中的parse方法
*/
int a = Integer.parseInt("12345");
double b = Double.parseDouble("12.20");
boolean c = Boolean.parseBoolean("true");
System.out.println(a);
System.out.println(b);
System.out.println(c);
2.大小写互换--》toUpperCase toLowerCase
String str1 = "hello";
String str2 = "WROLD";
String str3 = "Hello";
// 小写转大写
System.out.println(str1.toUpperCase());
// 大写转小写
System.out.println(str2.toLowerCase());
System.out.println(str3.toLowerCase());
3.. 字符串转数组
String str1 = "hello";
char[] value = str1.toCharArray();
for (int i = 0; i < value.length ; i++) {
System.out.print(value[i] + " ");
}
System.out.println();
System.out.println("====================");
// 字符数组转字符串（字符串的构造）
char[] value2 = {'h','e','l','l','o'};
String str2 = new String(value2);
System.out.println(str2); 
4. 格式化（以特定的格式输出字符串）
String s = String.format("%d-%d-%d", 2019, 9,14);
System.out.println(s);// 输出2019-9-146.字符串替换
用另一个字符串代替当前字符串中的某些内容
String str1 = "hello world";
// 单个字符替换
System.out.println(str1.replace('o', 'x'));// hellx wxrld 两个o都被替换了
// 字符串替换
System.out.println(str1.replace("hello", "xxxxxxx"));
// 替换首个位置
// replaceFirst的参数只能是字符串
System.out.println(str1.replaceFirst("o","x"));// hellx world 只替换第一个o
// replaceAll 用于基于正则表达式的文本替换
System.out.println(str1.replaceAll("o", "x"));
// replace的返回值是一个新的字符串，不是对原字符串进行修改
// java中字符串是常量，无法被修改
String str2 = str1.replace('e','d');7.字符串的拆分
1.split方法--》返回值是String[],所以要用字符串数组接收
String str1 = "how are you man?";
String[] value = str1.split(" ");
for (String s:value) {
System.out.println(s);
}
System.out.println("===================");
// 就分两组
String[] value2 = str1.split(" ",2);
for (String s:value2) {
System.out.println(s);
} 
2.特殊字符的拆分
在使用split方法时，传递的参数是字符，但是有些字符本身就有特定的作用（+-*\等等），需要使用转义字符进行转义
1.拆分IP地址
String str = "192.168.1.1" ;
String[] result = str.split("\\.") ;
for(String s: result) {
System.out.println(s);
}
1. 字符"|","*","+"都得加上转义字符，前面加上 "\\" .
2. 而如果是 "\" ，那么就得写成 "\\\\" .
3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符
String str = "192\\168\\1\\1" ;// 在字符串中使用\需要先进行转义
String[] result = str.split("\\\\") ;
for(String s: result) {
System.out.println(s);
}2.多次分割（开发常用）
在进行分割时，一个字符串内往往含有多个不同的符号，一次split只能以一个符号进行分割，如果想实现多次分割，可以利用嵌套的for循环进行多次分割
public static void main(String[] args) {
String str = "name=李四&age=17";
String[] arr1 = str.split("&");
for (int i = 0; i <arr1.length ; i++) {
String[] tmp = arr1[i].split("=");
System.out.println(tmp[0]+" = "+ tmp[1]);
}
}
7.字符串截取
从当前字符串某个索引位置处进行截取
String str = "helloworld";
System.out.println(str.substring(5));// 输出world
System.out.println(str.substring(0, 5));// 输出hello java中的区间都是左闭右开的注意事项：
1. 索引从0开始
2. 注意前闭后开区间的写法, substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标
8.其他操作方法
1.trim方法：
代码示例：
String str = " hello world ！！！！！！！！！";
System.out.println(str.trim());
注意：
1.trim方法只能去除字符串左右两边的空格，中间的空格无法删除
2.trim方法其实在搜索引擎中经常出现，比如你故意在搜索时在前面添加了一大堆的空格，而你在搜索的时候，浏览器会自动把字符前面的所有空格进行删除，这就是调用了trim方法
8.字符串的不可变性
String类型的数据是一种不可改变的数据类型，来看她的定义
1.这张图能反应很多信息：
1.String类被final修饰，代表不能被其他类继承
2.字符串实际上是存储在Value数组之中的，value也是一种引用类型
3.value数组被private修饰，代表无法在类外使用该数组，也就证明该数组的内容无法改变，也就是字符串的内容无法改变
一个误区：
很多人说String类无法改变是因为value数组被final修饰，这是错误的，因为value数组被final修饰，只能说明value不能指向其他的引用，但是其所指向的对象是可以改变的（类似于const char*）
final int[] arr = {1,2,3,4,5};
arr[0] = 10000;
System.out.println(Arrays.toString(arr));
2.所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象
StringBuilder也是与字符串相关的一个类，其中有一个append方法，用于字符串的追加
可以发现，在对字符串s进行追加时，实际上是又重新创建了一个字符串，使这个字符串为两个字符串append之后的结果，最后再将这个字符串重新赋值给s
二.StringBuilder和StringBuffer的介绍
前言：
由于stirng的不可改变性，对于字符串的操作有了一定的限制，为了更加方便地操作字符串，引入两个新的类：StringBuilder和StringBuffer，这两个类的基本用法一致
一.StringBuilder
常见方法总结：
1.append--》字符串追加
//StringBuilder是一个类，必须先进行实例化对象
StringBuilder str = new StringBuilder("hello");
StringBuilder str2 = str;
// 利用append进行追加 可追加字符，数字，字符串
str.append(' ');
str.append(123);
str.append("world");
str.append('!');
System.out.println(str);注意：
1.append方法的存在大大提高了新建字符串的效率，因为append方法在执行的时候是直接在位于缓冲区的字符数组之后添加字符的，并没有新建临时对象，减少了内存的不必要开辟和释放
2.可直接打印StringBuilder类的对象，因为其内部重写了toString方法
2.setCharAt(int index, char ch)-->将index位置的字符重置为ch
StringBuilder str = new StringBuilder("hello");
str.setCharAt(0,'!');
str.setCharAt(1,'!');
str.setCharAt(2,'!');
System.out.println(str);
3.insert(int offset, String str) -->在offset位置插入：八种基类类型 & String类型 & Object类型数据
StringBuilder str = new StringBuilder("hello");
// insert方法
// 并没有删除原位置的字符，而是在其之前插入另一个数据
str.insert(0,'!');
System.out.println(str);// !hello
str.insert(6,"world");
System.out.println(str);// !helloworld
str.insert(0,123456);
System.out.println(str);// 123456!helloworld注意： insert方法并没有删除原位置的字符，而是在其之前插入另一个数据
4.deleteCharAt(int index)--》删除index位置字符
StringBuilder str = new StringBuilder("hello");
System.out.println(str.deleteCharAt(0));// ello
System.out.println(str.deleteCharAt(0));// llo
// delete 删除指定区间内的所有字符
StringBuilder str2 = new StringBuilder("hello");
System.out.println(str2.delete(0, 2));// llo5.replace(int start, int end, String str)--》将指定区间的字符串设置为str
StringBuilder str = new StringBuilder("hello!!!!");
str.replace(1,6,"world");
System.out.println(str);// hworld!!!6.StringBuffer reverse()-->倒置字符串
StringBuilder str = new StringBuilder("hello!!!!world");
System.out.println(str.reverse());// dlrow!!!!olleh这是一个非常有用 的方法，在很多刷题网站中都有倒置字符串的实现，通过S听Builder自带的reverse方法可以快速实现！！！
源码：
public AbstractStringBuilder reverse() {
boolean hasSurrogates = false;
int n = count - 1;
for (int j = (n-1) >> 1; j >= 0; j--) {
int k = n - j;
char cj = value[j];
char ck = value[k];
value[j] = ck;
value[k] = cj;
if (Character.isSurrogate(cj) ||
Character.isSurrogate(ck)) {
hasSurrogates = true;
}
}
if (hasSurrogates) {
reverseAllValidSurrogatePairs();
}
return this;
}7.toString方法-->以字符串（String）类型返回
String和StringBuffer不能直接赋值，必须通过StringBuffer的toString方法才能转换
StringBuilder str = new StringBuilder("hello!!!!world");
// String str2 = str;// err
String newstr = str.toString();
System.out.println(newstr);// hello!!!!worldStringBuilder和StringBuffer也包含String类型中常见的方法，如indexOf,charAt,substring,length等方法，其用法和String类基本一致，此处不再详细阐述
总结：
String类是一个非常常用的类，要掌握其包含的常见方法的使用，深入理解String不能被改变和继承的原因；同时为了解决String类的一些缺陷，引入了两个新的类 StringBuilder和StringBuffer，这两个类可以看作String类的更高效的版本，其中有很多方法与String类重合，但也有很多自己独有的，非常有效的方法，了解这些方法会大大提高我们的开发效率！！！
三.再谈String类
1.字符串常量池
呃呃，笔者经过进一步的学习又了解到了关于String类的相关知识，在这里进行更多的补充
先来看一下String的源码
在Java中String是一个类，每个String对象都有两个属性 value和hash ，value就是存储的值，hash就是对象对应的hash值
再来看下述代码
String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
String s4 = new String("hello");;
System.out.println(s1 == s2);// true
System.out.println(s3 == s4);// false为什么s1和s2就相等呢？对象的比较不是根据对象的地址进行判断的么？在这里，引入一个概念--字符串常量池
在Java中，所有被""引起来的都叫做字符串常量，所有的字符串都是存储到Java中一个名叫”字符串常量池“的存储区域中，但是官方并没有这个概念，而是使用一个叫做StringPool的方法将字符串常量存储起来，而StringPool的底层其实是StringTable，它是由哈希表实现的（使用c++编写）。
1.String s1 = "hello";这句代码实际上是将hello存储到StringTable之中，建立了对应的映射关系
2.String s2 = "hello";在为s2进行赋值时，会先在StringTable中判断hello是否存在，如果存在就不再重复放，如果不存在，将值存入;(hashTable的特性)
3.hello此时已经存在于StringTable之中，不再存入，而是直接从表中获取数据，也就是说s1和s2拿到的数据的地址是相同的！！！
而对于s3，s4来说，他们是通过new来实例化一个新的对象，则必然在内存中重新开辟一块内存，他们的地址不相同
2.intern方法
先来看下面代码
char[] arr = new char[] {'a','b','c'};
String s1 = new String(arr);
String s2 = "abc";
System.out.println(s1 == s2);// false分析：
运用我们前面学习过的知识很容易判断
再来看下面代码
char[] arr = new char[] {'a','b','c'};
String s1 = new String(arr);
s1.intern();
String s2 = "abc";
System.out.println(s1 == s2);// true为什么就输出true呢？intern方法是什么？
intern方法就是将引用存入到常量池之中，intern方法是native的，底层是用c/c++写的
6986
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
