Java
–String
&&StringBuffer
&&StringBuilder
文章目录
String
字符串广泛应用 在 Java 编程中,在 Java 中字符串属于对象,Java 提供了 String 类来创建和操作字符串。
创建字符串
创建字符串最简单的方式如下:
String str = "Runoob";
在代码中遇到字符串常量时,这里的值是 “Runoob
”",编译器会使用该值创建一个 String 对象。
和其它对象一样,可以使用关键字和构造方法来创建 String 对象。
用构造函数创建字符串:
String str2=new String("Runoob");
String 创建的字符串存储在公共池中,而 new 创建的字符串对象在堆上:
String s1 = "Runoob"; // String 直接创建
String s2 = "Runoob"; // String 直接创建
String s3 = s1; // 相同引用
String s4 = new String("Runoob"); // String 对象创建
String s5 = new String("Runoob"); // String 对象创建
String 类有 11 种构造方法,这些方法提供不同的参数来初始化字符串,比如提供一个字符数组参数:
public class StringDemo{
public static void main(String args[]){
char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};
String helloString = new String(helloArray);
System.out.println( helloString );
}
}
runoob
**注意:**String 类是不可改变的,所以你一旦创建了 String 对象,那它的值就无法改变了(详看笔记部分解析)。
如果需要对字符串做很多修改,那么应该选择使用 StringBuilder
类
字符串的替换
replace()
public static void main(String[] args) {
String str1 = "hello word";
String str2 = str1.replace("hello", "hi");
String str3 = str1.replace("abc", "hi");
System.out.println("str2:"+str2); //输出 hi word
System.out.println("str3"+str3); //输出 hello word(要替换的目标不存在)
}
replaceall()
public static void main(String[] args) {
String str1 = "hello word";
String str2 = str1.replaceAll("o", "O"); //把字符串中的 o全部替换为 O
String str3 = str1.replaceAll("123", "A");
System.out.println("str2:"+str2); //输出 hellO wOrd
System.out.println("str3"+str3); //输出 hello word(要替换的目标不存在)
}
replaceFirst()
public static void main(String[] args) {
String str1 = "hello word";
String str2 = str1.replaceFirst("h", "H");
String str3 = str1.replaceFirst("o", "O"); //把字符串中第一个 o替换为 O
String str4 = str1.replaceFirst("111", "H");
System.out.println("str2:"+str2); //输出 Hello word
System.out.println("str3"+str3); //输出 hellO word
System.out.println("str4"+str4); //输出 hello word(要替换的目标不存在)
}
字符串的拆分
split(String regex)
public static void main(String[] args) {
String str1 = "你见过洛杉矶1凌晨四点的1样子吗?";
String[] strs = str1.split("1");
for(String s : strs){
System.out.println("s------"+s);
}
}
split(String regex, int limit)
public static void main(String[] args) {
String str1 = "abc1def1ghi1";
String[] str2 = str1.split("1", 555);
for(String s2 : str2){
System.out.println("s2---"+s2);
}
String[] str3 = str1.split("1", 3);
for(String s3 : str3){
System.out.println("s3---"+s3);
}
}
字符串的截取
substring(int beginIndex)
String str1 = "abcdefghi";
String str2 = str1.substring(2); //截取下标为2(含2)
System.out.println(str2);
substring(int beginIndex, int endIndex)
String str1 = "abcdefghi";
String str2 = str1.substring(2,4); //从下标为2的字符开始截取,截取到下标为4的字符(含2不含4)
System.out.println(str2);
字符串的查找
contains()
String str = "Hello Word";
boolean result1 = str.contains("l");
boolean result2 = str.contains("s");
System.out.println(result1); //输出 true
System.out.println(result2); //输出 false
endsWith()
//此方法测试字符串是否以指定的后缀结束
String str = "Hello Word";
boolean result1 = str.endsWith("d");
boolean result2 = str.endsWith("s");
System.out.println(result1); //输出 true
System.out.println(result2); //输出 false
startsWith(String prefix)
//此方法测试字符串是否以指定的字符开始
String str = "Hello Word";
boolean result1 = str.startsWith("H");
boolean result2 = str.startsWith("h");
System.out.println(result1); //输出 true
System.out.println(result2); //输出 false
startsWith(String prefix, int offIndex)
String str = "Hello Word";
boolean result1 = str.startsWith("H",0);
boolean result2 = str.startsWith("h",0);
boolean result3 = str.startsWith("e",1);
boolean result4 = str.startsWith("l",2);
boolean result5 = str.startsWith("l",3);
System.out.println(result1); //输出 true
System.out.println(result2); //输出 false
System.out.println(result3); //输出 true
System.out.println(result4); //输出 true
System.out.println(result5); //输出 true
indexOf(String str)
//返回指定字符在字符串中第一次出现处的索引(下标),如果此字符串中没有这样的字符,则返回 -1
String str = "Hello Word";
int res1 = str.indexOf("e");
int res2 = str.indexOf("s");
System.out.println(res1); //输出 1
System.out.println(res2); //输出-1
indexOf(String str, int fromIndex)
//返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引,如果此字符串中没有这样的字符,则返回 -1
String str = "Hello Word";
int res1 = str.indexOf("o",5);
int res2 = str.indexOf("s");
System.out.println(res1); //输出 7
System.out.println(res2); //输出-1
lastindexOf(String str)
//返回指定字符在此字符串中最后一次出现处的索引,如果此字符串中没有这样的字符,则返回 -1
String str = "Hello Word";
int res1 = str.lastIndexOf("o");
int res2 = str.indexOf("s");
System.out.println(res1); //输出 7
System.out.println(res2); //输出 -1
lastindexOf(String str, int fromIndex)
//从fromIndex个字符中找,返回指定字符在此字符串中最后一次出现处的索引,如果此字符串中没有这样的字符,则返回 -1
String str = "Hello Wordollo";
int res1 = str.lastIndexOf("o",9);
int res2 = str.indexOf("s");
System.out.println(res1); //输出 7
System.out.println(res2); //输出 -1
charAt(int index)
//返回指定索引处的字符。索引范围为从 0 到 length() - 1
String str = "Hello Wordollo";
char str1 = str.charAt(0);
char str2 = str.charAt(6);
System.out.println(str1); //输出 H
System.out.println(str2); //输出 W
字符串的比较
equals()
String str1 = "你见过洛杉矶凌晨四点的样子吗?";
String str2 = "ABC";
String str3 = "你见过洛杉矶凌晨四点的样子吗?";
System.out.println(str1.equals(str2)); //输出 false
System.out.println(str1.equals(str3)); //输出 true
equalsIgnoreCase()
//不区分大小写
String str1 = "abc";
String str2 = "ABC";
System.out.println(str1.equalsIgnoreCase(str2)); //输出 true
compareTo(String str)
/*
*用于两种方式的比较:
* 字符串与对象进行比较
* 按字典顺序比较两个字符串
* 返回值是整型,它是先比较对应字符的大小(ASCII码顺序),如果第一个字符和参数的第一个字符不等,结束比较,返回他们之间的差值,如果第一个字符和参数的第一个字符相等,则以第二个字符和参数的第二个字符做比较,以此类推,直至比较的字符或被比较的字符有一方
* 如果参数字符串等于此字符串,则返回值 0
* 如果此字符串小于字符串参数,则返回一个小于 0 的值
* 如果此字符串大于字符串参数,则返回一个大于 0 的值
*/
String str1 = "a";
String str2 = "A";
String str3 = "bb";
String str4 = "a";
System.out.println(str1.compareTo(str2)); //输出 32
System.out.println(str1.compareTo(str3)); //输出 -1
System.out.println(str1.compareTo(str4)); //输出 0
compareToIgnoreCase(String str)
//按字典顺序比较两个字符串,不考虑大小写
/*
* 如果参数字符串等于此字符串,则返回值 0
* 如果此字符串小于字符串参数,则返回一个小于 0 的值
* 如果此字符串大于字符串参数,则返回一个大于 0 的值
**/
String str1 = "a";
String str2 = "A";
String str3 = "bb";
String str4 = "a";
System.out.println(str1.compareToIgnoreCase(str2)); //输出 0
System.out.println(str1.compareToIgnoreCase(str3)); //输出 -1
System.out.println(str1.compareToIgnoreCase(str4)); //输出 0
/*
* 在compareTo上返回的数据类型是int型,有如下三种返回:
* 大于:> 0
* 小于:< 0
* 等于: = 0
* compareTo对于大小的比较实际上就是对字母编码的比较
**/
字符串转为数组
将字符串转为字节数组
getBytes(String charsetName)
: 使用指定的字符集将字符串编码为 byte 序列,并将结果存储到一个新的 byte 数组中getBytes()
使用平台的默认字符集将字符串编码为 byte 序列,并将结果存储到一个新的 byte 数组中
public static void main(String args[]) {
String Str1 = new String("runoob");
try{
byte[] Str2 = Str1.getBytes();
System.out.println( Str2 ); //输出 [B@7852e922
Str2 = Str1.getBytes( "UTF-8" );
System.out.println( Str2 ); //输出 [B@4e25154f
Str2 = Str1.getBytes( "ISO-8859-1" );
System.out.println( Str2 ); //输出 [B@70dea4e
} catch ( UnsupportedEncodingException e){
System.out.println("不支持的字符集");
}
}
将字符串变为字节数组
toCharArray() 方法将字符串转换为字符数组
public static void main(String args[]) {
String Str = new String("www.runoob.com");
System.out.println( Str.toCharArray() ); //输出 www.runoob.com
}
其他方法
字符串长度
大写转小写
小写转大写
去掉前后空格(中间保留)
字符串连接(一般用+)
将内容保存到对象池中
判断是否是空字符串
StringBuffer
StringBuffer
类提供了 3 个构造方法来创建一个字符串,如下所示:
StringBuffer()
构造一个空的字符串缓冲区,并且初始化为 16 个字符的容量。StringBuffer(int length)
创建一个空的字符串缓冲区,并且初始化为指定长度 length 的容量。StringBuffer(String str)
创建一个字符串缓冲区,并将其内容初始化为指定的字符串内容 str,字符串缓冲区的初始容量为 16 加上字符串str
的长度。
创建StringBuffer
类对象
使用 StringBuffer
类的构造函数的示例如下:
// 定义一个空的字符串缓冲区,含有16个字符的容量
StringBuffer str1 = new StringBuffer();
// 定义一个含有10个字符容量的字符串缓冲区
StringBuffer str2 = new StringBuffer(10);
// 定义一个含有(16+4)的字符串缓冲区,"青春无悔"为4个字符
StringBuffer str3 = new StringBuffer("青春无悔");
/*
*输出字符串的容量大小
*capacity()方法返回字符串的容量大小
*/
System.out.println(str1.capacity()); // 输出 16
System.out.println(str2.capacity()); // 输出 10
System.out.println(str3.capacity()); // 输出 20
上述代码声明了 3 个 StringBuffer
对象 str1
、str2
和 str3
,并分别对其进行初始化。str1.capacity()
用于查看 str1
的容量,接着以同样的方式对 str2
和 str3
进行容量查看的操作。
StringBuffer
的数据追加
StringBuffer
类的 append() 方法用于向原有 StringBuffer
对象中追加字符串。该方法的语法格式如下:
StringBuffer 对象.append(String str)
该方法的作用是追加内容到当前 StringBuffer
对象的末尾,类似于字符串的连接。调用该方法以后,StringBuffer
对象的内容也发生了改变,例如:
StringBuffer buffer = new StringBuffer("hello,"); // 创建一个 StringBuffer 对象
String str = "World!";
buffer.append(str); // 向 StringBuffer 对象追加 str 字符串
System.out.println(buffer.substring(0)); // 输出:Hello,World!
example
:
每个新学期开始,学校都会针对本学期课程列出必修课程。编写一个 Java 程序,要求用户向控制台循环录入五门必修课程名称,并将这五个名称进行连接,最后输出连接后的字符串。代码如下:
import java.util.Scanner;
public class Testl9 {
public static void main(String[] args) {
StringBuffer sys = new StringBuffer("校内课程管理");
System.out.println("欢迎进入《"+sys+"》系统");
// 声明课程名称字符串
StringBuffer courseName = new StringBuffer();
System.out.println("请录入本期的五门必修课名称:");
Scanner input = new Scanner(System.in);
// 循环接收控制台输入的字符串
String name = "";
for (int i = 0;i < 5;i++) {
name = input.next();
courseName.append(name+"\t");
if(i == 4) {
System.out.println("录入完毕!");
}
}
System.out.println("本学期的必修课程有:\n"+courseName);
}
在该程序中,首先声明一个空的 StringBuffer 对象,然后声明并初始化 courseName 变量,该变量用于存储用户从控制台输入的课程名称,接着使用 for 循环语句来循环接收用户输入数据。在循环体中,调用 StringBuffer 对象的 append() 方法对用户输入的字符串进行追加,当用户录完五门课程的名称后,程序将输出“录入完毕!”的提示信息。最后输出 String-Buffer 对象字符串。
运行程序,执行结果如下所示:
StringBuffer sb = new StringBuffer("hello");
sb.setCharAt(1,'E');
System.out.println(sb); // 输出:hEllo
sb.setCharAt(0,'H');
System.out.println(sb); // 输出:HEllo
sb.setCharAt(2,'p');
System.out.println(sb); // 输出:HEplo
StringBuffer
数据的插入
public StringBuffer insert(int offset, boolean b)
该方法的作用是在StringBuffer对象中插入内容,然后形成新的字符串
example
:
StringBuffer sb = new StringBuffer(“TestString”);
sb.insert(4,false); //TestfalseString
该示例代码的作用是在对象sb的索引值4的位置插入false值,形成新的字符串,则执行以后对象sb的值是”TestfalseString”。
StringBuffer
数据的替换
public void setCharAt(int index, char ch)
该方法的作用是修改对象中索引值为index位置的字符为新的字符ch。例如:
example
:
StringBuffer sb = new StringBuffer(“abc”);
sb.setCharAt(1,’D’); //aDc
StringBuffer
清除无效空格
public void trimToSize()
该方法的作用是将StringBuffer对象的中存储空间缩小到和字符串长度一样的长度,减少空间的浪费。
StringBuffer
反转字符串
StringBuffer
类中的 reverse() 方法用于将字符串序列用其反转的形式取代。该方法的语法格式如下:
StringBuffer 对象.reverse();
使用 StringBuffer
类中的 reverse() 方法对字符串进行反转的示例如下:
StringBuffer sb = new StringBuffer("java");
sb.reverse();System.out.println(sb); // 输出:avaj
StringBuffer
删除字符串
StringBuffer
类提供了 deleteCharAt()
和 delete()
两个删除字符串的方法,下面详细介绍。
deleteCharAt()
方法
deleteCharAt() 方法用于移除序列中指定位置的字符,该方法的语法格式如下:
StringBuffer 对象.deleteCharAt(int index);
deleteCharAt() 方法的作用是删除指定位置的字符,然后将剩余的内容形成一个新的字符串。例如:
StringBuffer sb = new StringBuffer("She");
sb.deleteCharAt(2);System.out.println(sb);
// 输出:Sh执行该段代码,将字符串 sb 中索引值为 2 的字符删除,剩余的内容组成一个新的字符串,因此对象 sb 的值为 Sh
delete()
方法
delete() 方法用于移除序列中子字符串的字符,该方法的语法格式如下:
StringBuffer 对象.delete(int start,int end);
其中,start 表示要删除字符的起始索引值(包括索引值所对应的字符),end 表示要删除字符串的结束索引值(不包括索引值所对应的字符)。该方法的作用是删除指定区域以内的所有字符,例如:
StringBuffer sb = new StringBuffer("hello jack");
sb.delete(2,5);
System.out.println(sb); // 输出:he jacksb.delete(2,5);System.out.println(sb); // 输出:heck
执行该段代码,将字符串“hello jack”索引值为 2(包括)到索引值为 5(不包括)之间的所有字符删除,因此输出的新的字符串的值为“he jack”。
StringBuilder
对于 StringBuilder
我这里就不做过多介绍了,我们就简单的看下,想深度了解的话,请小伙伴们自行去百度吧
- 没有使用StringBuilder的话,用字符串拼接耗时耗空间。
StringBuilder
让我们来看一个简单的案例方便我们理解下
package com.Brooke01;
public class StringBuliderDemo1 {
public static void main(String[] args) {
StringBuilder strBui = new StringBuilder("ssa");
System.out.println("strBui:"+strBui);
System.out.println("当前容量:"+strBui.capacity());
System.out.println("长度是:"+strBui.length());
}
}
结果:
strBui:ssa
当前容量:19
长度是:3
StringBUilder
的拼接功能和反转功能
package com.Brooke01;
public class StringBuilderDemo2 {
public static void main(String[] args) {
StringBuilder strBui = new StringBuilder();
//链式编程,拼接
strBui.append(true).append("abc").append(100);
System.out.println(strBui);
//反转
System.out.println(strBui.reverse());
}
}
结果:
trueabc100
001cbaeurt
StringBuilder
和String
的相互转换
package com.Brooke01;
public class StringBuilderTest1 {
public static void main(String[] args) {
StringBuilder strBui = new StringBuilder();
strBui.append("hello").append("world");
String str = strBui.toString();
System.out.println("StringBuilder转换为String输出:"+str);
StringBuilder strBui1 = new StringBuilder(str);
System.out.println("String转换为StringBuilder输出:"+strBui1);
}
}
输出结果如下:
StringBuilder转换为String输出:helloworld
String转换为StringBuilder输出:helloworld
运用StringBuilder使数组元素按格式拼接
package com.Brooke01;
/*
* 数组元素按格式拼接
*/
public class StringBuilderTest2 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
String str = arrToString(arr);
System.out.println("拼接后的字符串:"+str);
}
public static String arrToString(int[] arr) {
StringBuilder strBui = new StringBuilder();
strBui.append("[");
for(int x=0;x<arr.length;x++) {
if(x == arr.length-1) {
strBui.append(arr[x]);
}
else {
strBui.append(arr[x]).append(",");
}
}
strBui.append("]");
String str = strBui.toString();
return str;
}
}
输出结果如下:
拼接后的字符串:[1,2,3,4,5]
String
字符串转为StringBuilder
并反转再转回String输出
package com.Brooke01;
/*
* String字符串转为StringBuilder并反转再转回String输出
*/
import java.util.Scanner;
public class StringBuilderTest3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串:");
String str = sc.nextLine();
String strRes = myReserve(str);
System.out.println("反转后的字符串是:"+strRes);
}
public static String myReserve(String str) {
StringBuilder strBui = new StringBuilder(str);
strBui.reverse();
String str1 = strBui.toString();
return str1;
}
}
结果:
请输入一个字符串:
abcde
反转后的字符串是:edcba
判断字符串是否对称
package com.Brooke01;
/*
* 判断字符串是否对称
*/
import java.util.Scanner;
public class StringBuilderTest4 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串:");
String str = sc.nextLine();
boolean b = isSymmetry(str);
System.out.println("是否对称:"+b);
}
public static boolean isSymmetry(String str) {
StringBuilder strBui = new StringBuilder(str);
strBui.reverse();
String strRes = strBui.toString();
return strRes.equals(str);
}
}
结果:
请输入一个字符串:
abc
是否对称:false
String
、StringBuffer
、StringBuilder
的区别
String | StringBuffer | StringBuilder | |
---|---|---|---|
执行速度 | 最差 | 其次 | 最高 |
线程安全 | 线程安全 | 线程安全 | 线程不安全 |
使用场景 | 少量字符串操作 | 多线程环境下的大量操作 | 单线程环境下的大量操作 |
String:
对于String来说,是把数据存放在了常量池中,因为所有的String,默认都是以常量形式保存,且由final修饰,因此在线程池中它是线程安全的。因为每一个String当被创建好了以后,他就不再发生任何变化,但是它的执行速度是最差的。
我们要创建String的时候,他在常量池中对这些信息进行处理,如果在程序中出现了大量字符串拼接的工作,效率是非常底下的。
因此使用场景是在少量字符串操作的时候才建议直接使用String来操作。
StirngBuffer
:(效率不如StringBuilder
,但远比String要高)
StringBuffer
相对于StringBuilder
效率要相对低一点,但也远比String要高的多。效率低的原因:对于StringBuffer
来说更多的考虑到了多线程的情况,在进行字符串操作的时候,它使用了synchronize关键字,对方法进行了同步处理。
因此StringBuffer适用于多线程环境下的大量操作。
StringBuilder
:(没有考虑线程安全问题)
线程安全与线程不安全:
在进行多线程处理的时候,如果多个线程对于这一个对象同时产生操作,会产生预期之外的结果。对于StringBuilder
来说,执行效率虽然高,但是因为线程不安全,所以不建议在多线程的环境下对同一个StringBuilder
对象进行操作。
因此StringBuilder
适用于单线程环境下的大量字符串操作。