5.1 String类
5.1.1 声明字符串
字符串是常量,它们可以显示任何文字信息,字符串的值在创建之后不能更改。在Java语言中,单引号中的内容表示字符,例如's',而双引号中的内容则表示字符串,例如:
"我是字符串”,"123456789" ," 上下左右东西南北”
Java通过java lang String这个类来创建可以保存字符串的变量,所以字符串变量是一个对象。声明一个字符串变量a,以及声明两个字符串变量a、b。代码如下:
String a;
String a,b;
注意:
在不给字符串变量赋值的情况下,默认值为null,就是空对象,如果此时调用String的方法会发生空指针异常。
5.1.2 创建字符串
1.引用字符串常量
例如,直接将字符串常量赋值给String类型变量。代码如下:
String a = "时间就是金钱,我的朋友。";
String b = "锄禾日当午",c = "小鸡炖蘑菇";
String str1, str2;
str1=. "We are students";
srt2 = "We are students";
当两个字符串对象引用相同的常量时,就具有相同的实体,内存示意图如图所示。

利用构造方法实例化
例如,使用new关键字创建String对象。代码如下:
String a = new String("我爱清汤小肥羊");
String b = new String(a) ;
3.利用字符数组实例化
例如,定义一个字符数组charArray,使用该字符数组创建一个字符串。 代码如下:
char[ ] charArray = { 't', 'i', 'm', 'e' };
String a = new String (charArray) ;
4.提取字符数组中的一部分创建字符串对象
例如,定义一个字符数组charArray从该字符数组索引3的位置开始,提取两个元素,创建一个字符串。代码如下:
"char[ ] charArray = { '时,间,'就', '是,'金','钱,};
String a = new String (charArray, 3,2);
5.1\\String类
package holleJAVA;
public class heeeee {
public static void main(String[] args) {
// TODO Auto-generated method stub
String a="时间就是金钱,我的朋友。";
System.out.println("a="+a);
String b=new String("我爱清汤小肥羊");
String c=new String(b);
System.out.println("b="+b);
System.out.println("c="+c);
char[] charArray= {'t','i','m','e'};
String d=new String(charArray);
System.out.println("d="+d);
char[]charArray2 = {'时','间','就','是','金','钱'};
String e= new String(charArray2,4,2);
System.out.println("e="+e);
}
}

5.2连接字符串
string a= “建团";
string b= “一百周年";
b = a+b; //b =“建团一百周年”
b+ = a; //b =b+a=“建团一百周年”
使用“+”运算符可实现拼接多个字符串的功能,“+”运算符可以连接多个字”在年共产生 String对象。除了“+”运算符,“+=”同样可以实现字符串拼接。
/5.2使用“+”和“+=”拼接字符串。
例五点二
public class heeeee {
public static void main(String[] args) {
// TODO Auto-generated method stub
String a="abc";
String b=("123");
String c=a+b+"!"; //使用“+”拼接字符
String d="拼接字符串";//拼接字符串
d+=c; //使用“+=”拼接字符
System.out.println("a="+a);
System.out.println("b="+b);
System.out.println("c="+c);
System.out.println("d="+d);
}
}

提取字符串信息
长度 字符串名.length();
5.3.2 获取指定的字符
str .length() ;
String num ="12345 67890";
int size = num. length() ;
这个结果是将字符串num的长度赋值给int型变量size, 此时变量size的值为11,这表示leng()方法返回的字符串长度包括字符串中的空格。
charAt(String index)方法可将指定索引处的字符返回。
str. charAt (index);
str: 任意字符串对象。
index: char值的索引。
例5.3连接其他数据类型
public class heeeee {
public static void main(String[] args) {
// TODO Auto-generated method stub
int booktime=4;//声明的int型变量booktime 5
float practice = 2.5f; // 声明的float型变量practice
//将字符串与整型、浮点型变量相连,并将结果输出
System.out.println("我每天花费"+booktime+"小时看书;"+practice+"小时上机练习");
}
}

5.3.1 获取字符串长度
length()方法返回采用UTF-16的编码表示字符的数量,也就是char的数量。
注意: 字符串的length( )方法与数组的length虽然都是用来获取长度的,但两者却有些不同。String 的length( )是类的成员方法,是有括号的;数组的length是一个属性,是没有括号的。
5.3.2 获取指定字符串
charAt(String index)方法可将指定索引处的字符返回。
str. charAt (index);
str: 任意字符串对象。
index: char值的索引。

