String类
1 String类的概述
字符串:就是由多个字符组成的一串数据。也可以看成是一个字符数组。
通过查看API,我们可以知道
A:字符串字面值"abc"也可以看成是一个字符串对象。
B:字符串是常量,一旦被赋值,就不能被改变。
构造方法:
public String()
:空构造public String(byte[] bytes)
:把字节数组转成字符串public String(byte[] bytes,int index,int length)
:把字节数组的一部分转成字符串public String(char[] value)
:把字符数组转成字符串public String(char[] value,int index,int count)
:把字符数组的一部分转成字符串public String(String original)
:把字符串常量值转成字符串
字符串的方法:
public int length():返回此字符串的长度。
例子:
public class StringDemo {
public static void main(String[] args) {
// public String():空构造
String s1 = new String();
System.out.println("s1:" + s1);
System.out.println("s1.length():" + s1.length());
System.out.println("--------------------------");
// public String(byte[] bytes):把字节数组转成字符串
byte[] bys = { 97, 98, 99, 100, 101 };//byte范围-128-127
String s2 = new String(bys);
System.out.println("s2:" + s2);
System.out.println("s2.length():" + s2.length());
System.out.println("--------------------------");
// public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
// 我想得到字符串"bcd"
String s3 = new String(bys, 1, 3);
System.out.println("s3:" + s3);
System.out.println("s3.length():" + s3.length());
System.out.println("--------------------------");
// public String(char[] value):把字符数组转成字符串
char[] chs = { 'a', 'b', 'c', 'd', 'e', '爱', '林', '亲' };
String s4 = new String(chs);
System.out.println("s4:" + s4);
System.out.println("s4.length():" + s4.length());
System.out.println("--------------------------");
// public String(char[] value,int index,int count):把字符数组的一部分转成字符串
String s5 = new String(chs, 2, 4);
System.out.println("s5:" + s5);
System.out.println("s5.length():" + s5.length());
System.out.println("--------------------------");
//public String(String original):把字符串常量值转成字符串
String s6 = new String("abcde");
System.out.println("s6:" + s6);
System.out.println("s6.length():" + s6.length());
System.out.println("--------------------------");
//字符串字面值"abc"也可以看成是一个字符串对象。
String s7 = "abcde";
System.out.println("s7:"+s7);
System.out.println("s7.length():"+s7.length());
}
}
2 String的特点
1.一旦被赋值就不能改变,新的值开辟新的空间
2. String s = new String(“hello”)和String s = “hello”;的区别?
有。前者会创建2个对象,后者创建1个对象。
3. ==:比较引用类型比较的是地址值是否相同
equals:比较引用类型默认也是比较地址值是否相同,而String类重写了equals()方法,比较的是内容是否相同。
public class StringDemo2 {
public static void main(String[] args) {
String s1 = new String("hello");
String s2 = "hello";
System.out.println(s1 == s2);// false
System.out.println(s1.equals(s2));// true
}
}
3 String面试题看程序写结果
public class StringDemo3 {
public static void main(String[] args) {
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2);// false
System.out.println(s1.equals(s2));// true
String s3 = new String("hello");
String s4 = "hello";
System.out.println(s3 == s4);// false
System.out.println(s3.equals(s4));// true
String s5 = "hello";
String s6 = "hello";
System.out.println(s5 == s6);// true
System.out.println(s5.equals(s6));// true
}
}
4 String面试题看程序写结果2
- 看程序写结果
- 字符串如果是变量相加,先开空间,在拼接。
- 字符串如果是常量相加,是先加,然后在常量池找,如果有就直接返回,否则,就创建。
public class StringDemo4 {
public static void main(String[] args) {
String s1 = "hello";
String s2 = "world";
String s3 = "helloworld";
System.out.println(s3 == s1 + s2);// false
System.out.println(s3.equals((s1 + s2)));// true
System.out.println(s3 == "hello" + "world");// true
System.out.println(s3.equals("hello" + "world"));// true
// 通过反编译看源码,我们知道这里已经做好了处理。
// System.out.println(s3 == "helloworld");
// System.out.println(s3.equals("helloworld"));
}
}
5 String类的判断功能
boolean equals(Object obj)
:比较字符串的内容是否相同,区分大小写boolean equalsIgnoreCase(String str)
:比较字符串的内容是否相同,忽略大小写boolean contains(String str)
:判断大字符串中是否包含小字符串boolean startsWith(String str)
:判断字符串是否以某个指定的字符串开头boolean endsWith(String str)
:判断字符串是否以某个指定的字符串结尾boolean isEmpty()
:判断字符串是否为空。
注意:
字符串内容为空和字符串对象为空。
String s = “”;
String s = null;
public class StringDemo {
public static void main(String[] args) {
// 创建字符串对象
String s1 = "helloworld";
String s2 = "helloworld";
String s3 = "HelloWorld";
// boolean equals(Object obj):比较字符串的内容是否相同,区分大小写
System.out.println("equals:" + s1.equals(s2));
System.out.println("equals:" + s1.equals(s3));
System.out.println("-----------------------");
// boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
System.out.println("equals:" + s1.equalsIgnoreCase(s2));
System.out.println("equals:" + s1.equalsIgnoreCase(s3));
System.out.println("-----------------------");
// boolean contains(String str):判断大字符串中是否包含小字符串
System.out.println("contains:" + s1.contains("hello"));
System.out.println("contains:" + s1.contains("hw"));
System.out.println("-----------------------");
// boolean startsWith(String str):判断字符串是否以某个指定的字符串开头
System.out.println("startsWith:" + s1.startsWith("h"));
System.out.println("startsWith:" + s1.startsWith("hello"));
System.out.println("startsWith:" + s1.startsWith("world"));
System.out.println("-----------------------");
// 练习:boolean endsWith(String str):判断字符串是否以某个指定的字符串结尾这个自己玩
// boolean isEmpty():判断字符串是否为空。
System.out.println("isEmpty:" + s1.isEmpty());
String s4 = "";
String s5 = null;
System.out.println("isEmpty:" + s4.isEmpty());
// NullPointerException
// s5对象都不存在,所以不能调用方法,空指针异常
System.out.println("isEmpty:" + s5.isEmpty());
}
}
6 模拟用户登录练习
模拟登录,给三次机会,并提示还有几次。
分析:
A:定义用户名和密码。已存在的。
B:键盘录入用户名和密码。
C:比较用户名和密码。
如果都相同,则登录成功
如果有一个不同,则登录失败
D:给三次机会,用循环改进,最好用for循环。
手写:
public class Login {
public static void main(String[] args) {
String userName = "Test";
String passWord = "Pass";
String inputName;
String inputPassword;
Scanner sc = new Scanner(System.in);
for(int i = 3; i > 0; i--){
System.out.println("还有"+i+"次机会");
System.out.println("请输入用户名:");
inputName = sc.nextLine();
System.out.println("请输入密码:");
inputPassword = sc.nextLine();
if (userName.equals(inputName) && passWord.equals(inputPassword)){
System.out.println("登录成功");
break;
}
else{
System.out.println("登录失败");
}
}
}
}
答案:
public class StringTest {
public static void main(String[] args) {
// 定义用户名和密码。已存在的。
String username = "admin";
String password = "admin";
// 给三次机会,用循环改进,最好用for循环。
for (int x = 0; x < 3; x++) {
// x=0,1,2
// 键盘录入用户名和密码。
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名:");
String name = sc.nextLine();
System.out.println("请输入密码:");
String pwd = sc.nextLine();
// 比较用户名和密码。
if (name.equals(username) && pwd.equals(password)) {
// 如果都相同,则登录成功
System.out.println("登录成功");
break;
} else {
// 如果有一个不同,则登录失败
// 2,1,0
// 如果是第0次,应该换一种提示
if ((2 - x) == 0) {
System.out.println("帐号被锁定,请与班长联系");
} else {
System.out.println("登录失败,你还有" + (2 - x) + "次机会");
}
}
}
}
}
7 String类的获取功能
int length()
:获取字符串的长度。char charAt(int index)
:获取指定索引位置的字符int indexOf(int ch)
:返回指定字符在此字符串中第一次出现处的索引。int indexOf(String str)
:返回指定字符串在此字符串中第一次出现处的索引。int indexOf(int ch,int fromIndex)
:返回指定字符在此字符串中从指定位置后第一次出现处的索引。int indexOf(String str,int fromIndex)
:返回指定字符串在此字符串中从指定位置后第一次出现处的索引。String substring(int start)
:从指定位置开始截取字符串,默认到末尾。String substring(int start,int end)
:从指定位置开始到指定位置结束截取字符串。
public class StringDemo {
public static void main(String[] args) {
// 定义一个字符串对象
String s = "helloworld";
// int length():获取字符串的长度。
System.out.println("s.length:" + s.length());
System.out.println("----------------------");
// char charAt(int index):获取指定索引位置的字符
System.out.println("charAt:" + s.charAt(7));
System.out.println("----------------------");
// int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。
System.out.println("indexOf:" + s.indexOf('l'));
System.out.println("----------------------");
// int indexOf(String str):返回指定字符串在此字符串中第一次出现处的索引。
System.out.println("indexOf:" + s.indexOf("owo"));
System.out.println("----------------------");
// int indexOf(int ch,int fromIndex):返回指定字符在此字符串中从指定位置后第一次出现处的索引。
System.out.println("indexOf:" + s.indexOf('l', 4));
System.out.println("indexOf:" + s.indexOf('k', 4)); // -1
System.out.println("indexOf:" + s.indexOf('l', 40)); // -1
System.out.println("----------------------");
// 自己练习:int indexOf(String str,int
// fromIndex):返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
// String substring(int start):从指定位置开始截取字符串,默认到末尾。包含start这个索引
System.out.println("substring:" + s.substring(5));
System.out.println("substring:" + s.substring(0));
System.out.println("----------------------");
// String substring(int start,int
// end):从指定位置开始到指定位置结束截取字符串。包括start索引但是不包end索引
System.out.println("substring:" + s.substring(3, 8));
System.out.println("substring:" + s.substring(0, s.length()));
}
}
8 字符串的遍历
for (int x = 0; x < s.length(); x++) {
// char ch = s.charAt(x);
// System.out.println(ch);
// 仅仅是输出,我就直接输出了
System.out.println(s.charAt(x));
}
9 统计大写,小写及数字字符的个数练习
-
需求:统计一个字符串中大写字母字符,小写字母字符,数字字符出现的次数。(不考虑其他字符)
-
举例:
“Hello123World” -
结果:
大写字符:2个
小写字符:8个
数字字符:3个 -
分析:
前提:字符串要存在
A:定义三个统计变量
bigCount=0
smallCount=0
numberCount=0
B:遍历字符串,得到每一个字符。
length()和charAt()结合
C:判断该字符到底是属于那种类型的
大:bigCount++
小:smallCount++
数字:numberCount++
这道题目的难点就是如何判断某个字符是大的,还是小的,还是数字的。
ASCII码表:
0 48
A 65
a 97
虽然,我们按照数字的这种比较是可以的,但是想多了,有比这还简单的
char ch = s.charAt(x);
if(ch>=‘0’ && ch<=‘9’) numberCount++
if(ch>=‘a’ && ch<=‘z’) smallCount++
if(ch>=‘A’ && ch<=‘Z’) bigCount++
D:输出结果。
手写练习:
package cn.plsite.apiTest;
public class StringTest2 {
public static void main(String[] args) {
String str = "Hello123WorldzZ9";
int bigCount = 0;
int smallCount = 0;
int numCount = 0;
for(int i = 0; i < str.length(); i++){
if(str.charAt(i) >= 'A' && str.charAt(i) <= 'Z'){
bigCount++;
}
if(str.charAt(i) >= 'a' && str.charAt(i) <= 'z'){
smallCount++;
}
if(str.charAt(i) >= '0' && str.charAt(i) <= '9'){
numCount++;
}
}
System.out.println("大写字母有"+bigCount+"个");
System.out.println("小写字母有"+smallCount+"个");
System.out.println("数字有"+numCount+"个");
}
}
10 String类的转换功能
String的转换功能:
byte[] getBytes()
:把字符串转换为字节数组。char[] toCharArray()
:把字符串转换为字符数组。static String valueOf(char[] chs)
:把字符数组转成字符串。static String valueOf(int i)
:把int类型的数据转成字符串。-
注意:String类的valueOf方法可以把任意类型的数据转成字符串。
String toLowerCase()
:把字符串转成小写。String toUpperCase()
:把字符串转成大写。String concat(String str)
:把字符串拼接。
public class StringDemo {
public static void main(String[] args) {
//定义一个字符串对象
String s = "JavaSE";
// byte[] getBytes():把字符串转换为字节数组。
byte[] bys = s.getBytes();
for (int x = 0; x < bys.length; x++) {
System.out.println(bys[x]);
}
System.out.println("----------------");
// char[] toCharArray():把字符串转换为字符数组。
char[] chs = s.toCharArray();
for (int x = 0; x < chs.length; x++) {
System.out.println(chs[x]);
}
System.out.println("----------------");
// static String valueOf(char[] chs):把字符数组转成字符串。
String ss = String.valueOf(chs);
System.out.println(ss);
System.out.println("----------------");
// static String valueOf(int i):把int类型的数据转成字符串。
int i = 100;
String sss = String.valueOf(i);
System.out.println(sss);
System.out.println("----------------");
// String toLowerCase():把字符串转成小写。
System.out.println("toLowerCase:" + s.toLowerCase());
System.out.println("s:" + s);
// System.out.println("----------------");
// String toUpperCase():把字符串转成大写。
System.out.println("toUpperCase:" + s.toUpperCase());
System.out.println("----------------");
// String concat(String str):把字符串拼接。
String s1 = "hello";
String s2 = "world";
String s3 = s1 + s2;
String s4 = s1.concat(s2);
System.out.println("s3:"+s3);
System.out.println("s4:"+s4);
}
}
运行结果:
74
97
118
97
83
69
----------------
J
a
v
a
S
E
----------------
JavaSE
----------------
100
----------------
toLowerCase:javase
s:JavaSE
toUpperCase:JAVASE
----------------
s3:helloworld
s4:helloworld
11 把字符串的首字母转大写其他转小写练习
需求:把一个字符串的首字母转成大写,其余为小写。(只考虑英文大小写字母字符)
举例:
helloWORLD
结果:
Helloworld
分析:
A:先获取第一个字符
B:获取除了第一个字符以外的字符
C:把A转成大写
D:把B转成小写
E:C拼接D
练习:
public class StringTest4 {
public static void main(String[] args) {
String s1 = "helloWOrLd";
String s2 = s1.substring(0,1);
String s3 = s1.substring(1,s1.length());
String s4 = s2.toUpperCase();
String s5 = s3.toLowerCase();
String s6 = s4.concat(s5);
System.out.println(s6);
}
}
标准答案:
public class StringTest {
public static void main(String[] args) {
// 定义一个字符串
String s = "helloWORLD";
// 先获取第一个字符
String s1 = s.substring(0, 1);
// 获取除了第一个字符以外的字符
String s2 = s.substring(1);
// 把A转成大写
String s3 = s1.toUpperCase();
// 把B转成小写
String s4 = s2.toLowerCase();
// C拼接D
String s5 = s3.concat(s4);
System.out.println(s5);
// 优化后的代码
// 链式编程
String result = s.substring(0, 1).toUpperCase()
.concat(s.substring(1).toLowerCase());
System.out.println(result);
}
}
注意:substring截取是左闭右开形式的
12 String类的其他功能:
替换功能:
String replace(char old,char new)
String replace(String old,String new)
去除字符串首尾两处的空格
String trim()
按字典顺序比较两个字符串:str和str2进行相比,当str比str2大时,输出一个正整数;当str比str2小的时候输出一个负整数;str和str2相等时输出0。
*int compareTo(String str)
*int compareToIgnoreCase(String str)
// 替换功能
String s1 = "helloworld";
String s2 = s1.replace('l', 'k');
String s3 = s1.replace("owo", "ak47");
System.out.println("s1:" + s1);
System.out.println("s2:" + s2);
System.out.println("s3:" + s3);
System.out.println("---------------");
// 去除字符串两空格
String s4 = " hello world ";
String s5 = s4.trim();
System.out.println("s4:" + s4 + "---");
System.out.println("s5:" + s5 + "---");
// 按字典顺序比较两个字符串
String s6 = "hello";
String s7 = "hello";
String s8 = "abc";
String s9 = "xyz";
System.out.println(s6.compareTo(s7));// 0
System.out.println(s6.compareTo(s8));// 7
System.out.println(s6.compareTo(s9));// -16
运行结果:
s1:helloworld
s2:hekkoworkd
s3:hellak47rld
---------------
s4: hello world ---
s5:hello world---
0
7
-16
13 把int数组拼接字符串的案例
- 需求:把数组中的数据按照指定个格式拼接成一个字符串
- 举例:
int[] arr = {1,2,3}; - 输出结果:
“[1, 2, 3]” - 分析:
A:定义一个字符串对象,只不过内容为空
B:先把字符串拼接一个"["
C:遍历int数组,得到每一个元素
D:先判断该元素是否为最后一个
是:就直接拼接元素和"]"
不是:就拼接元素和逗号以及空格
E:输出拼接后的字符串
public class StringTest {
public static void main(String[] args) {
// 前提是数组已经存在
int[] arr = { 1, 2, 3 };
// 定义一个字符串对象,只不过内容为空
String s = "";
// 先把字符串拼接一个"["
s += "[";
// 遍历int数组,得到每一个元素
for (int x = 0; x < arr.length; x++) {
// 先判断该元素是否为最后一个
if (x == arr.length - 1) {
// 就直接拼接元素和"]"
s += arr[x];
s += "]";
} else {
// 就拼接元素和逗号以及空格
s += arr[x];
s += ", ";
}
}
// 输出拼接后的字符串
System.out.println("最终的字符串是:" + s);
}
}
改进版:
public class StringTest2 {
public static void main(String[] args) {
// 前提是数组已经存在
int[] arr = { 1, 2, 3 };
// 写一个功能,实现结果
String result = arrayToString(arr);
System.out.println("最终结果是:" + result);
}
/*
* 两个明确:返回值类型:String 参数列表:int[] arr
*/
public static String arrayToString(int[] arr) {
// 定义一个字符串
String s = "";
// 先把字符串拼接一个"["
s += "[";
// 遍历int数组,得到每一个元素
for (int x = 0; x < arr.length; x++) {
// 先判断该元素是否为最后一个
if (x == arr.length - 1) {
// 就直接拼接元素和"]"
s += arr[x];
s += "]";
} else {
// 就拼接元素和逗号以及空格
s += arr[x];
s += ", ";
}
}
return s;
}
}
14 字符串反转的练习
-
字符串反转
-
举例:键盘录入”abc”
-
输出结果:”cba”
-
分析:
A:键盘录入一个字符串
B:定义一个新字符串
C:倒着遍历字符串,得到每一个字符
a:length()和charAt()结合
b:把字符串转成字符数组
D:用新字符串把每一个字符拼接起来
E:输出新串
自己练习:
mport java.util.Scanner;
public class StringTest6 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("输入字符串");
String str1 = sc.nextLine();
char[] strArr = str1.toCharArray();
for (int i = 0 ;i < strArr.length / 2; i++){
char temp;
temp = strArr[i];
strArr[i] = strArr[strArr.length - i -1];
strArr[strArr.length - i - 1] = temp;
}
String str2 = new String(strArr);
System.out.println("反转字符串:"+ str2);
}
}
答案:
public class StringTest3 {
public static void main(String[] args) {
// 键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串:");
String line = sc.nextLine();
/*
// 定义一个新字符串
String result = "";
// 把字符串转成字符数组
char[] chs = line.toCharArray();
// 倒着遍历字符串,得到每一个字符
for (int x = chs.length - 1; x >= 0; x--) {
// 用新字符串把每一个字符拼接起来
result += chs[x];
}
// 输出新串
System.out.println("反转后的结果是:" + result);
*/
// 改进为功能实现
String s = myReverse(line);
System.out.println("实现功能后的结果是:" + s);
}
/*
* 两个明确:返回值类型:String 参数列表:String
*/
public static String myReverse(String s) {
// 定义一个新字符串
String result = "";
// 把字符串转成字符数组
char[] chs = s.toCharArray();
// 倒着遍历字符串,得到每一个字符
for (int x = chs.length - 1; x >= 0; x--) {
// 用新字符串把每一个字符拼接起来
result += chs[x];
}
return result;
}
}
15 在大串中查找小串出现的次数案例
-
统计大串中小串出现的次数
-
举例:
-
在字符串"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun"
-
结果:
-
java出现了5次
-
分析:
前提:是已经知道了大串和小串。A:定义一个统计变量,初始化值是0 B:先在大串中查找一次小串第一次出现的位置 a:索引是-1,说明不存在了,就返回统计变量 b:索引不是-1,说明存在,统计变量++ C:把刚才的索引+小串的长度作为开始位置截取上一次的大串,返回一个新的字符串,并把该字符串的值重新赋值给大串 D:回到B
public class StringTest7 {
public static void main(String[] args) {
String str1 = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
String str2 = "java";
int num = 0;
while(str1.contains(str2)){
num++;
int indexNum = str1.indexOf(str2);
str1 = str1.substring(indexNum + str2.length());
}
System.out.println(num);
}
}
答案:
public class StringTest4 {
public static void main(String[] args) {
// 定义大串
String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
// 定义小串
String minString = "java";
// 写功能实现
int count = getCount(maxString, minString);
System.out.println("Java在大串中出现了:" + count + "次");
}
/*
* 两个明确:返回值类型:int 参数列表:两个字符串
*/
public static int getCount(String maxString, String minString) {
// 定义一个统计变量,初始化值是0
int count = 0;
// 先在大串中查找一次小串第一次出现的位置
int index = maxString.indexOf(minString);
// 索引不是-1,说明存在,统计变量++
while (index != -1) {
count++;
// 把刚才的索引+小串的长度作为开始位置截取上一次的大串,返回一个新的字符串,并把该字符串的值重新赋值给大串
int startIndex = index + minString.length();
maxString = maxString.substring(startIndex);
// 继续查
index = maxString.indexOf(minString);
}
return count;
}
}
优化:
public class StringTest5 {
public static void main(String[] args) {
// 定义大串
String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
// 定义小串
String minString = "java";
// 写功能实现
int count = getCount(maxString, minString);
System.out.println("Java在大串中出现了:" + count + "次");
}
/*
* 两个明确:返回值类型:int 参数列表:两个字符串
*/
public static int getCount(String maxString, String minString) {
// 定义一个统计变量,初始化值是0
int count = 0;
/*
// 先在大串中查找一次小串第一次出现的位置
int index = maxString.indexOf(minString);
// 索引不是-1,说明存在,统计变量++
while (index != -1) {
count++;
// 把刚才的索引+小串的长度作为开始位置截取上一次的大串,返回一个新的字符串,并把该字符串的值重新赋值给大串
// int startIndex = index + minString.length();
// maxString = maxString.substring(startIndex);
maxString = maxString.substring(index + minString.length());
// 继续查
index = maxString.indexOf(minString);
}
*/
int index;
//先查,赋值,判断
while((index=maxString.indexOf(minString))!=-1){
count++;
maxString = maxString.substring(index + minString.length());
}
return count;
}
}
StringBuilder类
1 String类拼接问题
由于String类的对象内容不可改变,所以每当进行字符串拼接时,总是会在内存中创建一个新的对象。例如:
public class StringDemo {
public static void main(String[] args) {
String s = "Hello";
s += "World";
System.out.println(s);
}
}
在API中对String类有这样的描述:字符串是常量,它们的值在创建后不能被更改。
根据这句话分析我们的代码,其实总共产生了三个字符串,即"Hello"
、"World"
和"HelloWorld"
。引用变量s首先指向Hello
对象,最终指向拼接出来的新字符串对象,即HelloWord
。
由此可知,如果对字符串进行拼接操作,每次拼接,都会构建一个新的String对象,既耗时,又浪费空间。为了解决这一问题,可以使用java.lang.StringBuilder
类。
2 StringBuilder概述
查阅java.lang.StringBuilder
的API,StringBuilder又称为可变字符序列,它是一个类似于 String 的字符串缓冲区,通过某些方法调用可以改变该序列的长度和内容。
原来StringBuilder是个字符串的缓冲区,即它是一个容器,容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。
它的内部拥有一个数组用来存放字符串内容,进行字符串拼接时,直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。原理如下图所示:(默认16字符空间,超过自动扩充)
3 构造方法
根据StringBuilder的API文档,常用构造方法有2个:
public StringBuilder()
:构造一个空的StringBuilder容器。public StringBuilder(String str)
:构造一个StringBuilder容器,并将字符串添加进去。
public class StringBuilderDemo {
public static void main(String[] args) {
StringBuilder sb1 = new StringBuilder();
System.out.println(sb1); // (空白)
// 使用带参构造
StringBuilder sb2 = new StringBuilder("itcast");
System.out.println(sb2); // itcast
}
}
4 常用方法
StringBuilder常用的方法有2个:
public StringBuilder append(...)
:添加任意类型数据的字符串形式,并返回当前对象自身。public String toString()
:将当前StringBuilder对象转换为String对象。
append方法
append方法具有多种重载形式,可以接收任意类型的参数。任何数据作为参数都会将对应的字符串内容添加到StringBuilder中。例如:
public class Demo02StringBuilder {
public static void main(String[] args) {
//创建对象
StringBuilder builder = new StringBuilder();
//public StringBuilder append(任意类型)
StringBuilder builder2 = builder.append("hello");
//对比一下
System.out.println("builder:"+builder);
System.out.println("builder2:"+builder2);
System.out.println(builder == builder2); //true
// 可以添加 任何类型
builder.append("hello");
builder.append("world");
builder.append(true);
builder.append(100);
// 在我们开发中,会遇到调用一个方法后,返回一个对象的情况。然后使用返回的对象继续调用方法。
// 这种时候,我们就可以把代码现在一起,如append方法一样,代码如下
//链式编程
builder.append("hello").append("world").append(true).append(100);
System.out.println("builder:"+builder);
}
}
备注:StringBuilder已经覆盖重写了Object当中的toString方法。
toString方法
通过toString方法,StringBuilder对象将会转换为不可变的String对象。如:
public class Demo16StringBuilder {
public static void main(String[] args) {
// 链式创建
StringBuilder sb = new StringBuilder("Hello").append("World").append("Java");
// 调用方法
String str = sb.toString();
System.out.println(str); // HelloWorldJava
}
}
StringBuffer
1 StringBuffer的概述
线程安全的可变字符串。
StringBuffer的构造方法:
public StringBuffer()
:无参构造方法public StringBuffer(int capacity)
:指定容量的字符串缓冲区对象public StringBuffer(String str)
:指定字符串内容的字符串缓冲区对象
StringBuffer的方法:
public int capacity()
:返回当前容量。 理论值public int length()
:返回长度(字符数)。实际值
示例:
package cn.plsite.apiTest;
public class StringBufferTest {
public static void main(String[] args) {
// public StringBuffer():无参构造方法
StringBuffer sb = new StringBuffer();
System.out.println("sb:" + sb);
System.out.println("sb.capacity():" + sb.capacity());
System.out.println("sb.length():" + sb.length());
System.out.println("--------------------------");
// public StringBuffer(int capacity):指定容量的字符串缓冲区对象
StringBuffer sb2 = new StringBuffer(50);
System.out.println("sb2:" + sb2);
System.out.println("sb2.capacity():" + sb2.capacity());
System.out.println("sb2.length():" + sb2.length());
System.out.println("--------------------------");
// public StringBuffer(String str):指定字符串内容的字符串缓冲区对象
StringBuffer sb3 = new StringBuffer("hello");
System.out.println("sb3:" + sb3);
System.out.println("sb3.capacity():" + sb3.capacity());
System.out.println("sb3.length():" + sb3.length());
}
}
运行结果:
sb:
sb.capacity():16
sb.length():0
--------------------------
sb2:
sb2.capacity():50
sb2.length():0
--------------------------
sb3:hello
sb3.capacity():21
sb3.length():5
2 StringBuffer的添加功能
-
public StringBuffer append(String str)
:可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区本身 -
public StringBuffer insert(int offset,String str)
:在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
package cn.plsite.apiTest;
public class StringBufferTest {
public static void main(String[] args) {
// 创建字符串缓冲区对象
StringBuffer sb = new StringBuffer();
// public StringBuffer append(String str)
// StringBuffer sb2 = sb.append("hello");
// System.out.println("sb:" + sb);
// System.out.println("sb2:" + sb2);
// System.out.println(sb == sb2); // true
// 一步一步的添加数据
// sb.append("hello");
// sb.append(true);
// sb.append(12);
// sb.append(34.56);
// 链式编程
sb.append("hello").append(true).append(12).append(34.56);
System.out.println("sb:" + sb);
// public StringBuffer insert(int offset,String
// str):在指定位置把任意类型的数据插入到字符串缓冲区里面,并返回字符串缓冲区本身
sb.insert(5, "world");
System.out.println("sb:" + sb);
}
}
运行结果:
sb:hellotrue1234.56
sb:helloworldtrue1234.56
3 StringBuffer的删除功能
public StringBuffer deleteCharAt(int index)
:删除指定位置的字符,并返回本身public StringBuffer delete(int start,int end)
:删除从指定位置开始指定位置结束的内容,并返回本身
public class StringBufferDemo {
public static void main(String[] args) {
// 创建对象
StringBuffer sb = new StringBuffer();
// 添加功能
sb.append("hello").append("world").append("java");
System.out.println("sb:" + sb);
// public StringBuffer deleteCharAt(int index):删除指定位置的字符,并返回本身
// 需求:我要删除e这个字符,肿么办?
// sb.deleteCharAt(1);
// 需求:我要删除第一个l这个字符,肿么办?
// sb.deleteCharAt(1);
// public StringBuffer delete(int start,int
// end):删除从指定位置开始指定位置结束的内容,并返回本身
// 需求:我要删除world这个字符串,肿么办?
// sb.delete(5, 10);
// 需求:我要删除所有的数据
sb.delete(0, sb.length());
System.out.println("sb:" + sb);
}
}
4 StringBuffer的替换功能
public StringBuffer replace(int start,int end,String str)
:从start开始到end用str替换
public class StringBufferDemo {
public static void main(String[] args) {
// 创建字符串缓冲区对象
StringBuffer sb = new StringBuffer();
// 添加数据
sb.append("hello");
sb.append("world");
sb.append("java");
System.out.println("sb:" + sb);
// public StringBuffer replace(int start,int end,String
// str):从start开始到end用str替换
// 需求:我要把world这个数据替换为"节日快乐"
sb.replace(5, 10, "节日快乐");
System.out.println("sb:" + sb);
}
}
5 StringBuffer的反转功能
public StringBuffer reverse()
:StringBuffer的反转功能
public class StringBufferDemo {
public static void main(String[] args) {
// 创建字符串缓冲区对象
StringBuffer sb = new StringBuffer();
// 添加数据
sb.append("霞青林爱我");
System.out.println("sb:" + sb);
// public StringBuffer reverse()
sb.reverse();
System.out.println("sb:" + sb);
}
}
6 StringBuffer的截取功能
StringBuffer的截取功能:注意返回值类型不再是StringBuffer本身了
public String substring(int start)
public String substring(int start,int end)
public static void main(String[] args) {
// 创建字符串缓冲区对象
StringBuffer sb = new StringBuffer();
// 添加元素
sb.append("hello").append("world").append("java");
System.out.println("sb:" + sb);
// 截取功能
// public String substring(int start)
String s = sb.substring(5);
System.out.println("s:" + s);
System.out.println("sb:" + sb);
// public String substring(int start,int end)
String ss = sb.substring(5, 10);
System.out.println("ss:" + ss);
System.out.println("sb:" + sb);
}
结果:
sb:helloworldjava
s:worldjava
sb:helloworldjava
ss:world
sb:helloworldjava
7 StringBuffer和String的相互转换
String – StringBuffer
注意:不能把字符串的值直接赋值给StringBuffer
- 方式1:通过构造方法
StringBuffer sb = new StringBuffer(s); - 方式2:通过append()方法
StringBuffer sb2 = new StringBuffer();
sb2.append(s);
StringBuffer – String
- 方式1:通过构造方法
String str = new String(buffer); - 方式2:通过toString()方法
String str2 = buffer.toString();
public class StringBufferTest {
public static void main(String[] args) {
// String -- StringBuffer
String s = "hello";
// 注意:不能把字符串的值直接赋值给StringBuffer
// StringBuffer sb = "hello";
// StringBuffer sb = s;
// 方式1:通过构造方法
StringBuffer sb = new StringBuffer(s);
// 方式2:通过append()方法
StringBuffer sb2 = new StringBuffer();
sb2.append(s);
System.out.println("sb:" + sb);
System.out.println("sb2:" + sb2);
System.out.println("---------------");
// StringBuffer -- String
StringBuffer buffer = new StringBuffer("java");
// String(StringBuffer buffer)
// 方式1:通过构造方法
String str = new String(buffer);
// 方式2:通过toString()方法
String str2 = buffer.toString();
System.out.println("str:" + str);
System.out.println("str2:" + str2);
}
}
8 判断一个字符串是否对称
-
判断一个字符串是否是对称字符串
-
例如"abc"不是对称字符串,“aba”、“abba”、“aaa”、"mnanm"是对称字符串
-
分析:
判断一个字符串是否是对称的字符串,我只需要把
第一个和最后一个比较
第二个和倒数第二个比较
…
比较的次数是长度除以2。
public class StringBufferTest4 {
public static void main(String[] args) {
// 创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串:");
String s = sc.nextLine();
// 一个一个的比较
boolean b = isSame(s);
System.out.println("b:" + b);
//用字符串缓冲区的反转功能
boolean b2 = isSame2(s);
System.out.println("b2:"+b2);
}
public static boolean isSame2(String s) {
return new StringBuffer(s).reverse().toString().equals(s);
}
public static boolean isSame(String s) {
boolean flag = true;
// 把字符串转成字符数组
char[] chs = s.toCharArray();
for (int start = 0, end = chs.length - 1; start <= end; start++, end--) {
if (chs[start] != chs[end]) {
flag = false;
break;
}
}
return flag;
}
}
9 String,StringBuffer,StringBuilder的区别
- A:String是内容不可变的,而StringBuffer,StringBuilder都是内容可变的。String类是不可变类,即一旦一个String对象被创建以后,包含在这个对象中的字符序列是不可改变的,直至这个对象被销毁。StringBuffer对象则代表一个字符序列可变的字符串,当一个StringBuffer被创建以后,通过StringBuffer提供的append()、insert()、reverse()、setCharAt()、setLength()等方法可以改变这个字符串对象的字符序列。一旦通过StringBuffer生成了最终想要的字符串,就可以调用它的toString()方法将其转换为一个String对象。
- B:StringBuffer是同步的,数据安全,效率低,StringBuffer类中的方法都添加了synchronized关键字,也就是给这个方法添加了一个锁,用来保证线程安全;StringBuilder是不同步的,数据不安全,效率高
Java9改进了字符串(包括String、StringBuffer、StringBuilder)的实现。在Java9以前字符串采用char[]数组来保存字符,因此字符串的每个字符占2字节;而Java9的字符串采用byte[]数组再加一个encoding-flag字段来保存字符,因此字符串的每个字符只占1字节。所以Java9的字符串更加节省空间,字符串的功能方法也没有受到影响.