2021-11-09

java字符串操作类

Java中的字符串操作类【String】
　1.String类如何创建对象,有哪些常用方法？
　　String类–不可变的字符串操作类
　　String类–java的jdk提供好的开发类。【java.lang包不用import】
　　String类是使用final修饰符修饰的，说明它没有子类，不可被继承。
　　String类创建对象–构造方法
　　1.String()–创建一个空字符串对象
　　2.String(byte[] bytes, int offset, int length)–字节数组转换成字符串
　　3.String(char[] value, int offset, int count) --字符数组转换成字符串
　　4.String(String original) --字符串常量创建字符串对象
例如:

package com.wangixng.zyb1;
public class StringTest {
	public static void main(String[] args) {
		//1.String()--一个空字符串对象
		String st1=new String();
		//2.String(byte[] byte,int offset,int length)--自洁数组转换成字符串
		//byte[] bytes---字节数组
		//int offset---数组的起始位置
		//int length---被转换的字节数组
		byte bytearr[]= {97,98,99,100};
		String str2=new String(bytearr,0,bytearr.length);
		System.out.println("str2=="+str2);//abcd
		//3.String(char[] value,ing offset,int count)---字符数组转换成字符串
		//char[] value---字符数组
		//int offset---数组的起始位置
		//int count---被转换的字符个数
		char value[]= {'h','e','l','l','o'};
		String str3=new String (value,0,value.length);
		System.out.println("str3=="+str3);
		//4.String (String original)--字符串常量创建字符串对象
		String str4=new String("hello.wolrd");
		//上面的写法可以简化
		String str5="hello,world";
	}
}

package com.wangixng.zyb1;
public class StringTest {
	public static void main(String[] args) {
		String ss1=new String("abc");
		//2个对象 第一个对象"abc"---内存的字符串常量池
		//第二个对象new String("abc")--内存的堆区
		//String str5="hello,world";创建了一个对象，在内存的字符常量池。
	}
}

2.String的常用方法：
　　1.char charAt(int index) 从原始字符串中得到指定位置的字符元素。
　　2.String concat(String str)将指定的字符串连接到该字符串的末尾。
　　3.boolean contains(CharSequence s)判断指定的字符串数据是否在原始字符串中存在
　　4.boolean endsWith(String suffix)测试此字符串是否以指定的后缀结尾。
　　5.boolean startsWith(String prefix)测试此字符串是否以指定的前缀开头。
　　6.byte[] getBytes() 将字符串通过默认的字符编码转换成字节数组
　　　byte[] getBytes(String charsetName)将字符串通过指定的字符编码转换成字节数组
　　7.int indexOf(String str) 返回指定子字符串第一次出现在字符串内的索引位置
　　8.lastIndexOf(String str)返回指定子字符串最后一次出现的字符串中的索引。
　　9.boolean isEmpty()判断字符串是否为空串，此方法为true时，字符串长度一定为0
　　10.int length() 返回此字符串的长度。
　　11.boolean matches(String regex) 判断字符串数据是否符合正则表达式
　　12.String replace(CharSequence old, CharSequence new) 将与字面目标序列匹配的字符串的每个子字符串替换为指定的字面替换序列
　　13.String[] split(String regex)通过指定的符号将字符串拆分成一个字符串数组
　　14.String substring(int beginIndex)截取从指定的开始位置到字符串结尾的一个子字符串
String substring(int beginIndex, int endIndex) 截取从指定的开始位置到指定的结束位置的一个子字符串
　　15.char[] toCharArray() 将此字符串转换为新的字符数组
　　16.String toLowerCase() 大写转小写
　　17.toUpperCase() 小写转大写
　　18.String trim()去除原始字符串的两头空格
例如:

package com.wangixng.zyb1;
public class StringTest2 {
	public static void main(String[] args)throws Exception{
		//创建字符串对象
		String str1=new String("hello,world");
		//1.char charAt(int index) 从原始字符串中得到指定位置的字符元素。
		//System.out.println(str1.charAt(1));//e
		//2.String concat(String str)将指定的字符串连接到该字符串的末尾。
		//String newstr=str1.concat(",你好");
		//String newstr=str1+",你好";
		//System.out.println(newstr);//hello,world,你好
		//3.boolean contains(CharSequence s)判断指定的字符串数据是否在原始字符串中存在
		//System.out.println(str1.contains("hello"));//true
		/*
		//保存姓名的数组
		String names[]= {"张三","李四","王五","张三丰","李思思"};
		//4.boolean endsWith(String suffix)测试此字符串是否以指定的后缀结尾。
		for(String name:names) {
			if(name.endsWith("四")) {
				System.out.println("endsWith=="+name);
			}
		}
		for(String name:names) {
			if(name.startsWith("张")) {
				System.out.println("startsWith=="+name);
			}
		}
		//endsWith==李四
		//startsWith==张三
		//startsWith==张三丰
		//2.String(byte[] bytes, int offset, int length)--字节数组转换成字符串
		byte  bytearr[]={97,98,99,100};
		String  str2=new String(bytearr,0,bytearr.length); //abcd
		//6.byte[] getBytes() 将字符串通过默认的字符编码转换成字节数组
		//  byte[] getBytes(String charsetName)将字符串通过指定的字符编码转换成字节数组 
		//byte bytearr2[]=str2.getBytes();
		byte bytearr2[]=str2.getBytes("utf-8");
		for(byte val:bytearr2){
			System.out.println("val=="+val);
		}
		//val==97
		//val==98
		//val==99
		//val==100
		*/
		//7.int indexOf(String str) 返回指定子字符串第一次出现在字符串内的索引位置
		//System.out.println(str1.indexOf("llo"));//2
		//8.lastIndexOf(String str)返回指定子字符串最后一次出现的字符串中的索引。
		//System.out.println(str1.lastIndexOf("abc"));//-1
		//9.boolean isEmpty()判断字符串是否为空串，此方法为true时，字符串长度一定为0
		//System.out.println(str1.isEmpty());//false
		//10.int length() 返回此字符串的长度。
		//System.out.println(str1.length());//11
		//11.String replace(CharSequence old, CharSequence new) 将与字面目标序列匹配的字符串的每个子字符串替换为指定的字面替换序列
		//System.out.println(str1.replace("hello", "你好"));//你好,world
		//12.String[] split(String regex)通过指定的符号将字符串拆分成一个字符串数组
		//String strarr[]=str1.split(",");
		//System.out.println(strarr[0]);//hello
		//System.out.println(strarr[1]);//hello  //world
		//14.String substring(int beginIndex)截取从指定的开始位置到字符串结尾的一个子字符串
		//System.out.println(str1.substring(str1.indexOf(",")+1));//world
		//String substring(int beginIndex, int endIndex);截取从指定的开始位置到指定的结束位置的一个子字符串
		//System.out.println(str1.substring(0,str1.indexOf(",")));//hello
		//3.String(char[] value, int offset, int count) --字符数组转换成字符串
		//15.char[]  toCharArray() 将此字符串转换为新的字符数组
		char value[]= {'h','e','l','l','o'};
		String str3=new String(value,0,value.length);
		char value2[]=str3.toCharArray();
		for(char val:value2) {
			System.out.println("val=="+val);
		}
		//val==h
		//val==e
		//val==l
		//val==l
		//val==o
		//16.String toLowerCase() 大写转小写
		System.out.println(str1.toLowerCase());//hello,world
		//17.toUpperCase() 小写转大写
		System.out.println(str1.toUpperCase());//HELLO,WORLD		
	}
}

3.字符串与基本类型的转换
　　1.String 转换成基本类型
　　通过基本类型提供的封装类的parseXXX(String str)
　　int parseInt(String str) / double parseDoule(String str)
　　boolean parseBoolean(String str)…
　　上面的这一组parseXXX(String str)方法只能被基本类型的封装类调用。
　　只有基本数据类型才有自己对应的封装类。
　　封装类—基本数据类型对应的复合数据类型
　例如:
　　double dou=12.5; double类型的变量，没有可供使用的方法
　　Double dou=new Double(12.5); Double的对象，有可供使用的变量和方法。
　　Double就是double的封装类

基本类型[变量]	封装类[对象]
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

自动装箱—将基本数据类型转换成对应的封装类类型
　　1.封装类的构造方法
　　2.将基本数据类型变量/数据值直接赋值给对应的封装类变量
　自动拆箱–将封装类类型转成基本数据类型【直接赋值】
例如:

package com.wangixng.zyb1;
public class Main {
	public static void main(String[] args) {
		//String 转换成基本类型--parseXXX(String  str)---基本数据类型的封装类
		//封装类---基本数据类型对应的复合数据类型
		//基本数据类型没有可供使用的方法
		//封装类有可供使用的变量和方法。
		//自动装箱---将基本数据类型转换成对应的封装类类型
		//1.封装类的构造方法
		Integer int1=new Integer(100);
		int  a=100;
		Integer int2=new Integer(a);
		//2.将基本数据类型变量/数据值直接赋值给对应的封装类变量
		Integer int11=100;
		int  a2=100;
		Integer int22=a;
		//自动拆箱--将封装类类型转成基本数据类型【直接赋值】
		Double dou1=new Double(12.5);
		double  dou2=dou1;
		//我们可以通过基本数据类型的封装类的静态方法parseXXX(String  str)将字符串转换成基本类型
		String  str1="12.5";
		double dou3=Double.parseDouble(str1);
		System.out.println(dou3+1);
		String boo1="true";
		boolean  boo2=Boolean.parseBoolean(boo1);
		if(boo2){
			System.out.println("基本类型");
		}else{
			System.out.println("字符串类型");
		}
		//将基本数据类型转换成String【static String valueOf(基本数据类型的数据值/变量)】
		int num1=100;
		String str01=String.valueOf(num1);
		System.out.println(str01.length());
		double dou01=12.5;
		String str02=String.valueOf(dou01);
	}
}

基本数据类型与对应封装类的区别

基本数据类型	封装类
基本类型	类
变量，没可供调用的方法和变量	构造出来都是对象，提供了变量和方法
只在内存的栈区有数据分配	内存的栈区和堆区都有内存分配
有各自默认的数据值 int—0	默认值为null Integer—null

2.基本类型转换成String
　　将基本数据类型转换成String【static String valueOf(基本数据类型的数据值/变量)】
例如:

4.String类与字节数组或者字符数组之间的相互转换
　　　String类与字节数组
　　1.String类转换成字节数组----
　　　String类的”byte[] getBytes()”/”byte[] getBytes(String charsetName)”
　　2.字节数组转换String类型----
　　　String类的构造方法String(byte[] bytes, int offset, int length)
　　　String类与字符数组
　　3.String类转换成字符数组----
　　　String类的”char[] toCharArray()”
　　4.字符数组转换String类型----
　　　String类的构造方法”String(char[] value, int offset, int count)”
　5.字符串操作类StringBuilder、StringBuffer
　　StringBuilder— 一个可变的字符序列
　　StringBuilder() 构造一个初始容量为16个字符的空StringBuilder对象。
　　StringBuilder(CharSequence seq)通过其他的StringBuilder对象创建一个新的StringBuilder对象
　　StringBuilder(int capacity) 构造一个由 capacity参数指定的初始容量得空StringBuilder对象
　　StringBuilder(String str) 构造一个初始化为指定字符串内容的StringBuilder对象。
　　int capacity() 返回当前容量。
　　char charAt(int index) 返回 char在指定索引在这个字符值。
　　int indexOf(String str) 返回指定子字符串第一次出现的字符串内的索引。
　　int lastIndexOf(String str) 返回指定子字符串最右边出现的字符串内的索引。
　　int length() 返回长度（字符数）。
　　StringBuilder append(Object o) 将参数的字符串表示追加到序列中。
　　StringBuilder delete(int start, int end) 删除此序列的子字符串中的字符。
　　StringBuilder deleteCharAt(int index) 删除 char在这个序列中的指定位置。
　　StringBuilder insert(int offset, Object o) 将参数的字符串表示插入到此序列中指定的位置。
　　StringBuilder reverse() 导致该字符序列被序列的相反代替。
　　StringBuilder replace(int start, int end, String str) 用指定的String中的字符替换此序列的子字符串中的 String 。
　　String substring(int start) 返回一个新的 String ，其中包含此字符序列中当前包含的字符的子序列。
　　String substring(int start, int end) 返回一个新的 String ，其中包含此序列中当前包含的字符的子序列。
　　String toString() 返回表示此顺序中的数据的字符串。
例如:

package com.wangixng.zyb2;
public class StringBuiderTest1 {
	public static void main(String[] args) {
		//StringBuilder() 构造一个初始容量为16个字符的空StringBuilder对象。 
		StringBuilder  sbu1=new StringBuilder();
		//StringBuilder(CharSequence seq)通过其他的StringBuilder对象创建一个新的StringBuilder对象
		StringBuilder  sbu2=new StringBuilder("hello,world");
		//StringBuilder(int capacity) 构造一个由 capacity参数指定的初始容量得空StringBuilder对象
		StringBuilder  sbu3=new StringBuilder(23);
		//StringBuilder(String str) 构造一个初始化为指定字符串内容的StringBuilder对象。
		String str="hello,world";
		StringBuilder sbu4=new StringBuilder(str);
		//StringBuilder	append(Object o) 将参数的字符串表示追加到序列中。 
		System.out.println(sbu1.capacity());//16
		sbu1.append("12345678901234567");
		//int	capacity() 返回当前容量。 
		//StringBuilder容量扩展规则==当前容量*2+2
		System.out.println(sbu1.capacity());//34
		//char	charAt(int index) 返回 char在指定索引在这个字符值。
		//StringBuilder	delete(int start, int end) 删除此序列的子字符串中的字符。 
		System.out.println(sbu1.delete(0,2));//345678901234567
		//StringBuilder	deleteCharAt(int index) 删除 char在这个序列中的指定位置。 
		System.out.println(sbu1.deleteCharAt(5));//34567901234567
		//int	indexOf(String str) 返回指定子字符串第一次出现的字符串内的索引。 
		//int	lastIndexOf(String str) 返回指定子字符串最右边出现的字符串内的索引。
		//StringBuilder	insert(int offset, Object o) 将参数的字符串表示插入到此序列中指定的位置。
		System.out.println(sbu1.insert(5,"6"));//345676901234567
		//int	length() 返回长度（字符数）。 
		System.out.println(sbu1.length());//15
		//StringBuilder	reverse() 导致该字符序列被序列的相反代替。
		System.out.println(sbu1.reverse());//765432109676543
		//StringBuilder	replace(int start, int end, String str) 用指定的String中的字符替换此序列的子字符串中的 String 。
		System.out.println(sbu1.replace(0,5,"hello"));//hello2109676543
		//String	substring(int start) 返回一个新的 String ，其中包含此字符序列中当前包含的字符的子序列。 
		//String	substring(int start, int end) 返回一个新的 String ，其中包含此序列中当前包含的字符的子序列。 
		//String	toString() 返回表示此顺序中的数据的字符串。
	}
}

StringBuilder与String得转换
StringBuilder–》String
StringBuilder的toString();
String的构造方法String(StringBuilder builder)
String–>StringBuilder
StringBuilder的构造方法
StringBuffer类与StringBuilder类相似
StringBuffer类的构造方法
StringBuffer() 构造一个初始容量为16个字符的空StringBuffer对象。
StringBuffer(CharSequence seq) 通过其他的StringBuffer对象创建一个新的StringBuffer对象
StringBuffer(int capacity) 构造一个由 capacity参数指定的初始容量得空StringBuffer对象。
StringBuffer(String str) 构造一个初始化为指定字符串内容的StringBuffer对象。
StringBuffer类的方法
StringBuffer append(Object o) 将参数的字符串表示追加到序列中。
int capacity() 返回当前容量。
char charAt(int index) 返回 char在指定索引在这个字符值。
StringBuffer delete(int start, int end) 删除此序列的子字符串中的字符。
StringBuffer deleteCharAt(int index) 删除 char在这个序列中的指定位置。
int indexOf(String str) 返回指定子字符串第一次出现的字符串内的索引。
int lastIndexOf(String str) 返回指定子字符串最右边出现的字符串内的索引。
StringBuffer insert(int offset, Object o) 将参数的字符串表示插入到此序列中指定的位置。
int length() 返回长度（字符数）。
StringBuffer reverse() 导致该字符序列被序列的相反代替。
StringBuffer replace(int start, int end, String str) 用指定的String中的字符替换此序列的子字符串中的 String 。
String substring(int start) 返回一个新的 String ，其中包含此字符序列中当前包含的字符的子序列。
String substring(int start, int end) 返回一个新的 String ，其中包含此序列中当前包含的字符的子序列。
String toString() 返回表示此顺序中的数据的字符串。