例5.5
String str ="12345abcde";//创建字符串对象
int charIndex=str.indexOf("abc");//获取字符串str中“abc”首次出现的索引,赋值给charIndex
if(charIndex!=-1) {//判断:index的值不等于-1
//如果index不等于-1,则执行此行代码,说明str中存在“abc”字符串
System.out.println("str中存在abc字符串");
}else {//如果index等于-1,则执行此行代码,说明str中没有“abc”字符串
System.out.println("str中没有abc字符串");
}
}
}

2.indexOf(String srt,int fromindex)
a:任意字符串对象
str:要搜索的子字符串
fromindex:开始搜索的索引位置
例五点六
String str = "We are the world";
// 获取字符串中"r"第一次出现的索引位置
int firstIndex = str.indexOf("r");
// 获取字符串中"r"第二次出现的索引位置,从第一次出现的索引位置之后开始查找
int secondIndex = str.indexOf("r", firstIndex + 1);
// 获取字符串中"r"第三次出现的索引位置,从第二次出现的索引位置之后开始查找
int thirdIndex = str.indexOf("r", secondIndex + 1);
// 输出三次获取的索引位置
System.out.println("e第一次出現的索引位置是:" + firstIndex);
System.out.println("e第二次出現的索引位置是:" + secondIndex);
System.out.println("e第三次出現的索引位置是:" + thirdIndex);
}
}

3.pubile int lastindexOf(String srt)
a:任意字符串对象
str:要搜索的字符串
a:任意字符串
srt:要搜索的字符串
例5.7
String str = "Let it go!Let it go!"; // 创建字符串对象
int gIndex = str.lastIndexOf("g"); // 返回”g“最后一次出现的位置
int goIndex = str.lastIndexOf("go"); // 返回”go“最后一次出现的位置
int oIndex = str.lastIndexOf("o"); // 返回”o“最后一次出现的位置
System.out.println("字符串\"Let it go!Let it go\"中:\n");
System.out.println("\"g\"最后一次出现的位置是:" + gIndex);
System.out.println("\"o\"最后一次出现的位置是:" + oIndex);
System.out.println("\"go\"最后一次出现的位置是:" + goIndex);
}
}

5.8
String str = "01a3a56a89";
// 返回字母"a"最后一次出现的索引位置
int lastIndex = str.lastIndexOf("a");
// 返回字母"a"的索引位置otherIndex
// 满足0<=fiveBeforeIndex<=5条件,在满足条件的结果集中,返回最大的数字
int fiveBeforeIndex = str.lastIndexOf("a", 5);
// 返回字母"a"的索引位置otherIndex
// 满足0<=threeBeforeIndex<=3条件,在满足条件的结果集中,返回最大的数字
int threeBeforeIndex = str.lastIndexOf("a", 3);
System.out.println("字符串\"01a3a56a89\"中:\n");
System.out.println("字母\"a\"最后一次出现的位置是:" + lastIndex);
System.out.println("从索引位置5开始往回搜索,字母\"a\"最后一次出现的位置:" + fiveBeforeIndex);
System.out.println("从索引位置3开始往回搜索,字母\"a\"最后一次出现的位置:" + threeBeforeIndex);
}
}

5.9
package test;
public class StringStartWith {
public static void main(String[] args) {
// 前半句
String myDream1 = "我有一个梦想,幽谷上升,高山下降;";
// 后半句
String myDream2 = "坎坷曲折之路成坦途,圣光披露,满照人间。";
// 打印整句话
System.out.println(myDream1 + myDream2 + "\n\t\t————马丁•路德金《我有一个梦想》\n");
// 判断前半句是否以"我有一个梦想"为前缀
boolean firstBool = myDream1.startsWith("我有一个梦想");
// 判断后半句是否以"我有一个梦想"为前缀
boolean secondBool = myDream2.startsWith("我有一个梦想");
// 判断前半句的逻辑结果
if (firstBool) {
System.out.println("前半句是以\"我有一个梦想\"开始的。");
// 判断后半句的逻辑结果
} else if (secondBool) {
System.out.println("后半句是以\"我有一个梦想\"开始的。");
// 如果没有符合条件的字符串
} else {
System.out.println("没有以\"我有一个梦想\"开始的。");
}
}

5.10
// 创建字符串对象
String str = "床前明月光,疑是地上霜。\n举头望明月,低头思故乡。";
// 打印古诗
System.out.println(" 《静夜思》\n" + str + "\n");
// 返回换行符所在的位置
int enterIndex = str.indexOf("\n");
// 返回从换行符之后开始的子字符串前缀是否为”举“。
// 换行符在字符串中只占一个字符,所以enterIndex + 1
boolean flag = str.startsWith("举", enterIndex + 1);
if (flag) {
// 如果结果为真,则输出此句
System.out.println("第二行是以\"举\"开始的");
} else {
// 如果结果为假,则输出第二行开头第一个字符
System.out.println("第二行是以\"" + str.charAt(enterIndex + 1) + "\"开始的");
}
}
}

