1、线程安全：不安全，存在同步 *** 作同一数据的行为，效率高。安全的时候，没有同步 *** 作，效率低。
2、StringBuffer是一个可变序列。
3、StringBuffer又被称为字符缓冲区，把它当成一个字符串去 *** 作，只不过它与string相比是可以修改内容的。
4、在任何时间点，它包含着一些特定的字符序列，但是可以通过某些字符序列的长度和内容。
StringBuffer与String的区别：
1、StringBuffer的内容和长度都是可以改变的，String却不可以。
2、String创建每一个字符串都会在常量池开辟一个新的空间。而StringBuffer会提前给出容量，可以重新进行字符串拼接，而不会重新开辟空间。
StringBuffer的构造方法：
public StringBuffer();构造一个没有字符的字符串缓冲区，初始容量为16字符。
public StringBuffer(int capacity);构造一个没有字符的字符串缓冲区和指定的初始容量。
public StringBuffer(String str);构造一个初始化为指定内容的字符串缓冲区。
package com.one;
public class StringDemo {
public static void main(String[] args) {
//public StringBuffer() 构造一个没有字符的字符串缓冲区，初始容量为16个字符。
StringBuffer sb1 = new StringBuffer();
System.out.println("sb1:" + sb1); //StringBuffer重写了toString方法
//如何获取StringBuffer的容量
//public int capacity()返回当前容量。
System.out.println("当前StringBuffer的容量为：" + sb1.capacity());
//public int length()返回长度（字符数）。
System.out.println("StringBuffer中字符串的长度为：" + sb1.length());
System.out.println("===================================================");
//public StringBuffer(int capacity) 构造一个没有字符的字符串缓冲区和指定的初始容量。
StringBuffer sb2 = new StringBuffer(50);
System.out.println("sb2:" + sb2); //StringBuffer重写了toString方法
//如何获取StringBuffer的容量
//public int capacity()返回当前容量。
System.out.println("当前StringBuffer的容量为：" + sb2.capacity());
//public int length()返回长度（字符数）。
System.out.println("StringBuffer中字符串的长度为：" + sb2.length());
System.out.println("===================================================");
//public StringBuffer(String str) 构造一个初始化为指定字符串内容的字符串缓冲区。
StringBuffer sb3 = new StringBuffer("hello");
System.out.println("sb3:" + sb3); //StringBuffer重写了toString方法
//如何获取StringBuffer的容量
//public int capacity()返回当前容量。
System.out.println("当前StringBuffer的容量为：" + sb3.capacity()); // 21 = 16 + 5
//public int length()返回长度（字符数）。
System.out.println("StringBuffer中字符串的长度为：" + sb3.length()); // 5
}
}
StringBuffer的添加功能：
public StringBuffer append(String str)
通过API发现不仅可以追加字符串，还可以是任意数据类型的数据追加到StringBuffer中；
返回StringBuffer是：public StringBuffer insert(int index,String str)
public class StringDemo {
public static void main(String[] args) {
//创建一个StringBuffer对象
StringBuffer sb = new StringBuffer();
//public StringBuffer append(String str)
StringBuffer stringBuffer = sb.append("hello");
System.out.println(stringBuffer);
System.out.println(sb);
System.out.println(sb == stringBuffer);
// sb.append(10);
// sb.append('a');
// sb.append(true);
// sb.append(12.34);
// //无论追加的数据是什么类型，一旦进入到StringBuffer中就是成了字符串
// System.out.println(sb);
// System.out.println(stringBuffer);
//链式编程追加
sb.append(10).append('a').append(true).append(12.34);
System.out.println(sb);
System.out.println("===============================================");
//hello10atrue12.34
//public StringBuffer insert(int offset,String str)
// 将字符串插入到此字符序列中。返回的是字符串缓冲区本身
//String参数的String按顺序插入到指定偏移量的该序列中，向上移动原始位于该位置的任何字符，
// 并将该序列的长度增加到参数的长度。
sb.insert(5, "hadoop");
System.out.println(sb);
// 如果str是null ，则四个字符"null"被插入到该序列中。
// sb.insert(5,null);
Object o = null;
sb.insert(5, o);
System.out.println(sb);
}
}
StringBuffer的删除功能：
public StringBuffer delateCharAt(int index);删除指定索引处的字符，
public StringBuffer delate(int start,int end);
public class StringDemo {
public static void main(String[] args) {
//使用带参数的构造方法创建StringBuffer对象
StringBuffer sb = new StringBuffer("bigdata");
System.out.println("未做删除 *** 作之前的StringBuffer:" + sb);
// StringBuffer sb2 = sb.deleteCharAt(3); // *** 作的是同一个StringBuffer对象
// System.out.println(sb);
// System.out.println(sb2);
// System.out.println(sb==sb2);
sb.deleteCharAt(3);
System.out.println("做删除 *** 作之后的StringBuffer:" + sb);
//如果 index为负数或大于或等于length() 。
//index的值最大可以取到实际存储字符串的长度-1
// sb.deleteCharAt(30);
// sb.deleteCharAt(6);
System.out.println("===============================================");
//public StringBuffer delete(int start,int end)
//删除此序列的子字符串中的字符。
// 子串开始于指定start并延伸到字符索引end - 1 ，或如果没有这样的字符存在的序列的结束。
// 如果start等于end ，则不作任何更改。
// start<=index
StringBuffer的替换功能：
public StringBuffer replace(int start,int end,String str)
用指定的String中的字符替换子字符串中的String
字串开始于指定start并延伸到索引end-1，或如果没有这样的字符存在的序列而结束。第一字串中的的字符被去除，然后指定String被插入在start。
public class StringDemo {
public static void main(String[] args) {
//创建一个StringBuffer对象
StringBuffer sb = new StringBuffer();
//往StringBuffer中添加一些内容
sb.append("java").append("mysql").append("hadoop").append("hive").append("spark").append("flink");
System.out.println(sb);
//public StringBuffer replace(int start,int end,String str)
sb.replace(5,10,"数加学院真好");
System.out.println(sb);
}
}
StringBuffer的反转功能：
public StringBuffer reverse()
导致改字符序列被相反的序列代替。如果字符串包含任何替代对，则将他们是为单个字符进行反向 *** 作。
public class StringDemo {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("我爱你中国");
System.out.println("反转之前：" + sb);
System.out.println("反转之后：");
StringBuffer sb2 = sb.reverse(); // *** 作的是同一个StringBuffer对象
System.out.println(sb);
System.out.println(sb2);
}
}
StringBuffer的截取功能：
public StringBuffer substring(int start)
返回一个新的String,其中包含此序列中当前包含的字符的子序列
public StringBuffer substring(int start,int end)
返回一个新的String，其中包含此序列中当前包含的字符的子序列，字串起始于指定的start,并扩展到索引为end-1;
public class StringDemo {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("java")
.append("mysql")
.append("hive")
.append("ETL")
.append("spark");
System.out.println(sb);
//public String substring(int start)
//不会改变原来StringBuffer中的数据
//返回值是一个String类型的数据
String s1 = sb.substring(4);
System.out.println("截取的内容是："+s1);
// mysqlhiveETLspark
System.out.println("StringBuffer的内容为："+sb);
//StringBuffer的内容为：javamysqlhiveETLspark
//public String substring(int start,int end) 含头不含尾 [start,end)
//javamysqlhiveETLspark
String s2 = sb.substring(9, 13);
System.out.println("截取的内容是："+s2);
// 截取的内容是：hive
System.out.println("StringBuffer的内容为："+sb);
//StringBuffer的内容为：javamysqlhiveETLspark
}
}
String与StringBuffer之间的转换:
为什么要进行转换：A—>B,是为了使用B中的特殊功能，B—>A，可能是需要的最终结果是A类型的数据。
public static void main(String[] args) {
//String --> StringBuffer
String s = "hello";
// StringBuffer sb = s;
//java: 不兼容的类型: java.lang.String无法转换为java.lang.StringBuffer
// StringBuffer sb = "hello";
//方式1：通过构造方法转换
StringBuffer sb1 = new StringBuffer(s);
System.out.println(s);
System.out.println(sb1);
//方式2：通过append()
StringBuffer sb2 = new StringBuffer();
sb2.append(s);
System.out.println(s);
System.out.println(sb2);
System.out.println("==============================================");
//StringBuffer --> String
StringBuffer sb3 = new StringBuffer("bigdata");
//方式1：toString()方法
String s1 = sb3.toString();
System.out.println(sb3);
System.out.println(s1);
//方式2：subString
String s2 = sb3.substring(0);
System.out.println(s2);
System.out.println(sb3);
//方式3：String类的构造方法
//String(StringBuffer buffer)
//分配一个新的字符串，其中包含当前包含在字符串缓冲区参数中的字符序列。
String s3 = new String(sb3);
System.out.println(s3);
System.out.println(sb3);
}
}
String、StringBuffer和StringBulider之间的区别：
1、StringBuffer是线程同步安全的，数据安全，效率低。Stringbulider不是线程同步安全的，数据不安全，效率高。
2、String的内容是不可改变的，StringBuffer和StringBulider是可变序列。
3、StringBuffer上有synchronized关键字。
StringBuffer和数组之间的区别：
它们都可以看作是一个容器，装一些数据
但是，StringBuffer里面是一个一个字符
数组可以存放不同类型的数据，但StringBuffer只能存放一种数据。
探究String作为参数传递与StringBuilder作为参数传递的区别：
public static void main(String[] args) {
// //创建一个StringBuffer的对象
// StringBuffer stringBuffer = new StringBuffer();
// //创建一个StringBuilder的对象
// StringBuilder stringBuilder = new StringBuilder();
String s1 = "hello";
String s2 = "world";
System.out.println("s1: " + s1 + ",s2: " + s2);
change(s1, s2);
System.out.println("s1: " + s1 + ",s2: " + s2);
System.out.println("========================================");
StringBuffer sb1 = new StringBuffer("hello");
StringBuffer sb2 = new StringBuffer("world");
System.out.println("sb1: " + sb1 + ",sb2: " + sb2); // hello world
change(sb1, sb2);
System.out.println("sb1: " + sb1 + ",sb2: " + sb2); // sb1: hellow,sb2: worldworld
//当多个StringBuffer作为参数传参的时候，谁发生了 *** 作，谁就会受到影响‘
}
public static void change(StringBuffer sb1, StringBuffer sb2) {
sb1 = sb2;
sb2.append(sb1);
System.out.println("sb1: " + sb1 + ",sb2: " + sb2);
//sb1: worldworld,sb2: worldworld
}
public static void change(String s1, String s2) {
s1 = s2;
s2 = s1 + s2;
System.out.println("s1: " + s1 + ",s2: " + s2);
}
}
把数组拼接成一个字符串（用StringBuffer实现）：
public class StringDemo {
public static void main(String[] args) {
char[] chars = {'a','b','c','d'};
//创建一个空的StringBuffer对象
StringBuffer sb = new StringBuffer();
//遍历数组得到每一个字符
for(int i=0;i
字符反转（键盘录入字符）：
public class StringBufferTest2 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入字符串：");
String stringLine = sc.next();
//方式1：使用String的拼接方式
String s = "";
//将字符串转换成字符数组
char[] chars = stringLine.toCharArray();
//倒着遍历字符数组
for (int i = chars.length - 1; i >= 0; i--) {
s += chars[i];
}
System.out.println(stringLine + "反转之后的结果为：" + s);
System.out.println("========================================");
//方式2：StringBuffer中有一个reverse()方法实现
//将输入的String类型的数据转换成StringBuffer类型
StringBuffer sb = new StringBuffer(stringLine);
sb.reverse();
//将StringBuffer类型转换回去String类型
String s1 = sb.toString();
System.out.println(stringLine + "反转之后的结果为：" + s1);
System.out.println("=====================链式编程改进：=====================");
System.out.println(new StringBuffer(stringLine).reverse().toString());
}
}
判断一个字符串是否对称字符串：
例如"abc"不是的，“aba”、“anbna"、"abbc"是对称字符串；
分析：
第一个与最后一个比较，第二个与倒数第二个去比较……
比较的次数为：length/2取整
import java.util.Scanner;
public class StringBufferTest3 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入要判断的字符串：");
String stringLine = sc.next();
//方式1：一个一个的去比较
//将输入的字符串转化成字符数组
boolean flag = true;
char[] chars = stringLine.toCharArray();
for (int start = 0, end = chars.length - 1; start <= end; start++, end--) {
if (chars[start] != chars[end]) {
System.out.println("该字符串不是对称字符串");
flag = false;
break;
}
}
if(flag){
System.out.println("该字符串是对称字符串");
}
System.out.println("=========================================================");
//方式2：利用StringBuffer中反转方法，如果反转之前与反转之后的字符串是一样的，说明是对称字符串
//将输入的String类型的数据转化成StringBuffer类型的数据
StringBuffer sb = new StringBuffer(stringLine);
sb.reverse();
//再将反转后的StringBuffer类型的数据转换成String类型的数据
String s = sb.toString();
if(s!=null){
if(s.equals(stringLine)){
System.out.println("该字符串是对称字符串");
}else {
System.out.println("该字符串不是对称字符串");
}
}
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）