本文详细介绍了Java中的StringBuffer类，包括其线程安全的特性、构造方法和主要方法，如append、insert、delete、replace和reverse。此外，还提到了StringBuilder类，它是非线程安全但效率更高的选择。内容涵盖了两者之间的转换、性能比较，以及在参数传递中的行为。还讲解了StringJoiner的使用，并简述了基本类型包装类的作用，特别是Integer类的构造方法和字符串与整型间的转换方法。
StringBuffer类的概述
- StringBuffer类概述
我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuffer就可以解决这个问题 - 线程安全的可变字符序列
StringBuffer类的构造方法
- StringBuffer的构造方法：
public StringBuffer(): 无参构造方法
public StringBuffer(int capacity): 指定容量的字符串缓冲区对象
public StringBuffer(String str): 指定字符串内容的字符串缓冲区对象 - StringBuffer的方法：
public int capacity()：返回当前容量。 理论值
public int length():返回长度（字符数）。 实际值
案例演示
- 调用StringBuffer类的无参构造方法
package demo1;
public class Demo1 {
public static void main(String[] args) {
//StringBuffer 可变字符序列，长度是可变的。
// String 一旦定义他的值就不能被改变。
// StringBuffer 可以认为是一个字符容器，你可以不断的往容器中追加内容。
// StringBuffer()
// 构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。
StringBuffer sb = new StringBuffer();
System.out.println(sb.capacity());//获取容量
sb.append("abcdn");
System.out.println(sb.length());//获取容器中字符的长度
}
}
- 调用StringBuffer类的有参构造方法
package demo1;
public class Demo2 {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer(100);
System.out.println(s1.capacity());
StringBuffer s2 = new StringBuffer("hello");
System.out.println(s2.toString());//toString（）来获取字符串
}
}
- 链式编程
package demo1;
public class Demo3 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
//往字符串缓冲区中追加内容,返回的还是原来的那个对象
StringBuffer sb2 = sb.append("abc");
System.out.println(sb == sb2); //true
//因为我们调用完append()方法后，返回的还是那个对象，所以我就可以链式编程。
sb.append(100).append(true).append(3.14);
//StringBuffer 重写了toString方法，会把他容器中的内容转换成字符串
String s = sb.toString();
System.out.println(s);
}
}
StringBuffer的添加功能
- public StringBuffer append(String str): 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身
- public StringBuffer insert(int offset,String str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
- 案例演示
public class MyTest3 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("aaa").append("bbb");
//可以在指定位置，追加内容，返回的还是原来的那个容器
StringBuffer sb2 = sb.insert(0, "0000000");
System.out.println(sb == sb2);
System.out.println(sb.toString());
}
}
StringBuffer的删除功能
- StringBuffer的删除功能
public StringBuffer deleteCharAt(int index):删除指定位置的字符，并返回本身
public StringBuffer delete(int start,int end):删除从指定位置开始指定位置结束的内容，并返回本身
案例演示
public class MyTest4 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("西部开源教育科技有限公司");
//根据索引一次删除容器中的一个字符，返回的还是容器本身
sb.deleteCharAt(0);
System.out.println(sb.toString());
//可以根据起始索引和终止索引，删除容器中的一段内容，返回的还是容器本身
sb.delete(0, 3); //含头不含尾
System.out.println(sb.toString());
}
}
StringBuffer的替换和反转功能
- StringBuffer的替换功能
public StringBuffer replace(int start,int end,String str): 从start开始到end用str替换 - StringBuffer的反转功能
public StringBuffer reverse(): 字符串反转 - 案例演示
public class MyTest {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("西部开源教育科技有限公司");
//根据起始索引和终止索引，替换容器中的内容，返回的还是容器本身
sb.replace(0, 4, "天天向上"); //含头不含尾
System.out.println(sb.toString());
//反转容器中的内容，返回的还是容器本身
sb.reverse();
System.out.println(sb.toString());
}
}
把数组转成字符串
案例演示
- 需求：把数组中的数据按照指定个格式拼接成一个字符串
举例：
int[] arr = {1,2,3};
输出结果：
“[1, 2, 3]”
用StringBuffer的功能实现
public class Demo4 {
public static void main(String[] args) {
int [] arr={1,2,3};
StringBuffer s1 = new StringBuffer("{");
for (int i = 0; i < arr.length; i++) {
if(i==arr.length-1){
s1.append(arr[i]).append("}");
}else{
s1.append(arr[i]).append(",");
}
}
System.out.println(s1.toString());
}
}
字符串反转
案例演示
- 需求：把字符串反转
举例：键盘录入"abc"
输出结果：“cba”
用StringBuffer的功能实现
package demo1;
import java.util.Scanner;
public class Demo5 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入字符串");
String s = sc.nextLine();
StringBuffer s1 = new StringBuffer(s);
System.out.println(s1.reverse().toString());
}
}
StringBuilder的概述
String,StringBuffer,StringBuilder的区别
-
StringBuffer :线程安全的可变字符序列,线程安全效率低一些。
一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。
该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。 -
StringBuilder :线程不安全的可变字符序列。线程不安全效率高一些。
StringBuffer和String的相互转换
- String – StringBuffer
a:通过构造方法
b:通过append()方法 - StringBuffer – String
a: 使用substring方法
b:通过构造方法
c:通过toString()方法 - 案例演示
StringBuffer和String的相互转换
public class Demo6 {
public static void main(String[] args) {
//StringBuffer – String
StringBuffer sb3 = new StringBuffer("aaaa");
String s = sb3.toString();
System.out.println(s);
String s2 = sb3.substring(0);
System.out.println(s2);
String s1 = new String(sb3);
System.out.println(s1);
//String----StringBuffer
String str = "abc";
StringBuffer sb = new StringBuffer(str);
StringBuffer sb2 = new StringBuffer().append(str);
}
}
String和StringBuffer分别作为参数传递
- 形式参数问题
String作为参数传递 String虽然是引用类型,但是它是一个常量,所以在做传递的时候,完全可以将其看成基本数据类型数据进行传递，String类型输入值传递
StringBuffer作为参数传递 - 案例演示
String和StringBuffer分别作为参数传递问题
public class MyTest {
public static void main(String[] args) {
//引用类型作为参数传递，属于引用传递，传递的是地址值，形参的改变会影响实参。
//String类比较特殊，他作为参数传递，属于值传递，传递的是字符串的值，形参的改变不影响实参
//基本类型作文参数传递，属于值传递，传递的是值，形参的改变不影响实参。
String str = "hello";
test(str);
System.out.println(str); //2.hello
StringBuffer sb = new StringBuffer("abc");
test(sb);
System.out.println(sb); //3.bbbcba
}
private static void test(String str) {
str += "wolrd";
System.out.println(str); //1.helloworld
}
private static void test(StringBuffer sb) {
sb.append("bbb").reverse();
}
}
StringJoiner
- StringJoiner(CharSequence delimiter)
构建了一个字符容器，指定分隔符 - StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
构建了一个字符容器，指定分隔符，前缀，后缀 - 案例演示
public class MyTest2 {
public static void main(String[] args) {
/* A:
案例演示
需求：把数组中的数据按照指定个格式拼接成一个字符串
举例：
int[] arr = {1, 2, 3};
输出结果：
"[1, 2, 3]"*/
int[] arr = {1, 2, 3, 4, 5, 9};
StringJoiner joiner = new StringJoiner(",", "[", "]");
for (int i = 0; i < arr.length; i++) {
joiner.add(arr[i] + "");
}
String s = joiner.toString();
System.out.println(s);
StringJoiner joiner1 = new StringJoiner("-", "[", "]");
String s1 = joiner1.add("张三").add("李四").add("王五").toString();
System.out.println(s1);
}
}
基本类型包装类的概述
- 为什么会有基本类型包装类
为了对基本数据类型进行更多的操作,更方便的操作,java就针对每一种基本数据类型提供了对应的类类型. - 常用操作: 常用的操作之一：用于基本数据类型与字符串之间的转换。
- 基本类型和包装类的对应
byte ---------------- Byte
short ---------------- Short
int ---------------- Integer
long ---------------- Long
float ---------------- Float
double ---------------- Double
char ---------------- Character
boolean ---------------- Boolean
Integer类的概述和构造方法
-
Integer类概述
通过JDK提供的API，查看Integer类的说明Integer 类在对象中包装了一个基本类型 int 的值,
该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，
还提供了处理 int 类型时非常有用的其他一些常量和方法 -
构造方法
public Integer(int value)
public Integer(String s) //要个一个字面上是数字的字符串，如果不是就会报错
String和int类型的相互转换
- int – String
a:和""进行拼接
b:public static String valueOf(int i)
c:int – Integer – String
推荐方式：d:public static String toString(int i) - String – int
a:String – Integer – intValue();
推荐方式：b:public static int parseInt(String s) - 案例演示
public class MyTest3 {
public static void main(String[] args) {
int num = 100;
//100-----"100"
//方式1：拼接空串
String str = num + "";
String s2 = String.valueOf(num);
String s = new Integer(num).toString();
System.out.println(s);
//"100"----100
String str2 = "100";
//推荐的方式
int i = Integer.parseInt(str2); //NumberFormatException: For input string: "100a"
System.out.println(i);
Integer integer = new Integer(str2);
int i1 = integer.intValue();
System.out.println(i1);
}
}
- Integer的面试题
public class MyTest5 {
public static void main(String[] args) {
Integer i7 = 127;
Integer i8 = 127;
System.out.println(i7 == i8); //true
Integer i5 = 128;// Integer.valueOf(100); new Integer(128);
Integer i6 = 128; //Integer.valueOf(100); new Integer(128);
System.out.println(i5 == i6); //false
//Integer i5 = 128; 这种方式用的是自动装箱，底层用的是 Integer integer = Integer.valueOf(100);
Integer.valueOf(100);
/*
* Integer类里面有一个内部类：IntegerCache 这个内部类有一个数组，Integer cache[];
*
*IntegerCache内部类一加载 他的静态代码块中就会创建 256个Integer对象放到他维护的这个数组里面Integer cache[];
*
* 当你采用 Integer i7 = 127; 这种方式 底层 调用 Integer.valueOf(127);方法
*
* valueOf(127)方法的源码如下：
* public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high){
return IntegerCache.cache[i + (-IntegerCache.low)];
}
return new Integer(i);
}
你包装的这个值 在 -128---127 这个范围 会从Integer cache[];数组中返回一个对象给你
如果不在就会创建一个新的返回给你
*
* */
}
}
扫一扫
166
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
