天天看點
傳回

Java系列（34）——可變字元串

本系列部落格彙總在這裡：Java系列_彙總

目錄

  • 一、StringBuffer 概述
  • 二、StringBuffer 和 String 的差別
  • 三、StringBuffer 的 append 方法
  • 四、可變字元串的追加
  • 五、StringBuffer 類的部分方法
  • 六、可變字元串的修改
    • 1、插入
    • 2、删除
    • 3、替換
    • 4、字元串的反轉
    • 5、某個字元串倒序索引
    • 6、以上 3、4、5 示例

一、StringBuffer 概述

StringBuffer：字元串緩沖區。

  1. String一旦被建立後，值不能改變，如果參與了操作，引用發生了變化，不是在原有的字元串上操作，而是産生了一個字元串。但是 StringBuffer 一旦發生改變，就是在原有的基礎上改變的。

  2. 示例

    String

    String s = “hello”;
s += “world”;
System.out.println(s);//helloworld
    StringBuffer 
    StringBuffer b = “hello”;
b +=”world”;//使用hello的空間追加world，不是建立一個字元串。
System.out.println(s);//helloworld
  3. 關于線程：
    Java系列（34）——可變字元串
    Java系列（34）——可變字元串
    Java系列（34）——可變字元串
    StringBuffer是線程安全的，效率稍低。
  1. append 方法
    Java系列（34）——可變字元串
  2. package cn.tx;

public class Demo
{
	public static void main(String[] args)
	{
		/**
		 * append(boolean b) 描述：将 boolean參數的字元串表示附加到序列中。
		 */
		// 建立可變字元串，因為StringBuffer類裡有StringBuffer()構造器，是以可以直接new
		StringBuffer sb = new StringBuffer();
		// 把可變字元串做追加字元true
		StringBuffer sb1 = sb.append(true);
		// System.out.println(sb1);
		// 判斷StringBuffer追加後的字元串的位址是否相等
		System.out.println(sb == sb1);
		
		/**
		 * 對比String
		 */
		String str = "abc";
		// 字元串加上任何類型傳回的都是字元串，加上字元true
		String str1 = str + true;
		// System.out.println(str1);
		// 判斷String追加後的字元串的位址是否相等
		System.out.println(str == str1);

		/**
		 * 其餘append()不再示範，詳見API
		 */
	}
}
    Java系列（34）——可變字元串
  1. StringBuffer 的構造器
    Java系列（34）——可變字元串
  2. package cn.tx;

public class Demo
{
	public static void main(String[] args)
	{
		// 構造器一
		StringBuffer sb = new StringBuffer();

		/**
		 * length() 描述：傳回長度（字元數）。
		 */
		System.out.println("可變字元串的長度：" + sb.length());

		/**
		 * capacity() 描述：傳回目前容量。
		 */
		System.out.println("可變字元串的容量：" + sb.capacity());

		/**
		 * 追加後
		 */
		// 追加後的長度及容量變化,容量預設是16（可指定），未滿16，容量不會發生變化
		sb.append("liuchengjuan^_^kangyanfeng");
		System.out.println("可變字元串的長度為：" + sb.length() + "容量為：" + sb.capacity());

		/**
		 * 指定容量的建立
		 */
		// 建立一個10個容量的字元串（構造器二）
		StringBuffer sb1 = new StringBuffer(10);
		sb1.append("liuchengjuan^_^kangyanfeng");
		System.out.println("可變字元串的長度為：" + sb1.length() + "容量為：" + sb1.capacity());

		/**
		 * 帶參建立
		 */
		// 建立一個帶有字元串參數的可變字元串（構造器三）
		StringBuffer sb2 = new StringBuffer("liuchengjuan^_^kangyanfeng");
		System.out.println("可變字元串的長度為：" + sb2.length() + "容量為：" + sb2.capacity());
	}
}
    Java系列（34）——可變字元串
  1. 更多參見 API
    Java系列（34）——可變字元串
    Java系列（34）——可變字元串
    Java系列（34）——可變字元串
  2. package cn.tx;

public class Demo
{

	public static void main(String[] args)
	{
		// 建立可變字元串，開辟一個預設是16 個字元的空間
		StringBuffer sb = new StringBuffer();
		sb.append(true).append('q')// 位元組
				.append(new char[] { 'l', 'c', 'j' })// 數組
				.append("kang")// 字元串
				.append(100d)// double
				.append(14.5f)// float
				.append(13);// int

		System.out.println(sb);

		// 可變字元串對象的追加
		Person p = new Person();
		p.setIdcard("520");
		p.setName("劉成娟");
		p.setAge("18");
		p.setGender("1");

		// 追加了一個Person類的對象,列印拼接的應該是Person類toString的值
		sb.append(p);
		System.out.println(sb);

		StringBuffer sb1 = new StringBuffer("liuchengjuan");
		// 可變字元串1追加可變字元串2
		sb.append(sb1);
		System.out.println(sb);
	}
}
           
    package cn.tx;

