Java之String类、StringBuffer类、StringBuilder类

落日映苍穹つ 2023-03-04 08:07 10阅读 0赞

## String类 ##

代表字符串，Java中所有字符串字面值（如"abc"）都是String类的实例对象。

## 两种创建方式及区别 ##

String s1 = "abc"; // s1是一个类类型变量 "abc"是一个对象
    				   // 字符串最大的特点：一旦被初始化就不可改变
    String s2 = new String("abc");
    /* s1和s2的区别： s1在内存中有一个对象，即"abc" s2在内存中有两个对象，即new String()和"abc" */
    System.out.println(s1 == s2);//false 比较的是两个对象，他们指向了不同的地址值
    System.out.println(s1.equals(s2));//true
    								  //String类复写了Object类中equals方法
    								  //该方法用于判断字符串是否相同

## 字符串操作常用方法 ##

**获取**

1.  返回字符串长度  
    int length()
2.  根据位置获取位置上某个字符  
    char charAt(int index)
3.  根据字符获取该字符在字符串中的位置  
    int indexOf(char ch) //第一次出现的位置  
    int indexOf(char ch, int fromIndex) //从fromIndex位置开始出现的位置  
    int lastIndexOf(char ch) //从后往前数第一次出现的位置  
    int indexOf(String str) //第一次出现的位置  
    int indexOf(String str, int fromIndex) //从fromIndex位置开始出现的位置

**判断**

1.  字符串中是否包含某个子串  
    boolean contains(String str)
2.  字符串中是否有内容  
    boolean isEmpty()
3.  字符串是否以指定内容开头  
    boolean startsWith(String str)
4.  字符串是否以指定内容结束  
    boolean endsWith(String str)
5.  判断字符串内容是否相同  
    boolean equals(String str)
6.  判断内容是否相同并忽略大小写  
    boolean equalsIgnoreCase(String str)

**转换**

1.  将字符数组转换成字符串  
    构造函数：  
    String(char\[\] data)  
    String(char\[\] data,int offset,int count)//将字符数组中的一部分转换成字符串  
    静态方法：  
    static String copyValueOf(char\[\] data)  
    static String copyValueOf(char\[\] data,int offset,int count)  
    static String valueOf(char\[\] data)
2.  将字符串转换成字符数组  
    char\[\] toCharArray()
3.  将字节数组转换成字符串  
    String(byte\[\] data)  
    String(byte\[\] data,int offset,int count)//将字节数组中的一部分转换成字符串
4.  将字符串转换成字节数组  
    byte\[\] getBytes()
5.  将基本数据类型转换成字符串  
    static String valueOf(int)  
    static String valueOf(double)  
    \+""  
    特殊：字符串和字节数组在转换过程中是可以指定编码表的。

**其他**

1.  替换字符串中的部分字符  
    String replace(oldchar,newchar);
2.  切割为数组，按照特殊字符切割  
    String\[\] split(regex);
3.  子串，获取字符串中的一部分  
    String substring(begin);//从指定位置到最后  
    String substring(begin,end);//包含开始，不包含结束
4.  将字符串转成全大写或全小写  
    String toUpperCase();  
    String toLowerCase();
5.  将字符串两端的多个空格去除  
    String trim();
6.  对两个字符串按照字典顺序进行比较  
    int compareTo(str);

## 实例验证 ##

class StringDemo{ 
    	public static void main(String[] args) { 
    		test();
    		test1();
    	}
    	public static void test(){ 
    		/*获取*/
    		String str = "adsadsfsdaf";
    		//返回字符串长度
    		sop(str.length());//11
    		//根据位置获取字符
    		sop(str.charAt(4));//d
    		//获取在字符串中的位置
    		sop(str.indexOf('f'));//6
    		sop(str.indexOf("f"));//6
    		sop(str.lastIndexOf("f"));//10
    
    		/*判断*/
    		String str1 = "this is a good job";
    		//包含
    		sop(str1.contains("good"));//true
    		//是否有内容
    		sop(str1.isEmpty());//false
    		//以...开头
    		sop(str1.startsWith("this"));//true
    		//以...结尾
    		sop(str1.endsWith("this"));//false
    		//判断字符串内容是否相同
    		sop(str1.equals(str));//false
    		//忽略大小写判断内容
    		sop(str.equalsIgnoreCase("adsAdsFsDaf"));//true
    
    		/*转换*/
    		//字符数组转换为字符串
    		char[] arr = { 'a','b','c','d'};
    		//String str2 = new String(arr);
    		//String str2 = String.valueOf(arr);
    		String str2 = String.copyValueOf(arr);
    		sop(str2);//"abcd"
    		String str3 = new String(arr,2,2);
    		sop(str3);//cd
    		//字符串转换成数组
    		char[] arr1 = str2.toCharArray();
    		for(int i = 0; i < arr1.length; i++){ 
    			sop(arr1[i]);//a b c d
    		}
    		//将基本数据类型转化为字符串
    		String str4 = String.valueOf(5);
    		sop(str4 instanceof String);//true
    	}
    	public static void test1(){ 
    		String s1 = " hello world ";
    		String s2 = s1.replace("hello","hi");
    		sop(s2);
    		String[] arr = s1.split("o");
    		for(int x = 0; x < arr.length; x++){ 
    			sop(arr[x]);
    		}
    		String s3 = s1.substring(4);
    		sop(s3);
    		String s4 = s1.substring(2,7);
    		sop(s4);
    		String s5 = s1.toUpperCase();
    		sop(s5);
    		String s6 = s1.toLowerCase();
    		sop(s6);
    		String s7 = s1.trim();
    		sop(s7);
    		String str1 = "aaa";
    		String str2 = "abc";
    		sop(str1.compareTo(str2));
    	}
    	public static void sop(Object obj){ 
    		System.out.println(obj);
    	}
    }

