String类,StringBuffer类和StringBuilder类使用

String是一个特殊的类,掌握其特性原理才能更好的发挥长处,避免缺点带来的消耗,这也成为面试官喜欢用来考察应聘者的知识点.

字符串操作-String类

String可以表示一个字符串.
String类实际是使用字符数组存储的.

String类的两种赋值方法:
(1)一种称为直接赋值:String name=“小梦”;
(2)通过关键字new调用String的构造方法赋值String name=new String(“小白”);

String类编译期与运行期分析

编译期和运行期
代码示例:4种分析

String类字节与字符串操作方法

public byte[] getBytes():将字符串变为字节数组(普通)
public String(byte[] bytes):将字节数组变为字符串(构造)
public String(byte[]bytes,int offset,int length):将指定范围的字节数组变为字符串(构造)
public String(byte[]bytes,String charsetName):通过使用指定的charset解码指定的bytes数组,构造一个新的String

String类判断是否以指定内容开头或结尾

public boolean startsWith(String prefix):从第一个位置开始判断是否以指定的内容开头(普通)
public boolean startsWith(String prefix,int toffset):从指定位置开始判断是否以指定的内容开头(普通)
public boolean endsWith(String syffix):判断是否以指定的内容结尾(普通)
String类的替换操作
public String replace(char oldChar,newChar):替换指定字符(普通)
public String replace(CharSequence target,CharSequence replacement):替换指定字符串(普通)
public String replaceAll(String regex,String replacement):替换指定字符串(普通)
public String replaceFirst(String regex,String replacement):替换第一个满足条件的字符串(普通)
regex:规则(用正则表达式来运用)

String类字符串截取操作

public String substring(int beginIndex):从指定位置开始一直截取到末尾(普通)
public String substring(int beginIndex,int endIndex):截取指定范围内的字符串(普通)
String类字符串拆分操作
public String[] split(String regex):按照指定的字符串拆分(普通)
public String[] split(String regex,int limit):拆分字符串,并指定拆分的个数(普通)
String类字符串查找操作
public boolean contains(String s):返回一个字符串是否存在(普通)
public int indexOf(int ch):从头查找指定字符是否存在,char->int,如果存在则返回位置,如果不存在则返回"-1".
public int indexOf(int ch,int fromIndex):从指定位置查找字符是否存在,cahr->int,如果存在则返回位置,如果不存在则返回-1
public int indexOf(String str):从头查找指定的字符串是否存在,如果存在则返回位置,如果不存在则返回-1;
public int indexOf(String str,int fromIndex):从指定位置查找字符串是否存在,如果存在则返回位置,如果不存在则返回-1;

String类的其他操作

public boolean isEmpty():判断是否为空,指的是内容是否为空"";(普通)
public int length():取得字符串的长度;
public String toLowerCase():转小写;
public String toUpperCase():转大写;
public String trim():去掉开头和结尾的空格,中间的空格不去;
public String concat(String str):字符串连接操作.

String示例代码

package com.dream;
/**
 * String表示一个字符串,内部使用字符数组实现,该类不可变,不能被继承(最终类)
 * 2022年3月1日
 * @company
 * @author DreamTrue
 * @description
 */
public class StringDemo {

