String对象的声明和操作

java

String对象的声明和操作

• String字符是不可变的
• 类中每一个看来会修改String值得发布方法，其实都是创建了新的String对象（包含修改后的字符串内容）
• String的只读性带来效率优化可能
• 字符串字面值存储在字符串池中，String对象优先指向该字符池，避免发生成重复的字符串实例
• 系统对String的非修改处理效率很高，远远的超出了另外俩个字符串类的StringBuffer和StringBuilder（下边解释）

String对象的常用方法

        String str = "Made In China";
        String str1 = " bach";
        //返回字符串的长度
        System.out.println(str.length());//结果为：13
        //根据指定的索引值返回对应的单个字符
        System.out.println(str.charAt(0));//结果为：m
        //字符串的拼接
        System.out.println(str.concat(str1));//结果为： made in china  bach
        //是否包含指定的字符串
        System.out.println(str.contains("m"));//结果为：true
        //比较字符串的大小  根据ASCII比较
        System.out.println(str.compareTo(str1));//结果为：
        //指定子串在字符串中第一次出现的索引值位置，默认情况是单个字符进行编号
        //如果指定子串不存在则返回 -1
        System.out.println(str.indexOf("m"));//结果为：0
        //指定子串在字符串中最后一次出现的索引值位置，默认情况是单个字符进行编号
        //如果指定子串不存在则返回 -1
        System.out.println(str.lastIndexOf("a"));//结果为：12
        //根据制定子串对字符串进行分割
        String[] strs = str.split(" ");
        System.out.println(strs[0]);//made 
        System.out.println(strs[1]);//in
        System.out.println(strs[2]);//china
        //字符串截取1个参数的截取方式
        System.out.println(str.substring(3));//结果为：e in china
        //字符串截取2个参数的截取方式
        System.out.println(str.substring(2,6));//结果为：de i
        //将字符串中的字母全部转换成小写
        System.out.println(str.toLowerCase());//结果为：made in china
        //将字符串中的字母全部转换成大写
        System.out.println(str.toUpperCase());//结果为：    MADE IN CHINA
        //将字符串中的：“a”全部替换成A“”
        System.out.println(str.replace("a", "A"));//结果为：MAde In ChinA

String

• Java语言中的字符串值属于String类，虽然有其他方法表示字符串（如字符串数组），但Java一般使用String类作为字符串的标准格式，Java编辑器把字符串值作为String对象
• String对象一旦创建就不能改变，如果需要进行大量的字符串修改操作，应该使用StringBuffer/StringBuilder类或者字符数组，最终修改结果可以被转换成String

StringBuffer

• StringBuffer线程安全的可变字符序列(可变的字符数组)
• 一个类型与String的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容
• 每个字符缓冲区都有一定的容量，只有字符缓冲区所包含的字符序列的长度没有超出此容量，就无需分配新的内部缓冲数组
• 如果缓冲区溢出，则此容量自动增大

StringBuilder

• 从JDK5开始，为StringBuffer类补充了一个单线程使用的等价类，即StringBuilder
• 与StringBuffer相比，通常应该优先使用StringBuilder类，因为它支持所有相同操作，但由于它不执行同步，所以速度更快

StringBuffer操作

        StringBuilder sb = new StringBuilder();//默认的构造方法   默认长度为16
        //StringBuilder sb = new StringBuilder("abc");//添加容量   +3 长度为19
        //StringBuilder sb = new StringBuilder(100);//指定长度
        StringBuffer sb = new StringBuffer();
        sb.append(1);
        sb.append(true);
        sb.append("hello");//扩充 是容量满了之后 (n+1)*2
        //length()长度
        System.out.println(sb.length());
        //capacity()容器大小
        System.out.println(sb.capacity());
        //添加
        sb.append("worddddddddddddd");
        System.out.println(sb.capacity());
        //插入
        sb.insert(18, "6666666");
        System.out.println(sb);
        //取出指定下标的字符
        System.out.println(sb.charAt(2));
        System.out.println(sb);
        //删除【0，3）左避右开
        sb.delete(0, 3);
        System.out.println(sb);
        //出现的位置
        System.out.println(sb.indexOf("hello"));
        //替换
        System.out.println(sb.replace(6, 8, "**"));
        //翻转
        System.out.println(sb.reverse());
        //截取（返回类型不可变）
        System.out.println(sb.substring(3,8));
        //截取  （返回类型可变）
        System.out.println(sb.subSequence(3, 15));

模拟StringBuildetr

package com.stringbuilderdemo;
public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilderTest sbt = new StringBuilderTest("abcdefg");
        System.out.println(sbt.capacity());
        System.out.println(sbt.length());
        sbt.append("123");
        sbt.delete(3, 2);
        System.out.println(sbt);
        sbt.append("aaaaaaaaaa");
        sbt.append("aaaaaaaaaa");
        System.out.println(sbt.capacity());
    }
}
class StringBuilderTest {
    // 声明一个字符数组来保存数据
    private char[] test = null;
    // 无参的构造方法，初始容量为16
    public StringBuilderTest() {
        this.test = new char[16];
    }
    // int类型的构造方法，指定初始容量
    public StringBuilderTest(int capacity) {
        this.test = new char[capacity];
    }
    // String类型的构造方法，指定初始内容
    public StringBuilderTest(String str) {
        this.test = new char[str.length() + 16];
        // 把初始内容保存到test数组中
        this.append(str);
    }
    // 返回StringBuilder容量
    public int capacity() {
        return this.test.length;
    }
    // 返回StringBuilder内容长度
    public int length() {
        int length = 0;
        for (int i = 0; i < test.length; i++) {
            if (test[i] == 0) {
                break;
            }
            length = i + 1;
        }
        return length;
    }
    // 增加内容
    public void append(String str) {
        // 获得当前数组中的字符长度，确定拼接位置
        int length = this.length();
        // 确保长度能够容纳
        int length2 = str.length();
        while (true) {
            int capacity = this.capacity();
            if(capacity < (length + length2)){
            // 扩充数组容量
            dilatation();
            }else{
                break;
            }
        }
        // 把字符串放到数组中
        str.getChars(0, str.length(), this.test, length);
    }
    // 扩充数组容量
    public void dilatation() {
        // 获得原有的容量值
        int capacity = this.capacity();
        // 创建一个新的扩充后的数组
        //新数组的长度
        int newCapacity = (capacity + 1) * 2;
        char[] newTest = new char[newCapacity];
        // 将原有数组中的数据复制到新的数组中
        for (int i = 0; i < test.length; i++) {
            newTest[i] = test[i];
        }
        // 用新数组覆盖掉原有数组
        test = newTest;
    }
    // 获取指定位置的字符串
    public String get(int start, int count) {
        String str = new String(test, start, count);
        return str;
    }
    // 删除指定位置的字符串
    public void delete(int start, int count) {
        //获得数组内容长度
        int length = this.length();
        // 移动数据的起始点
        int startCopy = start + count;
        // 移动的数据的长度
        int countCopy = length- startCopy;
        for (int i = start; i < startCopy; i++) {
            test[i] = 0;
        }
        // 将后面的数据移动到前面进行拼接
        String str = new String(test, startCopy, countCopy);
        //将需要移动的数据在数组中清掉
        for(int i = startCopy;i<length;i++){
            test[i] = 0;
        }
        append(str);
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        String str = new String(test, 0, length());
        return str;
    }
}