package com.wangixng.zyb2;
public class StringBufferTest1 {
	public static void main(String[] args) {
		//StringBuffer() 构造一个初始容量为16个字符的空StringBuffer对象。 
		StringBuffer  sbu1=new StringBuffer();
		//StringBuffer(CharSequence seq)通过其他的StringBuffer对象创建一个新的StringBuffer对象
		StringBuffer  sbu2=new StringBuffer("hello,world");
		//StringBuffer(int capacity) 构造一个由 capacity参数指定的初始容量得空StringBuffer对象
		StringBuffer  sbu3=new StringBuffer(23);
		//StringBuffer(String str) 构造一个初始化为指定字符串内容的StringBuffer对象。
		String str="hello,world";
		StringBuffer sbu4=new StringBuffer(str);
		//StringBuffer	append(Object o) 将参数的字符串表示追加到序列中。 
		System.out.println(sbu1.capacity());//16
		sbu1.append("12345678901234567");
		//int	capacity() 返回当前容量。 
		//StringBuffer容量扩展规则==当前容量*2+2
		System.out.println(sbu1.capacity());//34
		//char	charAt(int index) 返回 char在指定索引在这个字符值。
		//StringBuffer	delete(int start, int end) 删除此序列的子字符串中的字符。 
		System.out.println(sbu1.delete(0,2));//345678901234567
		//StringBuffer	deleteCharAt(int index) 删除 char在这个序列中的指定位置。 
		System.out.println(sbu1.deleteCharAt(5));//34567901234567
		//int	indexOf(String str) 返回指定子字符串第一次出现的字符串内的索引。 
		//int	lastIndexOf(String str) 返回指定子字符串最右边出现的字符串内的索引。
		//StringBuffer	insert(int offset, Object o) 将参数的字符串表示插入到此序列中指定的位置。
		System.out.println(sbu1.insert(5,"6"));//345676901234567
		//int	length() 返回长度（字符数）。 
		System.out.println(sbu1.length());//15
		//StringBuffer	reverse() 导致该字符序列被序列的相反代替。
		System.out.println(sbu1.reverse());//765432109676543
		//StringBuffer	replace(int start, int end, String str) 用指定的String中的字符替换此序列的子字符串中的 String 。
		System.out.println(sbu1.replace(0,5,"hello"));//hello2109676543
		//String	substring(int start) 返回一个新的 String ，其中包含此字符序列中当前包含的字符的子序列。 
		//String	substring(int start, int end) 返回一个新的 String ，其中包含此序列中当前包含的字符的子序列。 
		//String	toString() 返回表示此顺序中的数据的字符串。
	}
}

StringBuffer与String得转换
StringBuffer–》String
StringBuffer的toString();
String的构造方法String(StringBuffer buffer)
String–>StringBuffer
StringBuffer的构造方法
StringBuilder与StringBuffer的区别?
StringBuilder–一个可变的字符序列,不保证线程同步【线程安全】. 访问速度快 jdk1.5
StringBuffer—一个可变的字符序列,保证线程安全. 访问速度慢 JDK1.0

String与StringBuilder/StringBuffer的区别?

	String	StringBuilder	StringBuffer
可变与否	不可变	可变	可变
线程安全与否	非线程安全	非线程安全	线程安全
运行速度	慢	快	较快
操作的情况	少量的字符串操作[拼接]的情况	单线程下字符串操大量操作的情况	多线程下字符串操 大量操作的情况

＂= =＂ 与 equals方法的区别。

==	equals
比较运算符	java.lang.Object中的方法
基本类型:比较数据值	不能被比较
复合类型:堆内存地址【引用地址】	复合类型:堆内存地址【引用地址】
	如果被重写比较的是存储对象的内容[String]

package com.wangxing.zyb3;
public class Student {
}

package com.wangxing.zyb3;
public class Main {
	public static void main(String[] args) {
		 Student stu1=new Student(); 
		 Student stu2=new Student();
		 //System.out.println(stu1==stu2);//false
		 //System.out.println(stu1.equals(stu2));//false
		 //stu1=stu2;
		 //System.out.println(stu1==stu2);//true
		 //System.out.println(stu1.equals(stu2));//true
		 String str1=new String("hello");	
		 String str2=new String("hello");	
		 System.out.println(str1==str2);//false
		 System.out.println(str1.equals(str2));//true
	}
}