	public static void main(String[] args) {
		//String的两种赋值方式,第一种合适
		//1.直接赋值
		String s1="小梦";
		//2.使用new关键字创建对象,new:表示申请内存空间
		//面试题:问以下代码创建了几个对象?
		String s2=new String("小梦");
		//如果没有写第一种赋值,s2创建了2个对象,如果写了第一种赋值方式,创建了1个对象
		//原因:使用new String创建对象时,会先在String常量池中搜寻是否有创建的String字符串,
		//如果有则new一个对象,在声明一个字符串,创建1个对象;
		//如果没有则先在String常量池中创建一个String字符串,再new一个对象,创建一个字符串变量,创建2个对象
		String s3="小梦";
		
		System.out.println(s1==s2);
		System.out.println(s1==s3);
		
		//代码实例:4种情况分析:直接赋值字符串连接时,考虑编译期和运行期
		//如果在编译期值可以被确定,那么就使用已有的对象,否则会创建新的对象
		String a="a";
		String a1=a+1;//在堆中进行创建对象
		String a2="a1";
		System.out.println(a1==a2);
		
		final String b="b";
		String b1=b+1;//常量+1,在编译期就会执行,所以String常量池中是b1
		String b2="b1";
		System.out.println(b1==b2);
		
		String c=getC();//方法是在执行期进行的
		String c1=c+1;
		String c2="c2";
		System.out.println(c1==c2);
		
		final String d=getD();
		String d1=d+1;
		String d2="d2";
		System.out.println(d1==d2);
		
	}
	
	private static String getC() {
		return "c";
	}
	
	private static String getD() {
		return "d";
	}

}

package com.dream;

import java.util.Arrays;

/**
 * 
 * 2022年3月5日
 * @author DreamTrue
 * @description:String类字节数组与字符串转换
 */
public class StringDemo2 {

	public static void main(String[] args) {
		// TODO 字节数组与字符串相互转换
		String str="DreamTrue521";
		char c=str.charAt(1);
		System.out.println(c);
		
		System.out.println(str.toCharArray());
		char[]cs= {
				'D','r','e','a','m'
		};
		String str2=new String(cs);
		System.out.println(str2);
		String str3=new String(cs,0,1);
		System.out.println(str3);
		
		System.out.println(str.getBytes());
		System.out.println(Arrays.toString(str.getBytes()));
		
		//String类替换字符串
		String str4="12345Dream7890";
		System.out.println(str4.replace('D','*'));
		System.out.println(str4.replace("123","*"));
		System.out.println(str4.replaceAll("[0-9]", "*"));
		System.out.println(str4.replaceAll("\\d", "*"));//第一个参数表示规则,正则表达式
		System.out.println(str4.replaceFirst("[0-9]", "*"));
		
		//截取字符串
		System.out.println(str4.substring(3));
		System.out.println(str4.substring(0, 5));
		CharSequence cs2=str4.subSequence(1, 5);
		System.out.println(cs2);
		System.out.println(str4.subSequence(4, 8));
		
		//字符串拆分
		String str5="12345DreamD7890";
		System.out.println(Arrays.toString(str5.split("D")));
		System.out.println(Arrays.toString(str5.split("D", 2)));
		//参数2表示应用split拆分(2-1)次
		
		//字符串查找
		System.out.println(str5.indexOf('a'));
		System.out.println(str5.indent(4));//indet方法,输出字符串首行空格数
		System.out.println(str5.indexOf('D'));//从前开始寻找
		System.out.println(str5.lastIndexOf("D"));//从后开始寻找
		System.out.println(str5.indexOf("5", 4));//从指定位置查找字符串
		System.out.println(str5.indexOf("5",5));
		
		//其他操作
		String str6="12345DreamD7890";
		String str7="";
		System.out.println(str6.isEmpty());
		System.out.println(str7.isEmpty());
		System.out.println(str6.length());
		System.out.println(str6.toLowerCase());
		System.out.println(str6.toUpperCase());
		String str8=" 12345 DreamD 7890 ";
		System.out.println(str8.trim());//去掉字符串头尾空格
		System.out.println(str6.concat(str8));
		
		System.out.println(String.valueOf(false));
		System.out.println(String.valueOf(10));
		
		//isBlank校验是否为空,是Maven工程中的

	}

}

StringBuffer类

在实际开发当中,我们经常会使用到字符串连接的操作,如果用String来操作,则使用"+"号来完成字符串的连接操作.
注意:使用String连接字符串,代码性能会非常低,应为String的内容不可变.
解决这个问题的方法是使用StringBuffer.

StringBuffer常用操作方法