5.11
String str1 = "你说完了吗?";
String str2 = "我说完了。";
boolean flag1 = str1.endsWith("。");// 判断str1是否以"。"结尾
boolean flag2 = str2.endsWith("。");// 判断str2是否以"。"结尾
System.out.println("字符串str1是以句号结尾的吗?" + flag1);// 输出结果
System.out.println("字符串str2是以句号结尾的吗?" + flag2);
}
}

5.12
String str = "这是一个字符串";//创建一个字符串
char[] ch = str.toCharArray();//将字符串转换成字符数组
for (int i = 0; i < ch.length; i++) {//遍历字符数组
System.out.println("数组第" + i + "个元素为:" + ch[i]);//输出数组的元素
}
}
}

截取字符串
1.substring(int beginIndex)
该方法返回一个新的字符串,它是此字符中的一个子字符申。 该子字符申从指定索引处的字符开始,直到此字符串末尾
5.13
// 创建字符串
String str = "今天的菜单有:蒸羊羔,蒸熊掌,蒸鹿尾。烧花鸭,烧雏鸡,烧子鹅,卤煮咸鸭,酱鸡,腊肉,松花小肚。";
System.out.println(str);// 输出字符串
boolean request1 = str.contains("腊肉");// 判断字符串中是否有“腊肉”的字样
System.out.println("今天有腊肉吗?" + request1);
boolean request2 = str.contains("汉堡");// 判断字符串中是否有“汉堡”的字样
System.out.println("今天有汉堡吗?" + request2);
}
}

截取字符串
substring(前序号,后序号)
5.4.1 截取字符串
1.substring(int beginIndex)
该方法返回一个新的字符串,它是此字符中的一个子字符申。 该子字符申从指定索引处的字符开始,直到此字符串末尾
str. substring (beginIndex);
str:任意字符串。
5.4.2 字符串替换
1. replace(CharSequence target, CharSequence replacement)
该方法可以实现将指定的字符序列替换成新的字符序列。CharSequence 是一个接口, 代表一个可读的字符序列,String、 StringBuffer 、StringBuilder 都实现了这个接口,所以可以直接将字符当成参数。
5.14
String str = "为革命保护视力,眼保健操开始!";
String substr = str.substring(8); //从第8位开始截取字符串
System.out.println("字符串str的后半句是:" + substr);
}
}

1.split(String regex)
该方法可根据给定的分隔符对字符串进行拆分,支持正则表达式,最后返回一个字符串数组。
1. replace(CharSequence target, CharSequence replacement)
该方法可以实现将指定的字符序列替换成新的字符序列。CharSequence 是一个接口, 代表一个可读的字符序列,String、 StringBuffer 、StringBuilder 都实现了这个接口,所以可以直接将字符当成参数。
str: 任意字符串。
oldstr:要被替换的字符序列。
newstr:替换后的字符序列。
5.15
public static void main(String[] args) {
String str = "闭门造车,出门合辙。";
// 从0开始(即从头开始)截取至4-1索引位置的子字符串
String substr = str.substring(0, 4);
System.out.println("字符串str的前半句是:" + substr);
}
}

replaceAll(String regex, String replacement)
该方法可以实现将指定的字符串替换成新的字符串,支持正则表达式。
str. replaceAll (regex, replacement) ;
str: 任意字符串。
regex: 被替换的字符串或正则表达式。
replacement:替换后的字符串
5.16
public static void main(String[] args) {
String str="明月几时有,把酒问青天";
String restr=str.replace("月", "日"); //将str中的”月“全部替换成”日“
System.out.println("字符串str替换之后的效果:"+restr);
}
}

