16 String类
java中的所有的字符串文字(例如"abc","123")都可以看做是实现了此类的实例对象
eg：
String str = new String();
str = "123";
str = "abc";
String类的特点：
1.字符串字面值常量，不变的
2.实现共享
3.内部封装了很多对于字符和字符串操作的API方法
4.Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。
5.凡是能够用"+"连接字符串的结果值类型都会转变成字符串类型
通过StringBuilder中的append方法实现的（把两种类型相加）
字符串转换通过toString方法实现的（变为字符串）
true +"" --> "true"
123 + "" --> "123"
3.14 + ""--> "3.14"
String类的常用用法以及使用格式：
序号旁边的是使用格式
//1.charAt(int index )返回指定索引处的字符值
String str = "abcds";
char sss = str.charAt(3);
System.out.println(sss);
char ssss = str.charAt(6);这个索引越界
System.out.println(ssss);
//相当于字符串的索引，设置好字符串，用charAt对第四个字符定位输出，
//其中定位数字3不能越界这里的字符串长度为6，因为是从0开始所以最大定位数字为5，
//2.codePoinAt(int index) //根据字符串的索引进行定位并转换成阿斯克码表上其对应的序号
String str = "aBbcds"
int codePointAt = str.codePointAt(1);
System.out.println(codePointAt);// B -->66 b-->98(根据阿斯克码表)
//3.compareTo(String str)
int compareTo = str2.compareTo(str);
//this.charAt(k)-anotherString.charAt(k)
//this.length()-anotherString.length()
System.out.println(compareTo);
//4.compareToIgnoreCase(String str) 忽视大小写比较字符串
int compareToIgnoreCase = str2.compareToIgnoreCase(str);
//5.concat(String str)
String concat = str.concat(str2);
System.out.println(concat);// Abc123afg123
//6.Contains(CharSequence s) [重要]
boolean contains = str2.contains("f23");// f23是一个整体不可分割
System.out.println(contains);//true false
//7.endsWith(String suffix ) suffix 后缀 prefix 前线
boolean endsWith = str2.endsWith("23");
System.out.println(endsWith);
//8 starsWith(String prefix) [重要] 是否以某个字符串为结尾
boolean StartsWith = str2.startsWith("afg");
System.out.println(StartsWith);
//9. 相等判断equals(Object o) 重要 相等判断
boolean equals = str.equals(str2);
System.out.println(equals);
//10.getBytes() byte[] "afg123"
byte[] bytes = str2.getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.print(bytes[i] + " ");
}
// UTF-8 GBK ISO-8859-1 Unicode //src 来源 dst 目的地
char[] dst = new char[10];// 10个元素 （没有东西）
//11.getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
//"afg123"
str2.getChars(2, 5, dst,4);//第五个位置
for (int i = 0; i < dst.length; i++) {
System.out.println(dst[i] + " ");
}
//str2 = "afg123"
//12. int indexOf(String str) 获取字符串第一次出现该字符串对应的索引位置 【重要】
int indexOf = str2.indexOf("12");//
System.out.println(indexOf);// 3
//13. int length()获取字符串的长度值 【重要】
int length = str2.length();
System.out.println(length);
//14.replace(CharSequence target, CharSequence replacement)
String replace = str2.replace("a", "e");// 把旧的字符串替换成新的字符串
System.out.println(replace);//ebc123ebc456
//15. split(String regex)根据指定的字符分割成字符串数组【重要】
//regex - 定界正则表达式
String str4 = "张三-李四-王五-赵六-abc";
String[] split = str4.split("-");
//相当于split = {"张三","李四","王五","赵六","abc"}
for (int i = 0; i < split.length; i++) {
System.out.print(split[i] + " ");
}
System.out.println();
String str5 = "abc.bcd.fff.123";
String[] split2 = str5.split("\\.");// 用.分割的话需要用需要用双反斜杠
// \---反斜杠 /---正斜杠 在字符串中"\"代表转义
for (int i = 0; i < split2.length; i++) {
System.out.print(split2[i] + " ");// abc bcd fff 123
} System.out.println();
String str6 = "123456789abc";
String[] split3 = str6.split("");//空字符串做分隔符
for (int i = 0; i < split3.length; i++) {
System.out.print(split3[i] + " ");//1,2,3,4,5,6,7,8,9,a,b,c
} //16.substring(int beginIndex,int endIndex) [a,b) 截取字符串 生成一个新的字符串
// 获取str6字符串中6789值
String substring = str6.substring(5, 9);
System.out.println(substring); //17. toLowerCase()小写 toUpperCase()大写
//18.String trim(() 去掉该字符串前后两端的空格
String str7 = " abc 123 ";
System.out.println("--"+str7+"--");
String trim = str7.trim();
System.out.println("--"+ trim + "--");
//19. static valueOf(Object o) 把非字符串类型转换成字符串类型，内容值不变
String valueOf = String.valueOf(abc);
System.out.println(valueOf);//123
------------恢复内容开始------------
java中的所有的字符串文字(例如"abc","123")都可以看做是实现了此类的实例对象
eg：
String str = new String();
str = "123";
str = "abc";
String类的特点：
1.字符串字面值常量，不变的
2.实现共享
3.内部封装了很多对于字符和字符串操作的API方法
4.Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。
5.凡是能够用"+"连接字符串的结果值类型都会转变成字符串类型
通过StringBuilder中的append方法实现的（把两种类型相加）
字符串转换通过toString方法实现的（变为字符串）
true +"" --> "true"
123 + "" --> "123"
3.14 + ""--> "3.14"
String类的常用用法以及使用格式：
序号旁边的是使用格式
//1.charAt(int index )返回指定索引处的字符值
String str = "abcds";
char sss = str.charAt(3);
System.out.println(sss);
char ssss = str.charAt(6);这个索引越界
System.out.println(ssss);
//相当于字符串的索引，设置好字符串，用charAt对第四个字符定位输出，
//其中定位数字3不能越界这里的字符串长度为6，因为是从0开始所以最大定位数字为5，
//2.codePoinAt(int index) //根据字符串的索引进行定位并转换成阿斯克码表上其对应的序号
String str = "aBbcds"
int codePointAt = str.codePointAt(1);
System.out.println(codePointAt);// B -->66 b-->98(根据阿斯克码表)
//3.compareTo(String str)
int compareTo = str2.compareTo(str);
//this.charAt(k)-anotherString.charAt(k)
//this.length()-anotherString.length()
System.out.println(compareTo);
//4.compareToIgnoreCase(String str) 忽视大小写比较字符串
int compareToIgnoreCase = str2.compareToIgnoreCase(str);
//5.concat(String str)
String concat = str.concat(str2);
System.out.println(concat);// Abc123afg123
//6.Contains(CharSequence s) [重要]
boolean contains = str2.contains("f23");// f23是一个整体不可分割
System.out.println(contains);//true false
//7.endsWith(String suffix ) suffix 后缀 prefix 前线
boolean endsWith = str2.endsWith("23");
System.out.println(endsWith);
//8 starsWith(String prefix) [重要] 是否以某个字符串为结尾
boolean StartsWith = str2.startsWith("afg");
System.out.println(StartsWith);
//9. 相等判断equals(Object o) 重要 相等判断
boolean equals = str.equals(str2);
System.out.println(equals);
//10.getBytes() byte[] "afg123"
byte[] bytes = str2.getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.print(bytes[i] + " ");
}
// UTF-8 GBK ISO-8859-1 Unicode //src 来源 dst 目的地
char[] dst = new char[10];// 10个元素 （没有东西）
//11.getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
//"afg123"
str2.getChars(2, 5, dst,4);//第五个位置
for (int i = 0; i < dst.length; i++) {
System.out.println(dst[i] + " ");
}
//str2 = "afg123"
//12. int indexOf(String str) 获取字符串第一次出现该字符串对应的索引位置 【重要】
int indexOf = str2.indexOf("12");//
System.out.println(indexOf);// 3
//13. int length()获取字符串的长度值 【重要】
int length = str2.length();
System.out.println(length);
//14.replace(CharSequence target, CharSequence replacement)
String replace = str2.replace("a", "e");// 把旧的字符串替换成新的字符串
System.out.println(replace);//ebc123ebc456
//15. split(String regex)根据指定的字符分割成字符串数组【重要】
//regex - 定界正则表达式
String str4 = "张三-李四-王五-赵六-abc";
String[] split = str4.split("-");
//相当于split = {"张三","李四","王五","赵六","abc"}
for (int i = 0; i < split.length; i++) {
System.out.print(split[i] + " ");
}
System.out.println();
String str5 = "abc.bcd.fff.123";
String[] split2 = str5.split("\\.");// 用.分割的话需要用需要用双反斜杠
// \---反斜杠 /---正斜杠 在字符串中"\"代表转义
for (int i = 0; i < split2.length; i++) {
System.out.print(split2[i] + " ");// abc bcd fff 123
} System.out.println();
String str6 = "123456789abc";
String[] split3 = str6.split("");//空字符串做分隔符
for (int i = 0; i < split3.length; i++) {
System.out.print(split3[i] + " ");//1,2,3,4,5,6,7,8,9,a,b,c
} //16.substring(int beginIndex,int endIndex) [a,b) 截取字符串 生成一个新的字符串
// 获取str6字符串中6789值
String substring = str6.substring(5, 9);
System.out.println(substring); //17. toLowerCase()小写 toUpperCase()大写
//18.String trim(() 去掉该字符串前后两端的空格
String str7 = " abc 123 ";
System.out.println("--"+str7+"--");
String trim = str7.trim();
System.out.println("--"+ trim + "--");
//19. static valueOf(Object o) 把非字符串类型转换成字符串类型，内容值不变
String valueOf = String.valueOf(abc);
System.out.println(valueOf);//123
------------恢复内容结束------------
------------恢复内容开始------------
java中的所有的字符串文字(例如"abc","123")都可以看做是实现了此类的实例对象
eg：
String str = new String();
str = "123";
str = "abc";
String类的特点：
1.字符串字面值常量，不变的
2.实现共享
3.内部封装了很多对于字符和字符串操作的API方法
4.Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。
5.凡是能够用"+"连接字符串的结果值类型都会转变成字符串类型
通过StringBuilder中的append方法实现的（把两种类型相加）
字符串转换通过toString方法实现的（变为字符串）
true +"" --> "true"
123 + "" --> "123"
3.14 + ""--> "3.14"
String类的常用用法以及使用格式：
序号旁边的是使用格式
//1.charAt(int index )返回指定索引处的字符值
String str = "abcds";
char sss = str.charAt(3);
System.out.println(sss);
char ssss = str.charAt(6);这个索引越界
System.out.println(ssss);
//相当于字符串的索引，设置好字符串，用charAt对第四个字符定位输出，
//其中定位数字3不能越界这里的字符串长度为6，因为是从0开始所以最大定位数字为5，
//2.codePoinAt(int index) //根据字符串的索引进行定位并转换成阿斯克码表上其对应的序号
String str = "aBbcds"
int codePointAt = str.codePointAt(1);
System.out.println(codePointAt);// B -->66 b-->98(根据阿斯克码表)
//3.compareTo(String str)
int compareTo = str2.compareTo(str);
//this.charAt(k)-anotherString.charAt(k)
//this.length()-anotherString.length()
System.out.println(compareTo);
//4.compareToIgnoreCase(String str) 忽视大小写比较字符串
int compareToIgnoreCase = str2.compareToIgnoreCase(str);
//5.concat(String str)
String concat = str.concat(str2);
System.out.println(concat);// Abc123afg123
//6.Contains(CharSequence s) [重要]
boolean contains = str2.contains("f23");// f23是一个整体不可分割
System.out.println(contains);//true false
//7.endsWith(String suffix ) suffix 后缀 prefix 前线
boolean endsWith = str2.endsWith("23");
System.out.println(endsWith);
//8 starsWith(String prefix) [重要] 是否以某个字符串为结尾
boolean StartsWith = str2.startsWith("afg");
System.out.println(StartsWith);
//9. 相等判断equals(Object o) 重要 相等判断
boolean equals = str.equals(str2);
System.out.println(equals);
//10.getBytes() byte[] "afg123"
byte[] bytes = str2.getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.print(bytes[i] + " ");
}
// UTF-8 GBK ISO-8859-1 Unicode //src 来源 dst 目的地
char[] dst = new char[10];// 10个元素 （没有东西）
//11.getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
//"afg123"
str2.getChars(2, 5, dst,4);//第五个位置
for (int i = 0; i < dst.length; i++) {
System.out.println(dst[i] + " ");
}
//str2 = "afg123"
//12. int indexOf(String str) 获取字符串第一次出现该字符串对应的索引位置 【重要】
int indexOf = str2.indexOf("12");//
System.out.println(indexOf);// 3
//13. int length()获取字符串的长度值 【重要】
int length = str2.length();
System.out.println(length);
//14.replace(CharSequence target, CharSequence replacement)
String replace = str2.replace("a", "e");// 把旧的字符串替换成新的字符串
System.out.println(replace);//ebc123ebc456
//15. split(String regex)根据指定的字符分割成字符串数组【重要】
//regex - 定界正则表达式
String str4 = "张三-李四-王五-赵六-abc";
String[] split = str4.split("-");
//相当于split = {"张三","李四","王五","赵六","abc"}
for (int i = 0; i < split.length; i++) {
System.out.print(split[i] + " ");
}
System.out.println();
String str5 = "abc.bcd.fff.123";
String[] split2 = str5.split("\\.");// 用.分割的话需要用需要用双反斜杠
// \---反斜杠 /---正斜杠 在字符串中"\"代表转义
for (int i = 0; i < split2.length; i++) {
System.out.print(split2[i] + " ");// abc bcd fff 123
} System.out.println();
String str6 = "123456789abc";
String[] split3 = str6.split("");//空字符串做分隔符
for (int i = 0; i < split3.length; i++) {
System.out.print(split3[i] + " ");//1,2,3,4,5,6,7,8,9,a,b,c
} //16.substring(int beginIndex,int endIndex) [a,b) 截取字符串 生成一个新的字符串
// 获取str6字符串中6789值
String substring = str6.substring(5, 9);
System.out.println(substring); //17. toLowerCase()小写 toUpperCase()大写
//18.String trim(() 去掉该字符串前后两端的空格
String str7 = " abc 123 ";
System.out.println("--"+str7+"--");
String trim = str7.trim();
System.out.println("--"+ trim + "--");
//19. static valueOf(Object o) 把非字符串类型转换成字符串类型，内容值不变
String valueOf = String.valueOf(abc);
System.out.println(valueOf);//123
------------恢复内容开始------------
java中的所有的字符串文字(例如"abc","123")都可以看做是实现了此类的实例对象
eg：
String str = new String();
str = "123";
str = "abc";
String类的特点：
1.字符串字面值常量，不变的
2.实现共享
3.内部封装了很多对于字符和字符串操作的API方法
4.Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。
5.凡是能够用"+"连接字符串的结果值类型都会转变成字符串类型
通过StringBuilder中的append方法实现的（把两种类型相加）
字符串转换通过toString方法实现的（变为字符串）
true +"" --> "true"
123 + "" --> "123"
3.14 + ""--> "3.14"
String类的常用用法以及使用格式：
序号旁边的是使用格式
//1.charAt(int index )返回指定索引处的字符值
String str = "abcds";
char sss = str.charAt(3);
System.out.println(sss);
char ssss = str.charAt(6);这个索引越界
System.out.println(ssss);
//相当于字符串的索引，设置好字符串，用charAt对第四个字符定位输出，
//其中定位数字3不能越界这里的字符串长度为6，因为是从0开始所以最大定位数字为5，
//2.codePoinAt(int index) //根据字符串的索引进行定位并转换成阿斯克码表上其对应的序号
String str = "aBbcds"
int codePointAt = str.codePointAt(1);
System.out.println(codePointAt);// B -->66 b-->98(根据阿斯克码表)
//3.compareTo(String str)
int compareTo = str2.compareTo(str);
//this.charAt(k)-anotherString.charAt(k)
//this.length()-anotherString.length()
System.out.println(compareTo);
//4.compareToIgnoreCase(String str) 忽视大小写比较字符串
int compareToIgnoreCase = str2.compareToIgnoreCase(str);
//5.concat(String str)
String concat = str.concat(str2);
System.out.println(concat);// Abc123afg123
//6.Contains(CharSequence s) [重要]
boolean contains = str2.contains("f23");// f23是一个整体不可分割
System.out.println(contains);//true false
//7.endsWith(String suffix ) suffix 后缀 prefix 前线
boolean endsWith = str2.endsWith("23");
System.out.println(endsWith);
//8 starsWith(String prefix) [重要] 是否以某个字符串为结尾
boolean StartsWith = str2.startsWith("afg");
System.out.println(StartsWith);
//9. 相等判断equals(Object o) 重要 相等判断
boolean equals = str.equals(str2);
System.out.println(equals);
//10.getBytes() byte[] "afg123"
byte[] bytes = str2.getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.print(bytes[i] + " ");
}
// UTF-8 GBK ISO-8859-1 Unicode //src 来源 dst 目的地
char[] dst = new char[10];// 10个元素 （没有东西）
//11.getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
//"afg123"
str2.getChars(2, 5, dst,4);//第五个位置
for (int i = 0; i < dst.length; i++) {
System.out.println(dst[i] + " ");
}
//str2 = "afg123"
//12. int indexOf(String str) 获取字符串第一次出现该字符串对应的索引位置 【重要】
int indexOf = str2.indexOf("12");//
System.out.println(indexOf);// 3
//13. int length()获取字符串的长度值 【重要】
int length = str2.length();
System.out.println(length);
//14.replace(CharSequence target, CharSequence replacement)
String replace = str2.replace("a", "e");// 把旧的字符串替换成新的字符串
System.out.println(replace);//ebc123ebc456
//15. split(String regex)根据指定的字符分割成字符串数组【重要】
//regex - 定界正则表达式
String str4 = "张三-李四-王五-赵六-abc";
String[] split = str4.split("-");
//相当于split = {"张三","李四","王五","赵六","abc"}
for (int i = 0; i < split.length; i++) {
System.out.print(split[i] + " ");
}
System.out.println();
String str5 = "abc.bcd.fff.123";
String[] split2 = str5.split("\\.");// 用.分割的话需要用需要用双反斜杠
// \---反斜杠 /---正斜杠 在字符串中"\"代表转义
for (int i = 0; i < split2.length; i++) {
System.out.print(split2[i] + " ");// abc bcd fff 123
} System.out.println();
String str6 = "123456789abc";
String[] split3 = str6.split("");//空字符串做分隔符
for (int i = 0; i < split3.length; i++) {
System.out.print(split3[i] + " ");//1,2,3,4,5,6,7,8,9,a,b,c
} //16.substring(int beginIndex,int endIndex) [a,b) 截取字符串 生成一个新的字符串
// 获取str6字符串中6789值
String substring = str6.substring(5, 9);
System.out.println(substring); //17. toLowerCase()小写 toUpperCase()大写
//18.String trim(() 去掉该字符串前后两端的空格
String str7 = " abc 123 ";
System.out.println("--"+str7+"--");
String trim = str7.trim();
System.out.println("--"+ trim + "--");
//19. static valueOf(Object o) 把非字符串类型转换成字符串类型，内容值不变
String valueOf = String.valueOf(abc);
System.out.println(valueOf);//123
------------恢复内容结束------------
------------恢复内容结束------------
------------恢复内容开始------------
java中的所有的字符串文字(例如"abc","123")都可以看做是实现了此类的实例对象
eg：
String str = new String();
str = "123";
str = "abc";
String类的特点：
1.字符串字面值常量，不变的
2.实现共享
3.内部封装了很多对于字符和字符串操作的API方法
4.Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。
5.凡是能够用"+"连接字符串的结果值类型都会转变成字符串类型
通过StringBuilder中的append方法实现的（把两种类型相加）
字符串转换通过toString方法实现的（变为字符串）
true +"" --> "true"
123 + "" --> "123"
3.14 + ""--> "3.14"
String类的常用用法以及使用格式：
序号旁边的是使用格式
//1.charAt(int index )返回指定索引处的字符值
String str = "abcds";
char sss = str.charAt(3);
System.out.println(sss);
char ssss = str.charAt(6);这个索引越界
System.out.println(ssss);
//相当于字符串的索引，设置好字符串，用charAt对第四个字符定位输出，
//其中定位数字3不能越界这里的字符串长度为6，因为是从0开始所以最大定位数字为5，
//2.codePoinAt(int index) //根据字符串的索引进行定位并转换成阿斯克码表上其对应的序号
String str = "aBbcds"
int codePointAt = str.codePointAt(1);
System.out.println(codePointAt);// B -->66 b-->98(根据阿斯克码表)
//3.compareTo(String str)
int compareTo = str2.compareTo(str);
//this.charAt(k)-anotherString.charAt(k)
//this.length()-anotherString.length()
System.out.println(compareTo);
//4.compareToIgnoreCase(String str) 忽视大小写比较字符串
int compareToIgnoreCase = str2.compareToIgnoreCase(str);
//5.concat(String str)
String concat = str.concat(str2);
System.out.println(concat);// Abc123afg123
//6.Contains(CharSequence s) [重要]
boolean contains = str2.contains("f23");// f23是一个整体不可分割
System.out.println(contains);//true false
//7.endsWith(String suffix ) suffix 后缀 prefix 前线
boolean endsWith = str2.endsWith("23");
System.out.println(endsWith);
//8 starsWith(String prefix) [重要] 是否以某个字符串为结尾
boolean StartsWith = str2.startsWith("afg");
System.out.println(StartsWith);
//9. 相等判断equals(Object o) 重要 相等判断
boolean equals = str.equals(str2);
System.out.println(equals);
//10.getBytes() byte[] "afg123"
byte[] bytes = str2.getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.print(bytes[i] + " ");
}
// UTF-8 GBK ISO-8859-1 Unicode //src 来源 dst 目的地
char[] dst = new char[10];// 10个元素 （没有东西）
//11.getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
//"afg123"
str2.getChars(2, 5, dst,4);//第五个位置
for (int i = 0; i < dst.length; i++) {
System.out.println(dst[i] + " ");
}
//str2 = "afg123"
//12. int indexOf(String str) 获取字符串第一次出现该字符串对应的索引位置 【重要】
int indexOf = str2.indexOf("12");//
System.out.println(indexOf);// 3
//13. int length()获取字符串的长度值 【重要】
int length = str2.length();
System.out.println(length);
//14.replace(CharSequence target, CharSequence replacement)
String replace = str2.replace("a", "e");// 把旧的字符串替换成新的字符串
System.out.println(replace);//ebc123ebc456
//15. split(String regex)根据指定的字符分割成字符串数组【重要】
//regex - 定界正则表达式
String str4 = "张三-李四-王五-赵六-abc";
String[] split = str4.split("-");
//相当于split = {"张三","李四","王五","赵六","abc"}
for (int i = 0; i < split.length; i++) {
System.out.print(split[i] + " ");
}
System.out.println();
String str5 = "abc.bcd.fff.123";
String[] split2 = str5.split("\\.");// 用.分割的话需要用需要用双反斜杠
// \---反斜杠 /---正斜杠 在字符串中"\"代表转义
for (int i = 0; i < split2.length; i++) {
System.out.print(split2[i] + " ");// abc bcd fff 123
} System.out.println();
String str6 = "123456789abc";
String[] split3 = str6.split("");//空字符串做分隔符
for (int i = 0; i < split3.length; i++) {
System.out.print(split3[i] + " ");//1,2,3,4,5,6,7,8,9,a,b,c
} //16.substring(int beginIndex,int endIndex) [a,b) 截取字符串 生成一个新的字符串
// 获取str6字符串中6789值
String substring = str6.substring(5, 9);
System.out.println(substring); //17. toLowerCase()小写 toUpperCase()大写
//18.String trim(() 去掉该字符串前后两端的空格
String str7 = " abc 123 ";
System.out.println("--"+str7+"--");
String trim = str7.trim();
System.out.println("--"+ trim + "--");
//19. static valueOf(Object o) 把非字符串类型转换成字符串类型，内容值不变
String valueOf = String.valueOf(abc);
System.out.println(valueOf);//123
------------恢复内容开始------------
java中的所有的字符串文字(例如"abc","123")都可以看做是实现了此类的实例对象
eg：
String str = new String();
str = "123";
str = "abc";
String类的特点：
1.字符串字面值常量，不变的
2.实现共享
3.内部封装了很多对于字符和字符串操作的API方法
4.Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。
5.凡是能够用"+"连接字符串的结果值类型都会转变成字符串类型
通过StringBuilder中的append方法实现的（把两种类型相加）
字符串转换通过toString方法实现的（变为字符串）
true +"" --> "true"
123 + "" --> "123"
3.14 + ""--> "3.14"
String类的常用用法以及使用格式：
序号旁边的是使用格式
//1.charAt(int index )返回指定索引处的字符值
String str = "abcds";
char sss = str.charAt(3);
System.out.println(sss);
char ssss = str.charAt(6);这个索引越界
System.out.println(ssss);
//相当于字符串的索引，设置好字符串，用charAt对第四个字符定位输出，
//其中定位数字3不能越界这里的字符串长度为6，因为是从0开始所以最大定位数字为5，
//2.codePoinAt(int index) //根据字符串的索引进行定位并转换成阿斯克码表上其对应的序号
String str = "aBbcds"
int codePointAt = str.codePointAt(1);
System.out.println(codePointAt);// B -->66 b-->98(根据阿斯克码表)
//3.compareTo(String str)
int compareTo = str2.compareTo(str);
//this.charAt(k)-anotherString.charAt(k)
//this.length()-anotherString.length()
System.out.println(compareTo);
//4.compareToIgnoreCase(String str) 忽视大小写比较字符串
int compareToIgnoreCase = str2.compareToIgnoreCase(str);
//5.concat(String str)
String concat = str.concat(str2);
System.out.println(concat);// Abc123afg123
//6.Contains(CharSequence s) [重要]
boolean contains = str2.contains("f23");// f23是一个整体不可分割
System.out.println(contains);//true false
//7.endsWith(String suffix ) suffix 后缀 prefix 前线
boolean endsWith = str2.endsWith("23");
System.out.println(endsWith);
//8 starsWith(String prefix) [重要] 是否以某个字符串为结尾
boolean StartsWith = str2.startsWith("afg");
System.out.println(StartsWith);
//9. 相等判断equals(Object o) 重要 相等判断
boolean equals = str.equals(str2);
System.out.println(equals);
//10.getBytes() byte[] "afg123"
byte[] bytes = str2.getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.print(bytes[i] + " ");
}
// UTF-8 GBK ISO-8859-1 Unicode //src 来源 dst 目的地
char[] dst = new char[10];// 10个元素 （没有东西）
//11.getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
//"afg123"
str2.getChars(2, 5, dst,4);//第五个位置
for (int i = 0; i < dst.length; i++) {
System.out.println(dst[i] + " ");
}
//str2 = "afg123"
//12. int indexOf(String str) 获取字符串第一次出现该字符串对应的索引位置 【重要】
int indexOf = str2.indexOf("12");//
System.out.println(indexOf);// 3
//13. int length()获取字符串的长度值 【重要】
int length = str2.length();
System.out.println(length);
//14.replace(CharSequence target, CharSequence replacement)
String replace = str2.replace("a", "e");// 把旧的字符串替换成新的字符串
System.out.println(replace);//ebc123ebc456
//15. split(String regex)根据指定的字符分割成字符串数组【重要】
//regex - 定界正则表达式
String str4 = "张三-李四-王五-赵六-abc";
String[] split = str4.split("-");
//相当于split = {"张三","李四","王五","赵六","abc"}
for (int i = 0; i < split.length; i++) {
System.out.print(split[i] + " ");
}
System.out.println();
String str5 = "abc.bcd.fff.123";
String[] split2 = str5.split("\\.");// 用.分割的话需要用需要用双反斜杠
// \---反斜杠 /---正斜杠 在字符串中"\"代表转义
for (int i = 0; i < split2.length; i++) {
System.out.print(split2[i] + " ");// abc bcd fff 123
} System.out.println();
String str6 = "123456789abc";
String[] split3 = str6.split("");//空字符串做分隔符
for (int i = 0; i < split3.length; i++) {
System.out.print(split3[i] + " ");//1,2,3,4,5,6,7,8,9,a,b,c
} //16.substring(int beginIndex,int endIndex) [a,b) 截取字符串 生成一个新的字符串
// 获取str6字符串中6789值
String substring = str6.substring(5, 9);
System.out.println(substring); //17. toLowerCase()小写 toUpperCase()大写
//18.String trim(() 去掉该字符串前后两端的空格
String str7 = " abc 123 ";
System.out.println("--"+str7+"--");
String trim = str7.trim();
System.out.println("--"+ trim + "--");
//19. static valueOf(Object o) 把非字符串类型转换成字符串类型，内容值不变
String valueOf = String.valueOf(abc);
System.out.println(valueOf);//123
------------恢复内容结束------------
------------恢复内容开始------------
java中的所有的字符串文字(例如"abc","123")都可以看做是实现了此类的实例对象
eg：
String str = new String();
str = "123";
str = "abc";
String类的特点：
1.字符串字面值常量，不变的
2.实现共享
3.内部封装了很多对于字符和字符串操作的API方法
4.Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。
5.凡是能够用"+"连接字符串的结果值类型都会转变成字符串类型
通过StringBuilder中的append方法实现的（把两种类型相加）
字符串转换通过toString方法实现的（变为字符串）
true +"" --> "true"
123 + "" --> "123"
3.14 + ""--> "3.14"
String类的常用用法以及使用格式：
序号旁边的是使用格式
//1.charAt(int index )返回指定索引处的字符值
String str = "abcds";
char sss = str.charAt(3);
System.out.println(sss);
char ssss = str.charAt(6);这个索引越界
System.out.println(ssss);
//相当于字符串的索引，设置好字符串，用charAt对第四个字符定位输出，
//其中定位数字3不能越界这里的字符串长度为6，因为是从0开始所以最大定位数字为5，
//2.codePoinAt(int index) //根据字符串的索引进行定位并转换成阿斯克码表上其对应的序号
String str = "aBbcds"
int codePointAt = str.codePointAt(1);
System.out.println(codePointAt);// B -->66 b-->98(根据阿斯克码表)
//3.compareTo(String str)
int compareTo = str2.compareTo(str);
//this.charAt(k)-anotherString.charAt(k)
//this.length()-anotherString.length()
System.out.println(compareTo);
//4.compareToIgnoreCase(String str) 忽视大小写比较字符串
int compareToIgnoreCase = str2.compareToIgnoreCase(str);
//5.concat(String str)
String concat = str.concat(str2);
System.out.println(concat);// Abc123afg123
//6.Contains(CharSequence s) [重要]
boolean contains = str2.contains("f23");// f23是一个整体不可分割
System.out.println(contains);//true false
//7.endsWith(String suffix ) suffix 后缀 prefix 前线
boolean endsWith = str2.endsWith("23");
System.out.println(endsWith);
//8 starsWith(String prefix) [重要] 是否以某个字符串为结尾
boolean StartsWith = str2.startsWith("afg");
System.out.println(StartsWith);
//9. 相等判断equals(Object o) 重要 相等判断
boolean equals = str.equals(str2);
System.out.println(equals);
//10.getBytes() byte[] "afg123"
byte[] bytes = str2.getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.print(bytes[i] + " ");
}
// UTF-8 GBK ISO-8859-1 Unicode //src 来源 dst 目的地
char[] dst = new char[10];// 10个元素 （没有东西）
//11.getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
//"afg123"
str2.getChars(2, 5, dst,4);//第五个位置
for (int i = 0; i < dst.length; i++) {
System.out.println(dst[i] + " ");
}
//str2 = "afg123"
//12. int indexOf(String str) 获取字符串第一次出现该字符串对应的索引位置 【重要】
int indexOf = str2.indexOf("12");//
System.out.println(indexOf);// 3
//13. int length()获取字符串的长度值 【重要】
int length = str2.length();
System.out.println(length);
//14.replace(CharSequence target, CharSequence replacement)
String replace = str2.replace("a", "e");// 把旧的字符串替换成新的字符串
System.out.println(replace);//ebc123ebc456
//15. split(String regex)根据指定的字符分割成字符串数组【重要】
//regex - 定界正则表达式
String str4 = "张三-李四-王五-赵六-abc";
String[] split = str4.split("-");
//相当于split = {"张三","李四","王五","赵六","abc"}
for (int i = 0; i < split.length; i++) {
System.out.print(split[i] + " ");
}
System.out.println();
String str5 = "abc.bcd.fff.123";
String[] split2 = str5.split("\\.");// 用.分割的话需要用需要用双反斜杠
// \---反斜杠 /---正斜杠 在字符串中"\"代表转义
for (int i = 0; i < split2.length; i++) {
System.out.print(split2[i] + " ");// abc bcd fff 123
} System.out.println();
String str6 = "123456789abc";
String[] split3 = str6.split("");//空字符串做分隔符
for (int i = 0; i < split3.length; i++) {
System.out.print(split3[i] + " ");//1,2,3,4,5,6,7,8,9,a,b,c
} //16.substring(int beginIndex,int endIndex) [a,b) 截取字符串 生成一个新的字符串
// 获取str6字符串中6789值
String substring = str6.substring(5, 9);
System.out.println(substring); //17. toLowerCase()小写 toUpperCase()大写
//18.String trim(() 去掉该字符串前后两端的空格
String str7 = " abc 123 ";
System.out.println("--"+str7+"--");
String trim = str7.trim();
System.out.println("--"+ trim + "--");
//19. static valueOf(Object o) 把非字符串类型转换成字符串类型，内容值不变
String valueOf = String.valueOf(abc);
System.out.println(valueOf);//123
------------恢复内容开始------------
java中的所有的字符串文字(例如"abc","123")都可以看做是实现了此类的实例对象
eg：
String str = new String();
str = "123";
str = "abc";
String类的特点：
1.字符串字面值常量，不变的
2.实现共享
3.内部封装了很多对于字符和字符串操作的API方法
4.Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。
5.凡是能够用"+"连接字符串的结果值类型都会转变成字符串类型
通过StringBuilder中的append方法实现的（把两种类型相加）
字符串转换通过toString方法实现的（变为字符串）
true +"" --> "true"
123 + "" --> "123"
3.14 + ""--> "3.14"
String类的常用用法以及使用格式：
序号旁边的是使用格式
//1.charAt(int index )返回指定索引处的字符值
String str = "abcds";
char sss = str.charAt(3);
System.out.println(sss);
char ssss = str.charAt(6);这个索引越界
System.out.println(ssss);
//相当于字符串的索引，设置好字符串，用charAt对第四个字符定位输出，
//其中定位数字3不能越界这里的字符串长度为6，因为是从0开始所以最大定位数字为5，
//2.codePoinAt(int index) //根据字符串的索引进行定位并转换成阿斯克码表上其对应的序号
String str = "aBbcds"
int codePointAt = str.codePointAt(1);
System.out.println(codePointAt);// B -->66 b-->98(根据阿斯克码表)
//3.compareTo(String str)
int compareTo = str2.compareTo(str);
//this.charAt(k)-anotherString.charAt(k)
//this.length()-anotherString.length()
System.out.println(compareTo);
//4.compareToIgnoreCase(String str) 忽视大小写比较字符串
int compareToIgnoreCase = str2.compareToIgnoreCase(str);
//5.concat(String str)
String concat = str.concat(str2);
System.out.println(concat);// Abc123afg123
//6.Contains(CharSequence s) [重要]
boolean contains = str2.contains("f23");// f23是一个整体不可分割
System.out.println(contains);//true false
//7.endsWith(String suffix ) suffix 后缀 prefix 前线
boolean endsWith = str2.endsWith("23");
System.out.println(endsWith);
//8 starsWith(String prefix) [重要] 是否以某个字符串为结尾
boolean StartsWith = str2.startsWith("afg");
System.out.println(StartsWith);
//9. 相等判断equals(Object o) 重要 相等判断
boolean equals = str.equals(str2);
System.out.println(equals);
//10.getBytes() byte[] "afg123"
byte[] bytes = str2.getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.print(bytes[i] + " ");
}
// UTF-8 GBK ISO-8859-1 Unicode //src 来源 dst 目的地
char[] dst = new char[10];// 10个元素 （没有东西）
//11.getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
//"afg123"
str2.getChars(2, 5, dst,4);//第五个位置
for (int i = 0; i < dst.length; i++) {
System.out.println(dst[i] + " ");
}
//str2 = "afg123"
//12. int indexOf(String str) 获取字符串第一次出现该字符串对应的索引位置 【重要】
int indexOf = str2.indexOf("12");//
System.out.println(indexOf);// 3
//13. int length()获取字符串的长度值 【重要】
int length = str2.length();
System.out.println(length);
//14.replace(CharSequence target, CharSequence replacement)
String replace = str2.replace("a", "e");// 把旧的字符串替换成新的字符串
System.out.println(replace);//ebc123ebc456
//15. split(String regex)根据指定的字符分割成字符串数组【重要】
//regex - 定界正则表达式
String str4 = "张三-李四-王五-赵六-abc";
String[] split = str4.split("-");
//相当于split = {"张三","李四","王五","赵六","abc"}
for (int i = 0; i < split.length; i++) {
System.out.print(split[i] + " ");
}
System.out.println();
String str5 = "abc.bcd.fff.123";
String[] split2 = str5.split("\\.");// 用.分割的话需要用需要用双反斜杠
// \---反斜杠 /---正斜杠 在字符串中"\"代表转义
for (int i = 0; i < split2.length; i++) {
System.out.print(split2[i] + " ");// abc bcd fff 123
} System.out.println();
String str6 = "123456789abc";
String[] split3 = str6.split("");//空字符串做分隔符
for (int i = 0; i < split3.length; i++) {
System.out.print(split3[i] + " ");//1,2,3,4,5,6,7,8,9,a,b,c
} //16.substring(int beginIndex,int endIndex) [a,b) 截取字符串 生成一个新的字符串
// 获取str6字符串中6789值
String substring = str6.substring(5, 9);
System.out.println(substring); //17. toLowerCase()小写 toUpperCase()大写
//18.String trim(() 去掉该字符串前后两端的空格
String str7 = " abc 123 ";
System.out.println("--"+str7+"--");
String trim = str7.trim();
System.out.println("--"+ trim + "--");
//19. static valueOf(Object o) 把非字符串类型转换成字符串类型，内容值不变
String valueOf = String.valueOf(abc);
System.out.println(valueOf);//123
------------恢复内容结束------------
------------恢复内容结束------------
------------恢复内容结束------------
16 String类的更多相关文章
- C++语言基础(16)-string类
使用 string 类需要包含头文件<string>,下面的例子介绍了几种定义 string 变量(对象)的方法: #include <iostream> #include & ...
- 源码学习-String类
最近在扫描CodeDex时报了一个不能使用String.intern()的字符串来做锁对象的告警,对这个问题有疑问查了些资料,顺便学习一下String类的源码. 1.类定义 String 被final ...
- 《C++ Primer Plus》16.1 string类 学习笔记
16.1.1 构造字符串程序清单16.1使用了string的7个构造函数.程序清单16.1 str1.cpp---------------------------------------------- ...
- C++ primer plus读书笔记——第16章 string类和标准模板库
第16章 string类和标准模板库 1. string容易被忽略的构造函数: string(size_type n, char c)长度为n,每个字母都为c string(const string ...
- 《C++ Primer Plus》第16章 string类和标准模板库 学习笔记
C++提供了一组功能强大的库,这些库提供了很多常见编程问题的解决方案以及简化其他问题的工具string类为将字符串作为对象来处理提供了一种方便的方法.string类提供了自动内存管理动能以及众多处理字 ...
- String类和StringBuffer类的区别
首先,String和StringBuffer主要有2个区别: (1)String类对象为不可变对象,一旦你修改了String对象的值,隐性重新创建了一个新的对象,释放原String对象,StringB ...
- String 类相关知识
1.常用方法 1)判断字符串是否为空 public boolean isEmpty()2)获取字符串长度 public int length()3)截取子子串 public String substr ...
- Java String类的常用方法
String(byte[ ] bytes):通过byte数组构造字符串对象. String(char[ ] value):通过char数组构造字符串对象. String(Sting original) ...
- [C++][语言语法]标准C++中的string类的用法总结
转自:http://www.cnblogs.com/xFreedom/archive/2011/05/16/2048037.html 要想使用标准C++中string类,必须要包含 #include ...
随机推荐
- Unity Shader学习笔记-1
本篇文章是对Unity Shader入门精要的学习笔记,插图大部分来自冯乐乐女神的github 如果有什么说的不正确的请批评指正 目录 渲染流水线 流程图 Shader作用 屏幕映射 三角形遍历 两大 ...
- Vue登录注册，并保持登录状态
关于vue登录注册,并保持登录状态,是vue玩家必经之路,网上也有很多的解决方法,但是有一些太过于复杂,新手可能会看的一脸懵逼,现在给大家介绍一种我自己写项目在用而且并不难理解的一种方法. 项目中有一 ...
- 点、像素、分辨率、PPI、DPI等
屏幕尺寸 屏幕尺寸是屏幕的对角线的长度,单位是英寸,1英寸=2.54厘米. pixel 像素,它是组成图片的最小单元,代表红绿蓝等各种颜色. dot 点,它是屏幕发光.cmos感光的最小物理单元,水平 ...
- Python-全局解释器锁GIL原理和多线程产生原因与原理-多线程通信机制
GIL 全局解释器锁,这个锁是个粗粒度的锁,解释器层面上的锁,为了保证线程安全,同一时刻只允许一个线程执行,但这个锁并不能保存线程安全,因为GIL会释放掉的并且切换到另外一个线程上,不会完全占用,依据 ...
- 059 01 Android 零基础入门 01 Java基础语法 06 Java一维数组 06 增强型for循环
059 01 Android 零基础入门 01 Java基础语法 06 Java一维数组 06 增强型for循环 本文知识点:增强型for循环 增强型for循环格式 案例练习增强型for循环 数组名字 ...
- 【题解】NOIP2018 赛道修建
题目戳我 \(\text{Solution:}\) 根据题目信息简化题意,是让你在树上找出\(m\)条路径使得路径长度最小值最大. 看到题第一感先二分一个答案,问题转化为如何选择一些路径使得它们最小值 ...
- angularCroppie
下载 angularCroppieangularCroppie 图像Cropper使用Croppie 安装 Npm: Npm安装角croppie 使用 添加依赖项:angular.模块("m ...
- 使用react Context+useReducer替代redux
首先明确一点,Redux 是一个有用的架构,但不是非用不可.事实上,大多数情况,你可以不用它,只用 React 就够了. 曾经有人说过这样一句话. "如果你不知道是否需要 Redux,那就是 ...
- Vue学习 一 环境搭建
Vue ui 启动 创建一个新项目 包管理器 npm Bable 转换js 至低版本的支持(兼容低版本) TypeScript 对TypeScript 的支持 (暂时不需要) PWA ...
- [leetcode] 周赛 211
比赛题目:https://leetcode-cn.com/circle/discuss/luvHfG/ 两个相同字符之间的最长子字符串 题目:5543. 两个相同字符之间的最长子字符串. 开始理解错题 ...