Java面向对象-常用类（String 、StringBuffer 、StringBuilder的使用与深入）

最新推荐文章于 2024-06-10 21:57:08 发布

可可西不理

最新推荐文章于 2024-06-10 21:57:08 发布

阅读量367

点赞数 10

文章标签： java

本文链接：https://blog.csdn.net/weixin_47234283/article/details/139160259

版权

常用类-字符串相关类

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
		
	}
}

可可西不理

关注

10
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java面向对象-常用类（String 、StringBuffer 、StringBuilder的使用与深入）

String是不可变类, 即一旦一个String对象被创建, 包含在这个对象中的字符序列是不可改变的, 直至该对象被销毁。String类是final类，不能有子类。
复制链接

扫一扫