常用类-字符串相关类
1 什么是String
String是不可变类, 即一旦一个String对象被创建, 包含在这个对象中的字符序列是不可改变的, 直至该对象被销毁。
String类是final类，不能有子类。
2 分类
String
StringBuffer
StringBuilder
3 String的使用
package com.qf.string_class;
public class Test01 {
public static void main(String[] args) {
String str = "123abc";
str = str.concat("DEF123");//在末尾追加，并返回新的字符串
str = str.substring(2);//从开始下标处截取到字符串末尾，并返回新的字符串
str = str.substring(1, 7);//从开始下标处(包含)截取到结束下标处(排他)，并返回新的字符串
str = str.toLowerCase();//转小写，并返回新的字符串
str = str.toUpperCase();//转大写，并返回新的字符串
//--------------------------------------------------------------------
str = " 123 abc DEF 123 ";
str = str.trim();//去除首尾空格，并返回新的字符串
str = str.replace('2', '6');//替换字符，并返回新的字符串
str = str.replaceAll("163", "666888");//替换字符串，并返回新的字符串
str = str.replaceFirst("666", "7777");//替换第一次出现的字符串，并返回新的字符串
str = str.replaceAll(" ", "");//去除空格（将空格字符串替换成空内容的字符串）
System.out.println("判断两个字符串是否相同(区分大小写)：" + str.equals("7777888abcDEF666888"));
System.out.println("判断两个字符串是否相同(不区分大小写)：" + str.equalsIgnoreCase("7777888ABCDEF666888"));
System.out.println("判断字符串是否以某个字符串开头：" + str.startsWith("777"));
System.out.println("判断字符串是否以某个字符串结尾：" + str.endsWith("666888"));
System.out.println("查询出子字符串在字符串中第一次出现的下标：" + str.indexOf("88"));
System.out.println("查询出子字符串在字符串中最后一次出现的下标：" + str.lastIndexOf("88"));
System.out.println("获取指定下标上的字符：" + str.charAt(7));
System.out.println(str);//7777888abcDEF666888
//-------------------------------------------------------------
//将其他类型转型成String
System.out.println(String.valueOf(100));//int -> String
System.out.println(String.valueOf(123.123));//double -> String
System.out.println(String.valueOf('a'));//char -> String
System.out.println(String.valueOf(true));//boolean -> String
System.out.println(String.valueOf(new char[]{'a','b','c'}));//char[] -> String
//将其他类型转型成String -- 简化版
System.out.println(100 + "");
System.out.println(123.123 + "");
System.out.println('a' + "");
System.out.println(true + "");
}
}
4 StringBuffer的使用
理解:
StringBuffer代表可变的字符序列。
StringBuffer称为字符串缓冲区
它的工作原理是：预先申请一块内存，存放字符序列，如果字符序列满了，会重新改变缓存区的大小，以容纳更多的字符序列。
StringBuffer是可变对象，这个是String最大的不同
package com.qf.string_class;
public class Test02 {
public static void main(String[] args) {
//创建StringBuffer对象
StringBuffer sb = new StringBuffer();
//在末尾追加字符串
sb.append("123abc");
sb.append("DEF123");
sb.insert(6, "XXYYZZ");//将字符串插入到指定下标的位置
sb.setCharAt(6, 'x');//替换指定下标上的字符
sb.replace(3, 6, "aabbcc");//替换开始下标处(包含)到结束下标处(排他)的字符串
sb.deleteCharAt(3);//删除指定下标上的字符
sb.delete(3, 17);//删除开始下标处(包含)到结束下标处(排他)的字符串
sb.reverse();//反转字符串
System.out.println(sb.toString());//321321
}
}
5 StringBuilder的使用
理解：
StringBuilder代表可变的字符序列。
StringBuilder称为字符串缓冲区
它的工作原理是：预先申请一块内存，存放字符序列，如果字符序列满了，会重新改变缓存区的大小，以容纳更多的字符序列。
StringBuilder是可变对象，这个是String最大的不同
package com.qf.string_class;
public class Test03 {
public static void main(String[] args) {
//创建StringBuilder对象
StringBuilder sb = new StringBuilder();
//在末尾追加字符串
sb.append("123abc");
sb.append("DEF123");
sb.insert(6, "XXYYZZ");//将字符串插入到指定下标的位置
sb.setCharAt(6, 'x');//替换指定下标上的字符
sb.replace(3, 6, "aabbcc");//替换开始下标处(包含)到结束下标处(排他)的字符串
sb.deleteCharAt(3);//删除指定下标上的字符
sb.delete(3, 17);//删除开始下标处(包含)到结束下标处(排他)的字符串
sb.reverse();//反转字符串
System.out.println(sb.toString());//321321
}
}
6 关于字符串类的深入 – String创建对象
package com.qf.string_class;
public class Test04 {
/**
* 知识点：关于字符串类的深入 -- String创建对象
*/
public static void main(String[] args) {
//面试题：描述下列代码会创建几个String对象
//答案：1个（常量池里的数据是唯一的）
// String str1 = "abc";
// String str2 = "abc";
// System.out.println(str1);
// System.out.println(str2);
//面试题：描述下列代码会创建几个String对象
//答案：3个（常量池一个，new了两个）
String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(str1);
System.out.println(str2);
}
}
7 关于字符串类的深入 – String拼接创建对象
package com.qf.string_class;
public class Test05 {
/**
* 知识点：关于字符串类的深入 -- String拼接创建对象
*/
public static void main(String[] args) {
String str1 = "abc";
String str2 = "abc";
System.out.println(str1 == str2);//true
//两个常量在编译时直接拼接
String str3 = "ab" + "c";
System.out.println(str1 == str3);//true
//两个常量在编译时直接拼接
final String s1 = "ab";
final String s2 = "c";
String str4 = s1 + s2;//反编译：String str4 = "abc";
System.out.println(str1 == str4);//true
//变量拼接，底层会创建StringBuilder对象
String s3 = "ab";
String s4 = "c";
String str5 = s3 + s4;//底层实现：String str5 = (new StringBuilder(String.valueOf(s3))).append(s4).toString()
System.out.println(str1 == str5);//false
}
}
8 关于字符串类的深入 – StringBuilder底层源码
package com.qf.string_class;
public class Test06 {
/**
* 知识点：关于字符串类的深入 -- StringBuilder底层源码
*/
public static void main(String[] args) {
//面试题：如果减少容器的伸缩性？（如果减少容器的扩容次数）
//答案：选择容器类的有参构造，直接指定容器长度
/**
* 经验：现在的需求要存储10000个长度的数据，不要使用new StringBuilder()的方式，因为
* 使用无参构造，底层会创建16长度的容器，存储10000个数据需要多次扩容，效率极低，
* 直接使用new StringBuilder(10000)的方式，一步到位。
*/
//默认长度：10000
//StringBuilder sb = new StringBuilder(10000);
//默认长度："abc".length() + 16
//StringBuilder sb = new StringBuilder("abc");
//默认长度：16
StringBuilder sb = new StringBuilder();
String str = null;
sb.append(str);
sb.append("aaaaa");
sb.append("bbbbb");
sb.append("cccccccccc");
System.out.println(sb.toString());
}
}
9 关于字符串类的深入 – StringBuffer底层源码
package com.qf.string_class;
public class Test07 {
/**
* 知识点：关于字符串类的深入 -- StringBuffer底层源码
*
* 注意：
* StringBuffer和StringBuilder在使用层面上是一模一样的（调用方法）,
* StringBuffer和StringBuilder都是继承的同一个父类（AbstractStringBuilder）,
* 而且底层实现都是依赖于父类，唯一不同就是StringBuffer方法上加了锁（synchronized），
* 就意味着StringBuffer是线程安全的
*
* 应用场景：
* 单线程的程序：使用StringBuilder，因为不上锁
* 多线程的程序：使用StringBuffer，上锁是因为不让其他线程抢到资源
*
* 注意：StringBuilder的效率比StringBuffer高，因为没有上锁和解锁的过程
*/
public static void main(String[] args) {
//默认长度：10000
//StringBuffer sb = new StringBuffer(10000);
//默认长度："abc".length() + 16
//StringBuffer sb = new StringBuffer("abc");
//默认长度：16
StringBuffer sb = new StringBuffer();
String str = null;
sb.append(str);
sb.append("aaaaa");
sb.append("bbbbb");
sb.append("cccccccccc");
System.out.println(sb.toString());
}
}
10 频繁的拼接字符串使用StringBuilder或StringBuffer
package com.qf.string_class;
public class Test08 {
/**
* 知识点：关于字符串类的深入 -- 频繁的拼接字符串使用StringBuilder或StringBuffer
*/
public static void main(String[] args) {
//获取自1970.1.1 0:0:0到现在的毫秒数(1000毫秒=1秒)
//long currentTimeMillis = System.currentTimeMillis();
// long startTime = System.currentTimeMillis();
// String str = "小丹";
// for (int i = 0; i < 50000; i++) {
// str += "小可爱，皇冠给你带";
//底层实现：
//str = str + "小可爱，皇冠给你带";
//str = new StringBuidler(String.valueOf(str)).append("小可爱，皇冠给你带").toString();
// }
// long endTime = System.currentTimeMillis();
// System.out.println("消耗时长为：" + (endTime-startTime));//8814
//----------------------------------------------------------------------
long startTime = System.currentTimeMillis();
StringBuilder sb = new StringBuilder(450002);
sb.append("小丹");
for (int i = 0; i < 50000; i++) {
sb.append("小可爱，皇冠给你带");
}
long endTime = System.currentTimeMillis();
System.out.println("消耗时长为：" + (endTime-startTime));//5
}
}