部分替换 String restr=str.replace
全部替换 正则表达式(数字) String restrAll=str.replaceAll
代码
5.17
public static void main(String[] args) {
// 创建字符串,前十位是数字
String str = "0123456789abc\\d";
// 使用replace()将符合"\\d"表达式的字符串替换"?"
String restr = str.replace("\\d", "?");
// 使用replaceAll()将符合"\\d"表达式的字符串替换"?"
String restrAll = str.replaceAll("\\d", "?");
// 输出结果
System.out.println("字符串str:" + str);
System.out.println("使用replace()替换的结果:" + restr);
System.out.println("使用replaceAll()替换的结果:" + restrAll);
}
}

5.18
public static void main(String[] args) {
// 创建字符串
String str = "8I want to marry you, so I need you!";
// 将开头的数字替换成两个双引号""
String noNumber = str.replaceFirst("\\d", "");
// 将第一次出现的"you"替换成"her"
String youToHer = noNumber.replaceFirst("you", "her");
// 输出结果
System.out.println("替换之后的结果是:"+youToHer);
}
}

字符串分割
字符串.split(子串<可传正则表达式>,次数);
1.split(String regex)
该方法可根据给定的分隔符对字符串进行拆分,支持正则表达式,最后返回一个字符串数组。
str:任意字符串。
regex:分隔符表达式
5.19
public static void main(String[] args) {
// 创建一个字符串
String str = "从前有座山,山里有个庙,庙里有个小松鼠";
// 让字符串按照","进行分割
String[] strArray = str.split(",");
// 使用for循环,循环输出数字所有元素
for (int i = 0; i < strArray.length; i++) {
System.out.println("数组第" + i + "索引的元素是:" + strArray[i]);
}
}
}

2. sit(tigi regex, int limit)
该方法可根据给定的分隔符对字符串进行拆分,并限定拆分的次数,支持正则表达式。
str,split(regex, limit)
str:任意字符串。
regex: 分隔符表达式。
limit: 限定的分割次数
5.20
public static void main(String[] args) {
// 创建字符串,包含多种类型字符
String str = "a1b2,c,d e f|gh";
// 使用","分割
String[] a1 = str.split(",");
// 使用空格分割
String[] a2 = str.split(" ");
// 使用"|"分割
String[] a3 = str.split("\\|");
// 使用正则表达式分割,本行用数字分割
String[] a4 = str.split("\\d");
// 同时用","、空格、"|"、数字分割,用符号"|"连接所有分隔符
String[] a5 = str.split(",| |\\||\\d");
// 显示str的原值
System.out.println("str的原值:[" + str + "]");
// 使用for-each循环展示","分割的结果
System.out.print("使用\",\"分割:");
for (String b : a1) {
System.out.print("[" + b + "]");
}
System.out.println(); // 换行
// 使用for-each循环展示空格分割的结果
System.out.print("使用空格分割:");
for (String b : a2) {
System.out.print("[" + b + "]");
}
System.out.println();
// 使用for-each循环 展示"|"分割的结果
System.out.print("使用\"|\"分割:");
for (String b : a3) {
System.out.print("[" + b + "]");
}
System.out.println();
// 使用for-each循环展示数字分割的结果
System.out.print("使用數字分割:");
for (String b : a4) {
System.out.print("[" + b + "]");
}
System.out.println();
// 使用for-each循环展示所有分隔符同时分割的结果
System.out.print("同時使用所有分隔符:");
for (String b : a5) {
System.out.print("[" + b + "]");
}
System.out.println();
}
}

5.21
public static void main(String[] args) {
// 创建字符串
String str = "192.168.0.1";
// 按照"."进行分割
String[] firstArray = str.split("\\.");
// 按照"."进行两次分割
String[] secondArray = str.split("\\.", 2);
// 输出str原值
System.out.println("str的原值为:[" + str + "]");
// 输出全部分割的结果
System.out.print("全部分割的结果:");
for (String a : firstArray) {
System.out.print("[" + a + "]");
}
System.out.println();// 换行
// 输出分割两次的结果
System.out.print("分割两次的结果:");
for (String a : secondArray) {
System.out.print("[" + a + "]");
}
System.out.println();
}
}

