投稿
  1. 首页
  2. 随笔

`java`学习笔记（十二）`Java`--`String`&&`StringBuffer`&&`StringBuilder`

xyz • 2022-11-8 • 随笔 • 阅读 14

`java`学习笔记（十二）`Java`--`String`&&`StringBuffer`&&`StringBuilder`,第1张

`java`学习笔记（十二）`Java`--`String`&&`StringBuffer`&&`StringBuilder` Java–String&&StringBuffer&&StringBuilder

文章目录
  • `Java`--`String`&&`StringBuffer`&&`StringBuilder`
    • String
      • 创建字符串
      • **字符串的替换**
        • `replace()`
        • `replaceall()`
        • `replaceFirst()`
      • **字符串的拆分**
        • `split(String regex)`
        • `split(String regex, int limit)`
      • **字符串的截取**
        • `substring(int beginIndex)`
        • `substring(int beginIndex, int endIndex)`
      • **字符串的查找**
        • `contains()`
        • `endsWith()`
        • `startsWith(String prefix)`
        • `startsWith(String prefix, int offIndex)`
        • `indexOf(String str)`
        • `indexOf(String str, int fromIndex)`
        • `lastindexOf(String str)`
        • `lastindexOf(String str, int fromIndex)`
        • `charAt(int index)`
      • **字符串的比较**
        • `equals()`
        • `equalsIgnoreCase()`
        • `compareTo(String str)`
        • `compareToIgnoreCase(String str)`
      • **字符串转为数组**
        • 将字符串转为字节数组
        • 将字符串变为字节数组
      • **其他方法**
        • 字符串长度
        • 大写转小写
        • 小写转大写
        • 去掉前后空格(中间保留)
        • 字符串连接(一般用+)
        • 将内容保存到对象池中
        • 判断是否是空字符串
    • `StringBuffer`
      • 创建`StringBuffer`类对象
      • `StringBuffer`的数据追加
        • `example`:
      • `StringBuffer`数据的插入
        • `example`:
      • `StringBuffer`数据的替换
        • `example`:
      • `StringBuffer`清除无效空格
      • `StringBuffer`反转字符串
      • `StringBuffer`删除字符串
        • `deleteCharAt()` 方法
        • `delete()` 方法
    • `StringBuilder`
      • `StringBuilder`
      • `StringBUilder`的拼接功能和反转功能
      • `StringBuilder`和`String`的相互转换
      • 运用StringBuilder使数组元素按格式拼接
      • `String`字符串转为`StringBuilder`并反转再转回String输出
      • 判断字符串是否对称
      • `String`、`StringBuffer`、`StringBuilder`的区别
      • String：
      • `StirngBuffer`：（效率不如`StringBuilder`，但远比String要高）
      • `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) 
		
		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) 
		//按字典顺序比较两个字符串，不考虑大小写
		
		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
字符串转为数组 将字符串转为字节数组

  • 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("青春无悔");

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 

输出结果如下：
 

拼接后的字符串：[1,2,3,4,5]

 
String字符串转为StringBuilder并反转再转回String输出 

package com.Brooke01;

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的区别 
StringStringBufferStringBuilder执行速度最差其次最高线程安全线程安全线程安全线程不安全使用场景少量字符串 *** 作多线程环境下的大量 *** 作单线程环境下的大量 *** 作
String： 

 
 
对于String来说，是把数据存放在了常量池中，因为所有的String，默认都是以常量形式保存，且由final修饰，因此在线程池中它是线程安全的。因为每一个String当被创建好了以后，他就不再发生任何变化，但是它的执行速度是最差的。
 我们要创建String的时候，他在常量池中对这些信息进行处理，如果在程序中出现了大量字符串拼接的工作，效率是非常底下的。
 因此使用场景是在少量字符串 *** 作的时候才建议直接使用String来 *** 作。
 

 
StirngBuffer：（效率不如StringBuilder，但远比String要高） 

 
 
StringBuffer相对于StringBuilder效率要相对低一点，但也远比String要高的多。效率低的原因：对于StringBuffer来说更多的考虑到了多线程的情况，在进行字符串 *** 作的时候，它使用了synchronize关键字，对方法进行了同步处理。
 因此StringBuffer适用于多线程环境下的大量 *** 作。
 

 
StringBuilder：（没有考虑线程安全问题） 

 
 
线程安全与线程不安全：
 在进行多线程处理的时候，如果多个线程对于这一个对象同时产生 *** 作，会产生预期之外的结果。对于StringBuilder来说，执行效率虽然高，但是因为线程不安全，所以不建议在多线程的环境下对同一个StringBuilder对象进行 *** 作。
 因此StringBuilder适用于单线程环境下的大量字符串 *** 作。
 

					
										


					

						
欢迎分享，转载请注明来源：内存溢出
原文地址: http://outofmemory.cn/zaji/4748525.html
赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
xyz xyz 一级用户组
0 0
上一篇 2022-11-08
下一篇 2022-11-08

发表评论

登录后才能评论

评论列表（0条）

保存