public StringBuffer():构造一个空的StringBuffer对象
public StringBuffer(String str):将指定的String变为StringBuffer内容
public StringBuffer(CharSequence seq):接受CharSequence接口的实例
public StringBuffer append(数据类型 b):提供了很多的append方法,用于进行字符串连接
public StringBuffer delete(int start,int end):删除指定位置的内容
public int indexOf(String str):字符串查询功能
public StringBuffer insert(int offset,数据类型 b):在指定位置上增加一个内容
public StringBuffer replace(int start,int end,String str):将指定范围的内容替换成其他内容
public String substring(int start,int end):截取指定范围的字符串
public String substring(int start):字符串截取
public StringBuffer reverse():字符串反转

StringBuffer示例代码

package com.dream;
/**
*2022年3月5日
*@author Dream
*@description
*StringBuffer类解决String的性能问题
*/
public class StringBufferDemo {

	public static void main(String[] args) {
		// TODO StringBuffer类解决String的性能问题
		String a="a";
		String b="b";
		String c=a+b+1;//创建了四个对象
		System.out.println(c);
		
		String a1="a"+1+2+3+"b";//a123b:常量相加没有性能问题,创建一个对象
		System.out.println(a1);
		
		//StringBuffer目的是用来解决字符串相加时带来的性能问题(常量与变量)
		//StringBuffer的内部实现采用字符数粗,默认数组的长度是16,超过数组大小时,动态扩充的算法是
		//所以当我们预知要添加的数据长度时,建议使用带初始化容量的构造方法,来避免动态扩充的次数,从而提高效率
		//synchronized线程安全的,影响性能
		StringBuffer sb=new StringBuffer();
		sb.append(a).append(b).append(1);
		System.out.println(sb.toString());
		//转换成StringBuffer类
		System.out.println(new StringBuffer(a1));
		String a2="1234DemoD567890";
		CharSequence cs=a2.subSequence(2, 8);
		System.out.println(new StringBuffer(cs));
		
		StringBuffer sb1=new StringBuffer(a2);
		//删除
		System.out.println(sb1.delete(0, 5));
		//查询
		System.out.println(sb1.indexOf("D"));
		//插入
		System.out.println(sb1.insert(0, "true"));
		//替换
		System.out.println(sb1.replace(1, 5, "fangfafaf"));
		//截取
		System.out.println(sb1.substring(5));
		//反转
		System.out.println(sb1.reverse());

	}

}

StringBuilder类

StringBuffer的兄弟
一个可变的字符序列.此类提供一个与StringBuffer兼容的API,但不保证同步.该类被设计用作StringBuffer的一个简易替换,用在字符串缓冲区被单个线程使用的时候(这种情况很普遍).如果可能,简易优先使用该类,因为在大多数实现中,它比StringBuffer要快.

注意:JDK1.5以后,字符串相加原理分析

StringBuffer与StringBuildeer的区别

StringBuffer是线程安全的,性能低,适合在多线程使用,JDK1.0
StringBuilder是线程不安全的,性能高,适合在单线程中使用,这种情况占大多数,在JDK1.5后添加

package com.dream;
/**
*2022年3月5日
*@author Dream
*@description
*
*/
public class StringBuilder {
	
	public static void main(String[] args) {
		
		StringBuilder sb=new StringBuilder();
		
		/**
		 * 字符串相加操作
		 * 1.多个常量相加没有性能问题,在编译期优化
		 * 2.变量与常量相加,会产生多个垃圾对象
		 */
		/**
		 * String a="a"+1;
		 * String b=a+"b";
		 */
		
		String c=null;
		for(int i=0;i<5;i++) {
			c+=i;
			//每次循环产生一个StringBuilder对象实现拼接,性能低,最好是手动创建StringBuilder来拼接
		}
		System.out.println(c);
		//字符串相加,在变异后,会使用StringBuilder来优化代码,实现拼接
		
	}
	
}