大小写转换
1. toLowerCase()
该方法将String转换为小写。如果字符串中没有应被转换的字符,则将原字符串返回;否则将返回一个新的字符串,将原字符串中每个可进行小写转换的字符都转换成等价的小写字符。字符长度与原字符长度相同。
str. toLowerCase () ;
str: 任意字符串。
2. toUpperCase()
该方法将String转换为大写。如果字符串中没有应被转换的字符,则将原字符串返回:否则返回一个新字符串,将原字符串中每个可进行大写转换的字符都转换成等价的大写字符。新字符长度与原字符长度相同。
str. toUpperCase() ;
其中,str 表示任意字符串。
5.22
public static void main(String[] args) {
String str = "abc DEF"; // 创建字符串
System.out.println(str.toLowerCase()); // 按照小写格式输出
System.out.println(str.toUpperCase()); // 按照大写格式输出
}
}

比较字符串是否相等
a==b 位置
a.equals 值
a.equalsIgnoreCase(b)
5.23
public static void main(String[] args) {
String str = " abc ";
String shortStr = str.trim();
System.out.println("str的原值是:[" + str + "]");
System.out.println("去掉首尾空白的值:[" + shortStr + "]");
}
}

比较字符串是否相等
对字符串对象进行比较不能简单地使用比较运算符“==”,因为比较运算符比较的是两个字符串的内存地址是否相同。因为即使两个字符串的文本值相同,两个对象的内存地址也可能不同,以使用比较运算符会返回false。
5.24
public static void main(String[] args) {
// 创建字符串
String str = " a b cd e f g ";
// 利用正则表达式,将字符串中所有的空白内容都替换成””
String shortstr = str.replaceAll("\\s", "");
// 输出结果
System.out.println("str的原值是:[" + str + "]");
System.out.println("删除空内容之后的值是:[" + shortstr + "]");
}
}


5.25
public static void main(String[] args) {
String tom, jerry;
// 直接引入字符串常量
tom = "I am a student";
jerry = "I am a student";
System.out.println("直接引入字符串常量的比较结果:" + (tom == jerry));
// 使用new创建信对象
tom = new String("I am a student");
jerry = new String("I am a student");
System.out.println("使用new创建对象的比较结果:" + (tom == jerry));
}
}

5.26
public static void main(String[] args) {
String str1 = "Hello";
String str2 = new String("Hello");
String str3 = new String("你好");
String str4 = str2;
System.out.println("str1 == str2 的结果:" + (str1 == str2));
System.out.println("str1 == str3 的结果:" + (str1 == str3));
System.out.println("str1 == str4 的结果:" + (str1 == str4));
System.out.println("str2 == str4 的结果:" + (str2 == str4));
System.out.println("str1.equals(str2) 的结果:" + str1.equals(str2));
System.out.println("str1.equals(str3) 的结果:" + str1.equals(str3));
System.out.println("str1.equals(str4) 的结果:" + str1.equals(str4));
}
}

5.27
public static void main(String[] args) {
// 创建字符串对象,内容全部小写
String str1 = "abc";
// 创建字符串对象,内容全部大写
String str2 = "ABC";
// 比较两个字符串的内容是否相等
System.out.println("区分大小写的结果:"+str1.equals(str2));
// 比较两个字符串的内容是否相等,不区分大小写
System.out.println("不区分大小写的结果:"+str1.equalsIgnoreCase(str2));
}
}

5.28
import java.util.Date; //导入java.util.Date类
public class fhhd {
public static void main(String[] args) { //主方法
Date date = new Date(); //创建Date对象date
String year = String.format("%tY", date); //将date进行格式化
String month = String.format("%tB", date);
String day = String.format("%td", date);
System.out.println("今年是:" + year + "年"); //输出信息
System.out.println("现在是:" + month);
System.out.println("今天是:" + day + "号");
}
}

5.29
import java.util.Date; //导入java.util.Date类
public class fhhd {
public static void main(String[] args) { // 主方法
Date date = new Date(); // 创建Date对象date
String hour = String.format("%tH", date); // 将date进行格式化
String minute = String.format("%tM", date);
String second = String.format("%tS", date);
// 输出的信息
System.out.println("现在是:" + hour + "时" + minute + "分" + second + "秒");
}
}