public class Person
{
	private String idcard;
	private String name;
	private String age;
	private String gender;

	public String getIdcard()
	{
		return idcard;
	}

	public void setIdcard(String idcard)
	{
		this.idcard = idcard;
	}

	public String getName()
	{
		return name;
	}

	public void setName(String name)
	{
		this.name = name;
	}

	public String getAge()
	{
		return age;
	}

	public void setAge(String age)
	{
		this.age = age;
	}

	public String getGender()
	{
		return gender;
	}

	public void setGender(String gender)
	{
		this.gender = gender;
	}

	@Override
	public String toString()
	{
		return "Person [idcard=" + idcard + ", name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}
}
    Java系列（34）——可變字元串

六、可變字元串的修改

StringBuffer 字元串處理。

Java系列（34）——可變字元串
  • package cn.tx;

public class Demo
{

	public static void main(String[] args)
	{
		StringBuffer sb = new StringBuffer("liuchengjuan");
		// sb.insert(2, true);

		/**
		 * insert(int offset, String str) 描述： 将字元串插入到此字元序列中。
		 */
		// 在指定的索引位置插入字元串，注意不要出現字元串索引越界的問題
		sb.insert(2, "kang");
		System.out.println(sb);

		/**
		 * insert(int offset, char[] str) miaoshu :在此序列中插入 char數組參數的字元串表示形式。
		 */
		// 插入數組
		sb.insert(3, new char[] { 'k', 'y', 'f' });
		System.out.println(sb);

		/**
		 * insert(int index, char[] str, int offset, int len) 描述：在此序列中插入
		 * str數組參數的子陣列的字元串表示形式。
		 */
		// 第一個參數是要插入的索引位置，第二個參數是要插入的字元數組，第三個參數是數組的起始索引，第四個參數是要插入的長度
		// 在字元串索引3的位置處插入數組cs索引從1開始往後2長度的字元串
		char[] cs = { 'j', 'u', 'a', 'n' };
		sb.insert(3, cs, 1, 2);
		System.out.println(sb);

		/**
		 * 其餘insert不再示範，詳見API
		 */
	}
}
    Java系列（34）——可變字元串

Java系列（34）——可變字元串
  • package cn.tx;

public class Demo
{
	public static void main(String[] args)
	{
		StringBuffer sb = new StringBuffer("juan");

		/**
		 * delete(int start, int end) 描述： 删除此序列的子字元串中的字元。
		 */
		// 第一個是删除的開始索引，第二個是結束索引（删除包含開始索引，不包含結束索引）
		// 有點數組越界的味道，但是不是數組越界，此處沒有這個概念
		sb.delete(2, 4);
		System.out.println(sb);

		/**
		 * deleteCharAt(int index) 描述：删除 char在這個序列中的指定位置。
		 */
		// 删除指定索引位置的字元（此處有越界的概念 ）
		sb.deleteCharAt(1);
		System.out.println(sb);
	}
}
    Java系列（34）——可變字元串

Java系列（34）——可變字元串

  • package cn.tx;

public class Demo
{

	public static void main(String[] args)
	{
		StringBuffer sb = new StringBuffer("juan");

		/**
		 * replace(int start, int end, String str) 描述：用指定的String中的字元替換此序列的子字元串中的 String。
		 */
		// 第一個參數是替換的開始索引，第二個參數是替換的結束索引，第三個參數是替換的字元串
		sb.replace(1, 3, "kang");
		System.out.println(sb);

		/**
		 * reverse() 描述：導緻該字元序列被序列的相反代替。
		 */
		// 字元串反轉
		sb.reverse();
		System.out.println(sb);

		/**
		 * lastIndexOf(String str) 描述：傳回指定子字元串最右邊出現的字元串内的索引。
		 */
		// 獲得倒數第一次出現的字元串索引
		int lastIndex = sb.lastIndexOf("n");
		System.out.println(lastIndex);

		/**
		 * lastIndexOf(String str, int fromIndex) 描述：傳回指定子字元串最後一次出現的字元串中的索引。
		 */
		// 獲得從指定的索引開始向前數，找到倒數第一次出現的字元串出現的索引
		int lastIndex1 = sb.lastIndexOf("n", 5);
		System.out.println(lastIndex1);
	}
}
    Java系列（34）——可變字元串
java 可變字元串 字元串 構造器 數組
上一篇: String為什麼是不可變的？
下一篇: 為什麼 String 是不可變的？

繼續閱讀