StringBuffer类

线程安全,可变的字符序列。字符串缓冲区就像一个String,但可以修改。在任何时间点,它包含一些特定的字符序列,但可以通过某些方法调用来更改序列的长度和内容。

字符串缓冲区可以安全地被多个线程使用。 这些方法在必要时进行同步,以便任何特定实例上的所有操作都按照与所涉及的各个线程所执行的方法调用顺序一致的顺序发生。

StringBuffer的主要StringBufferappendinsert方法,它们被重载以便接受任何类型的数据。 每个都有效地将给定的数据转换为字符串,然后将该字符串的字符附加或插入到字符串缓冲区。 append方法总是在缓冲区的末尾添加这些字符; insert方法将insert添加到指定点。

储存

append()

将指定的类型附加到此存储到StringBuffer中。

append方法支持的类型有“boolean,String,char,char[],CharSequnce,double,float,int,long,Object”

public StringBuffer append(类型 type)

用法:

public class StringBufferDemo {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.append("Hello");
        sb.append(' ');
        sb.append("Java");
        sb.append(123);
        sb.append(123.00);
        sb.append(true);
    }
}

insert()

将类型插入到此字符序列中。

“`java
public StringBuffer insert(int offset, 类型 type)
“`

参数:

  • offset 索引位置

用法:

public class StringBufferDemo {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.insert(0, true);
        sb.insert(1, "Hello");
        sb.insert(4, 123456);
        sb.insert(5, 12.22);
        sb.insert(8, new Object());
        sb.insert(2, new char[]{'0', 'a'});
    }
}

删除

delete()

删除此序列的子字符串中的字符。 子串开始于指定start并延伸到字符索引end - 1 ,或如果没有这样的字符存在的序列的结束。 如果start等于end ,则不作任何更改。

public StringBuffer delete(int start, int end)

参数:

  • start 开始索引
  • end 结束索引

用法:

public class StringBufferDemo {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.insert(0, true);
        sb.insert(1, "Hello");
        sb.insert(4, 123);
        sb.insert(5, 12.3);
        // sb.toString() = tHel112.323lorue
        System.out.println("sb.toString() = " + sb.toString());

        sb.delete(0, 5);
        // sb.toString() = 12.323lorue
        System.out.println("sb.toString() = " + sb.toString());
    }
}

deleteCharAt()

删除char在这个序列中的指定位置。 该序列缩短了一个char

“`java
public StringBuffer deleteCharAt(int index)
“`

参数:

  • index 要删除的索引char

用法:

public class StringBufferDemo {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.insert(0, true);
        sb.insert(1, "Hello");
        sb.insert(4, 123);
        sb.insert(5, 12.3);
        // sb.toString() = tHel112.323lorue
        System.out.println("sb.toString() = " + sb.toString());

        sb.deleteCharAt(0);
        // sb.toString() = Hel112.323lorue
        System.out.println("sb.toString() = " + sb.toString());
    }
}

获取

charAt()

返回char在指定索引在这个序列值。第一个char值为索引0 ,下一个索引为1 ,依此类推,就像数组索引一样。

索引参数必须大于或等于0 ,并小于此序列的长度。

如果char由索引指定的值是surrogate,则返回所述替代值。

public char charAt(int index)

参数:

  • index 所需指数char指。

用法:

public class StringBufferDemo {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.insert(0, "Hello");
        sb.insert(1, "World");
        sb.insert(2,"Java");
        // sb.toString() = HWJavaorldello
        System.out.println("sb.toString() = " + sb.toString());
        // sb.charAt(2) = J
        System.out.println("sb.charAt(2) = " + sb.charAt(2));
    }
}

indexOf()

返回指定子字符串第一次出现的字符串内的索引。

“`java
public int indexOf(String str)
“`

返回指定子串的第一次出现的字符串中的索引,从指定的索引开始。

“`java
public int indexOf(String str, int fromIndex)
“`

参数:

  • str 要搜索的子字符串。
  • fromIndex 从中开始搜索索引。

用法:

public class StringBufferDemo {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.insert(0, "Hello");
        sb.insert(1, "World");
        sb.insert(2, "Java");
        // sb.toString() = HWJavaorldello
        System.out.println("sb.toString() = " + sb.toString());
        // sb.indexOf("j") = -1
        System.out.println("sb.indexOf(\"j\") = " + sb.indexOf("j"));
        // sb.indexOf("o") = 6
        System.out.println("sb.indexOf(\"o\") = " + sb.indexOf("o"));
        // sb.indexOf("o") = 6
        System.out.println("sb.indexOf(\"o\",7) = " + sb.indexOf("o", 7));
    }
}

lastIndexOf()

返回指定子字符串最右边出现的字符串内的索引。 最右边的空字符串“”被认为发生在索引值this.length()

“`java
public int lastIndexOf(String str)
“`

返回指定子字符串最后一次出现的字符串中的索引。

“`java
public int lastIndexOf(String str, int fromIndex)
“`

参数:

  • str 要搜索的子字符串。
  • fromIndex 从中开始搜索索引。

用法:

public class StringBufferDemo {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.insert(0, "Hello");
        sb.insert(1, "World");
        sb.insert(2, "Java");
        // sb.toString() = HWJavaorldello
        System.out.println("sb.toString() = " + sb.toString());

        // sb.lastIndexOf("j") = -1
        System.out.println("sb.lastIndexOf(\"j\") = " + sb.lastIndexOf("j"));
        // sb.lastIndexOf("o") = 13
        System.out.println("sb.lastIndexOf(\"o\") = " + sb.lastIndexOf("o"));
        // sb.lastIndexOf("l",10) = 8
        System.out.println("sb.lastIndexOf(\"l\",10) = " + sb.lastIndexOf("l", 10));
    }
}

length()

返回长度(字符数)。

public int length()

用法:

public class StringBufferDemo {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.insert(0, "Hello");
        sb.insert(1, "World");
        sb.insert(2, "Java");
        // sb.toString() = HWJavaorldello
        System.out.println("sb.toString() = " + sb.toString());
        // sb.length() = 14
        System.out.println("sb.length() = " + sb.length());
    }
}

substring()

返回一个新字符串,该字符串包含此字符序列中当前包含的子序列字符。子字符串从指定的索引开始,一直扩展到序列的末尾。

public String substring(int start)

返回一个新字符串,该字符串包含该序列中当前包含的字符的子序列。子字符串从指定的起始点开始,并扩展到索引结束- 1处的字符。

public String substring(int start, int end)

参数:

  • start 开始索引
  • end 结束索引

用法:

public class StringBufferDemo {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.insert(0, "Hello");
        sb.insert(1, "World");
        sb.insert(2, "Java");
        // sb.toString() = HWJavaorldello
        System.out.println("sb.toString() = " + sb.toString());
        // sb.substring(5) = aorldello
        System.out.println("sb.substring(5) = " + sb.substring(5));
        // sb.substring(2,10) = Javaorld
        System.out.println("sb.substring(2,10) = " + sb.substring(2, 10));
    }
}

修改

replace()

将此序列的子字符串中的字符替换为指定字符串中的字符。子字符串从指定的开始处开始,并扩展到索引结束- 1处的字符,如果不存在这样的字符,则扩展到序列的结束处。首先删除子字符串中的字符,然后在开始时插入指定的字符串。(如果需要,此序列将被加长以适应指定的字符串。)

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.insert(0, "Hello");
        sb.insert(1, "World");
        sb.insert(2, "Java");
        // sb.toString() = HWJavaorldello
        System.out.println("sb.toString() = " + sb.toString());
        // sb.replace(0, sb.length(), "Hello World Java") = Hello World Java
        System.out.println("sb.replace(0, sb.length(), \"Hello World Java\") = " + sb.replace(0, sb.length(), "Hello World Java"));
    }
}

setCharAt()

在指定索引处的字符被设置为ch。这个序列被改变来表示一个新的字符序列,它与旧的字符序列完全相同,除了它包含了字符ch的位置索引。
索引参数必须大于或等于0,并且小于这个序列的长度。