5.30
import java.util.Date; //导入java.util.Date类
public class fhhd {
public static void main(String[] args) { // 主方法
Date date = new Date(); // 创建Date对象date
String time = String.format("%tc", date); // 将date格式化
String form = String.format("%tF", date);
// 将格式化后的日期时间输出
System.out.println("全部的时间信息是:" + time);
System.out.println("年-月-日格式:" + form);
}
}

5.31
public static void main(String[] args) {
// 输出字符
String str1 = String.format("%c", 'X');
System.out.println("字母x大写:" + str1);
// 输出数字
String str2 = String.format("%d", 1251 + 3950);
System.out.println("1251+3950的结果是:" + str2);
// 输出小数点后两位
String str3 = String.format("%.2f", Math.PI);
System.out.println("π取两位小数点:" + str3);
// 输出布尔值
String str4 = String.format("%b", 2 < 3);
System.out.println("2<3的结果是:" + str4);
// 输出哈希散列码,等同Integer.toHexString(3015);
String str5 = String.format("%h", 3510);
System.out.println("3510的hashCode值:" + str5);
// 输出8进制
String str6 = String.format("%o", 33);
System.out.println("33的8进制结果是:" + str6);
// 输出16进制
String str7 = String.format("%x", 33);
System.out.println("33的16进制结果是:" + str7);
// 输出科学计数法
String str8 = String.format("%e", 120000.1);
System.out.println("120000.1用科学计数法表示:" + str8);
// 输出带有效位数和指数的16进制浮点值
String str9 = String.format("%a", 40.0);
System.out.println("40.0的十六进制浮点值:" + str9);
// 输出百分号和数字
System.out.println(String.format("天才是由%d%%的灵感,%d%%的汗水 。", 1, 99));
}
}

5.32
public static void main(String[] args) {
// 让字符串输出的最大长度为5,不足长度在前端补空格
String str1 = String.format("%5d", 123);
System.out.println("输出长度为5的字符串|" + str1 + "|");
// 让字符串左对齐
String str2 = String.format("%-5d", 123);
System.out.println("左对齐|" + str2 + "|");
// 在8进制前加一个0
String str3 = String.format("%#o", 33);
System.out.println("33的8进制结果是:" + str3);
// 在16进前加一个0x
String str4 = String.format("%#x", 33);
System.out.println("33的16进制结果是:" + str4);
// 显示数字正负号
String str5 = String.format("%+d", 1);
System.out.println("我是正数:" + str5);
// 显示数字正负号
String str6 = String.format("%+d", -1);
System.out.println("我是负数:" + str6);
// 在正数前补一个空格
String str7 = String.format("% d", 1);
System.out.println("我是正数,前面有空格" + str7);
// 在负数前补一个负号
String str8 = String.format("% d", -1);
System.out.println("我是负数,前面有负号" + str8);
// 让字符串输出的最大长度为5,不足长度在前端补0
String str9 = String.format("%05d", 12);
System.out.println("前面不够的数用0填充:" + str9);
// 用逗号分隔数字
String str10 = String.format("%,d", 123456789);
System.out.println("用逗号分隔:" + str10);
// 正数无影响
String str11 = String.format("%(d", 13);
System.out.println("我是正数,我没有括号:" + str11);
// 让负数用括号括起来
String str12 = String.format("%(d", -13);
System.out.println("我是负数,我有括号的:" + str12);
}
}