test1结果：  
![在这里插入图片描述][20200805135019450.png]

## 字符串操作方法封装 ##

**1、自主封装去除字符串两端空格**

public static String myReverse(String str,int x,int y){ 
    	//转换成数组
    	char[] arr = str.toCharArray();
    	//数组反转
    	reverse(arr,x,y);
    	//数组转换成字符串
    	return new String(arr);
    }

**2、自主封装字符串反转**

public static String myReverse(String str,int x,int y){ 
    	//转换成数组
    	char[] arr = str.toCharArray();
    	//数组反转
    	reverse(arr,x,y);
    	//数组转换成字符串
    	return new String(arr);
    }
    private static void reverse(char[] arr,int x,int y){ 
    	for(int start=x,end=y;start<end;start++,end--)
    		swap(arr,start,end);
    }
    private static void swap(char[] arr,int x,int y){ 
    	char temp = arr[x];
    	arr[x] = arr[y];
    	arr[y] = temp; 
    }

**3、获取字符串中另一个串出现的次数**

public static int getCount(String str,String key){ 
    	int count = 0;
    	int index = 0;
    	while((index=str.indexOf(key,index))!=-1){ 
    		index += key.length();
    		count++;
    	}
    	return count;
    }

**4、获取两个串中的最大相同子串**

public static String getMaxContent(String str1,String str2){ 
    	String max = str1.length()>str2.length()?str1:str2;
    	String min = max==str1?str2:str1;
    	for(int x = 0; x < min.length(); x++){ 
    		for(int y = 0, z = min.length() - x; z!=min.length()+1; y++, z++){ 
    			String temp = min.substring(y,z);
    			if(max.contains(temp))
    				return temp;
    		}
    	}
    	return "";
    }

## StringBuffer类 ##

字符串的组成原理就是通过该类实现的，是**字符串缓冲区**，是一个**容器**  
**特点**

1.  长度可以变化
2.  可以直接操作多个数据类型
3.  最后通过toString方法变成字符串

**相关操作**  
存储

*  StringBuffer append()：将指定数据作为参数添加到已有数据结尾处
 *  StringBuffer insert(index,数据)：将指定数据插入到指定index位置
 *  StringBuffer getChars(int srcBegin,int srcEnd,char\[\] dst,int dstBegin)：将缓冲区制定数据存储到指定字符数组中

获取

*  char charAt(int index)：获取指定位置的字符
 *  int indexOf(String str)：判断是否存在子串
 *  int lastIndexOf(String tr)
 *  int length()：获取长度
 *  String substring(int start, int end)：截取，包含start，不包含end

删除

*  StringBuffer delete(int start,int end)：删除缓冲区中的数据，包含start，不包含end
 *  StringBuffer deleteCharAt(int index)：删除指定位置的字符

修改

*  StringBuffer replace(int start,int end,String str)：替换掉指定位置上的字符
 *  StringBuffer setCharAt(int index,char ch)：替换掉指定位置上的字符

反转

*  StringBuffer reverse()

**实例验证**

class StringBufferDemo{ 
    	public static void main(String[] args) { 
    		//一个容器
    		StringBuffer sb = new StringBuffer();
    		sb.append(true).append("aaa").append(123);
    		sb.insert(1,"mama");
    		sb.toString();//tmamarueaaa123
    		sb.charAt(5);//r
    		sb.indexOf("mama");//1
    		sb.length();//14
    		sb.substring(3,8);//marue
    		sb.delete(3,8);//tmaaaa123
    		sb.deleteCharAt(3);//tmaaa123
    		sb.replace(2,5,"ccc");//tmccc123
    		sb.setCharAt(3,'b');//tmcbc123
    		sb.reverse();//321cbcm
    	}
    }

## StringBuilder ##

JDK1.5版本之后出现的，和StringBuffer用法相同  
唯一区别：  
StringBuffer是线程同步的，需要判断锁，更为安全（适用于多个线程操作同一数据）  
StringBuilder线程不同步（适用于单线程，不需要判断锁，效率更高）

[20200805135019450.png]: /images/20230208/c9394771aab94d74a07c232156dbf889.png