public void setCharAt(int index, char ch)

参数:

  • index 要修改的字符的索引。

  • ch 新字符。

    用法:

public class StringBufferDemo {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.insert(0, "Hello");
        sb.insert(1, "World");
        sb.insert(2, "Java");
        // sb.toString() = HWJavaorldello
        System.out.println("sb.toString() = " + sb.toString());

        sb.setCharAt(2, 'j');
        // sb.toString() = HWjavaorldello
        System.out.println("sb.toString() = " + sb.toString());
    }
}

反转

reverse()

使该字符序列替换为序列的反面。如果序列中包含任何代理项对,则将它们作为单个字符处理,以便进行反向操作。因此,高低代位的顺序永远不会颠倒。设n为该字符序列在执行相反方法之前的字符长度(而不是字符值中的长度)。那么新字符序列中索引k处的字符等于旧字符序列中索引n-k-1处的字符。

public StringBuffer reverse()

用法:

public class StringBufferDemo {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer();
        sb.insert(0, "Hello");
        sb.insert(1, "World");
        sb.insert(2, "Java");
        // sb.toString() = HWJavaorldello
        System.out.println("sb.toString() = " + sb.toString());

        sb.reverse();
        // sb.toString() = olledlroavaJWH
        System.out.println("sb.toString() = " + sb.toString());
    }
}

将缓冲区中指定数据存储到指定字符数组中。

getChars()

方法将字符从字符串复制到目标字符数组。

public void getChars(int srcBegin, int srcEnd, char[] dst,  int dstBegin)

参数:

  • srcBegin — 字符串中要复制的第一个字符的索引。
  • srcEnd — 字符串中要复制的最后一个字符之后的索引。
  • dst — 目标数组。
  • dstBegin — 目标数组中的起始偏移量。

用法:

public class StringBufferDemo {
    public static void main(String[] args) {
        char[] str = new char[5];
        try {
            "Hello World".getChars(1, 6, str,0);
            for (char c : str) {
                System.out.println(c);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

结果:

c = e
c = l
c = l
c = o
c =  

StringBuilder类

可变的字符序列。
这个类提供了一个与StringBuffer兼容的API但不保证同步。
这个类设计用于在单个线程使用字符串缓冲区的地方(通常情况下)作为StringBuffer的临时替换。
如果可能,建议优先使用该类而不是StringBuffer,因为在大多数实现中它会更快。

StringBuffer和StringBuilder区别

  • StringBuffer线程同步。
  • StringBuilder线程不同步。

以后开发,建议使用StringBuilder

升级StringBuilder三个因素:

  • 提高效率。
  • 简化书写。
  • 提高安全性。

基本数据类型

基本数据类型引用数据类型
byteByte
shortshort
intInteger
longLong
booleanBoolean
floatFloat
doubleDouble
charCharacter

用法:

public class Test {
    public static void main(String[] args) {
        // 获取整数最大值
        // Integer.MAX_VALUE = 2147483647
        System.out.println("Integer.MAX_VALUE = " + Integer.MAX_VALUE);
    }
}

基本数据类型对象包装类的最常见作用。

就是用于基础数据类型和字符串类型之间转化。

练习:

  • 基本数据类型转成字符串。
    • 基本数据类型+”“
    • 基本数据类型.toString(基本数据类型值);
    • 如:Integer.toString(34); // 将34整数转成成”34“
  • 字符串转成基本数据类型。

  • 语法:类型.parse类型(“字符串”);
    • 将一个字符串转成整数。
public class Test {
    public static void main(String[] args) {
        // Integer.parseInt("123") = 123
        System.out.println("Integer.parseInt(\"123\") = " + Integer.parseInt("123"));
    }
}

基本数据类型对象包装类新特性

  • JDK1.5以后,简化了定义方式。
    • Integer x = new Integer(4);可以直接写成
    • Integer x = 4;//自动装箱。
    • x = x + 5;//自动拆箱。通过intValue方法。
  • 需要注意:
  • 在使用时,Integer x = null;上面的代码就会出现NullPointerException