可变字符串
StringBuffer是线程安全的可变字符序列,一个类似于 String的字符串缓冲区。前面内容介绍过String创建的字符串对象是不可修改的,这一节介绍的SuigBufter类创造的字字符串序列是可修改的且实体容量会随着存放的字符串增加而自动增加。StringBulder 与StringBuffer有完全相同的API.只是为了提高效率而放弃了线程安全控制。
5.5.1 StringBuffer 类的常用方法
类名 对象类型 执行效率 线程安全性
String 指向另外的空间 常量 慢 不安全
StringBuffer 指向在原来的基础上添加 变量 中 有锁 安全
Stringbuilder 在原来的基础上添加 变量 快 无 锁 不安全
StringBuffer和Stringbuilder 的使用方法:
追加 字符串名.append (需要追加的值);
修改某个元素的值 字符串名.setCharAT(序号,值);
1.创建StringBuffer类
创建一一个新的StringBuffer对象必须用new方法,而不能像String对象那样直接引用字符串常量。
StringBuffer sbf = new StringBuffer() ;//创建一个对象,无初始值
StringBuffer sbf = new StringBuffer ("abc") ;//创建一个对象,初始值为“abc"
StringBuffer sbf = new StringBuffer(32); //创建一个对象, 初始容量为32个字符
2. append()方法
将参数转换成字符串,将所得字符串中的字符追加到此序列中。
sbf:append (obj);
sbf:任意StingBuffer 对象
5.33
public static void main(String[] args) {
// 创建StringBuffer对象
StringBuffer sbf = new StringBuffer("门前大桥下,");
// 追加字符串常量
sbf.append("游过一群鸭,");
// 追加StringBuffer对象
StringBuffer tmp = new StringBuffer("快来快来数一数,");
sbf.append(tmp);
// 追加整型变量
int x = 24678;
sbf.append(x);
// 输出
System.out.println(sbf.toString());
}
}

3. setCharAt(int index, char ch)方法
将给定索引处的字符修改为ch。
sbf . setCharAt (index, ch) ;
sbf:任意StringBuffer对象。
index:被替换字符的索引。
ch:替换后的字符。
5.34
public static void main(String[] args) {
StringBuffer sbf = new StringBuffer("0123456");
System.out.println("sbf的原值是:" + sbf);
sbf.setCharAt(3, 'A'); // 将索引为3的字符改成'A'
System.out.println("修改后的值是:" + sbf);
}
}

StringBuilder类与StringBuffer类具有兼容的API,所以两者的使用方法也相同
例5.35
StringBuffer和Stringbuilder 的使用方法:
插入 字符串名.insert(序号,值);
反转 字符串名.reverse();
删除 字符串名.delate(前序号,后序号)
5.35
public static void main(String[] args) {
StringBuffer sbf = new StringBuffer("0123456");
System.out.println("sbf的原值为:"+sbf);
sbf = sbf.insert(5, "F"); //在索引为5的位置插入"F",将返回值赋给sbf自己
System.out.println("修改之后的值为:"+sbf);
}
}

StringBuilder类与StringBuffer类具有兼容的API,所以两者的使用方法也相同
例5.35
StringBuffer和Stringbuilder 的使用方法:
插入 字符串名.insert(序号,值);
反转 字符串名.reverse();
删除 字符串名.delate(前序号,后序号)
5.36
public static void main(String[] args) {
StringBuffer sbf = new StringBuffer("同一个世界,同一个梦想");
System.out.println("sbf的原值为:" + sbf);
sbf = sbf.reverse();// 将字符序列sbf反转
System.out.println("修改之后的值为:" + sbf);
}
}

5.37
public static void main(String[] args) {
StringBuffer sbf = new StringBuffer("天行健,君子以自强不息");
System.out.println("sbf的原值为:"+sbf);
sbf = sbf.delete(4, 7); //删除从索引4开始至索引7之前的内容
System.out.println("删除之后的值为:"+sbf);
}
}

String只能赋值一次, 每二次内容发生改变都生成了一个新的对象,然后原有的对象引用新的象,所以说String本身是不可改变。每一次改变String的字符串内容,都会在内存创建新的对象,每一次生成新对象都会对系统性能产生影响
而StringBuffer和StringBuilder不同,每次操作都是对自身对象做操作,而不是生成新的对象
SrigBufer和SrngBider也存在不同之处。StringBuffer 的方法都使用"synchronized"关键字进行修饰,这样保证了同时最多只有一个线程可以运行这些方法,也就是保证了线程安全。StringBuilder则不具备这样的特点。反过来说,正因为StringBuilder 没有线程安全机制,运行起来就不用考虑给线程加锁,所以运行效率会比StringBuffer 要高
5.38
public static void main(String[] args) {
StringBuffer sbf = new StringBuffer("ABCDEFG");// 创建字符串序列
int lenght = sbf.length();// 获取字符串序列的长度
char chr = sbf.charAt(5); // 获取索引为5的字符
int index = sbf.indexOf("DEF");// 获取DEF字符串所在的索引位置
String substr = sbf.substring(0, 2);// 截取从索引0开始至索引2之间的字符串
StringBuffer tmp = sbf.replace(2, 5, "1234");// 将从索引2开始至索引5之间的字符序列替换成"1234"
System.out.println("sbf的原值为:" + sbf);
System.out.println("sbf的长度为:" + lenght);
System.out.println("索引为5的字符为:" + chr);
System.out.println("DEF字符串的索引位置为:" + index);
System.out.println("索引0开始至索引2之间的字符串:" + substr);
System.out.println("替换后的字符串为:" + tmp);
}
}

1)操作少,数据少,用string。
(2)单线程,操作多,数据多,用stringBuilder。
(3)多线程,操作多,数据多,用stringBuffe
5.39
public static void main(String[] args) {
StringBuilder sbd = new StringBuilder();
System.out.println("sbd的原值为空");
sbd.append("我是StringBuilder类");
System.out.println("sbd追加字符串:" + sbd);
int length = sbd.length();
System.out.println("sbd的长度为:" + length);
sbd = sbd.insert(length - 1, "123456");
System.out.println("插入字符串:" + sbd);
sbd = sbd.delete(sbd.length() - 1, sbd.length());
System.out.println("删除最后一个字:" + sbd);
sbd = sbd.reverse();
System.out.println("反序输出:" + sbd);
}
}

5.40
public static void main(String[] args) {
String str = "String";
// String转换成StringBuffer
StringBuffer sbf = new StringBuffer(str);
// String转换成StringBuilder
StringBuilder sbd = new StringBuilder(str);
// StringBuffer转换成String
str = sbf.toString();
// StringBuilder转换成String
str = sbd.toString();
// StringBuffer转换成StringBuilder
StringBuilder bufferToBuilder = new StringBuilder(sbf.toString());
// StringBuilder转换成StringBuffer
StringBuffer builderToBuffer = new StringBuffer(sbd.toString());
}
}
String只能赋值一次, 每二次内容发生改变都生成了一个新的对象,然后原有的对象引用新的象,所以说String本身是不可改变。每一次改变String的字符串内容,都会在内存创建新的对象,每一次生成新对象都会对系统性能产生影响
而StringBuffer和StringBuilder不同,每次操作都是对自身对象做操作,而不是生成新的对象
SrigBufer和SrngBider也存在不同之处。StringBuffer 的方法都使用"synchronized"关键字进行修饰,这样保证了同时最多只有一个线程可以运行这些方法,也就是保证了线程安全。StringBuilder则不具备这样的特点。反过来说,正因为StringBuilder 没有线程安全机制,运行起来就不用考虑给线程加锁,所以运行效率会比StringBuffer 要高


5.41
public static void main(String[] args) { // 主方法
String str = ""; // 创建空字符串
// 定义对字符串执行操作的起始时间
long starTime = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) { // 利用for循环执行10000次操作
str = str + i; // 循环追加字符串
}
long endTime = System.currentTimeMillis(); // 定义对字符串操作后的时间
long time = endTime - starTime; // 计算对字符串执行操作的时间
System.out.println("String循环1万次消耗时间:" + time); // 将执行的时间输出
StringBuilder builder = new StringBuilder(""); // 创建字符串生成器
starTime = System.currentTimeMillis(); // 定义操作执行前的时间
for (int j = 0; j < 10000; j++) { // 利用for循环进行操作
builder.append(j); // 循环追加字符
}
endTime = System.currentTimeMillis(); // 定义操作后的时间
time = endTime - starTime; // 追加操作执行的时间
System.out.println("StringBuilder循环1万次消耗时间:" + time); // 将操作时间输出
StringBuilder builder2 = new StringBuilder(""); // 创建字符串生成器
starTime = System.currentTimeMillis(); // 定义操作执行前的时间
for (int j = 0; j < 50000; j++) { // 利用for循环进行操作
builder2.append(j); // 循环追加字符
}
endTime = System.currentTimeMillis(); // 定义操作后的时间
time = endTime - starTime; // 追加操作执行的时间
System.out.println("StringBuilder循环5万次消耗时间:" + time); // 将操作时间输出
}
}

这篇博客详细介绍了Java中字符串的操作,包括创建字符串、连接字符串、获取长度、获取指定字符、截取字符串、替换字符串、字符串拼接和分割以及大小写转换。讲解了String、StringBuffer和StringBuilder的区别与使用场景,强调了线程安全和性能的影响。

被折叠的 条评论
为什么被折叠?



