String类

一、String类

1.1字符数组转换为字符串

char[] array = {'a'，'b'，'c'}；
String str = new String(array)；
System.out.println(str)；

1.2计算字符串长度

str.length();或者"hello".length()；

1.3判断字符串是不是空的

String str1 = "";
System.out.println(str1.isEmpty());

输出结果是true

String str2 = null;
System.out.println(str2.isEmpty());

运行时出现空指针异常

1.4比较字符串

String str1 = new String("abcd");
String str2 = new String("abcd");
System.out.println(str1 == str2);//输出结果是false，因为str1和str2存的是不同对象的引用，==两边比较的是地址，equals比较的是字符串具体的内容
System.out.println(str1.equals(str2));//输出结果是true，String类中重写了Object类中的equals方法，所以优先调用重写的equals方法

String str3 = ("abcd");
String str4 = ("abcd");
System.out.println(str3 = str4);//输出结果是true，字符串常量池，涉及哈希表的知识。堆中会有一个常量池(StringTable)，其实就是一个哈希表，用来提高存储效率，存储双引号引起来的字符串(存储字符串的常量值)，1.看常量池是否存在当前字符串，2.没有则存进去，3.有则获取这个字符串在常量池当中的地址

String str1 = "abcd";
String str2 = "abcdef";
System.out.println(str1.compareTo(str2));//输出结果是负数，String类实现了Comparable接口，重写了Comparable中的compareTo方法

String str1 = "abcd";
String str2 = "Abcd";
System.out.println(str1.compareToIgnoreCase(str2));//输出结果是0，忽略大小写进行比较

1.5查找字符串

String str1 = "abcdef";
char ch = str1.charAt(2);
System.out.println(ch);//输出结果是c

int index = str1.indexOf('c');
System.out.println(index);//输出结果是2，获取'c'首次出现位置的下标，indexOf函数实现了重载

int index = str1.indexOf("de");
System.out.println(index);//输出结果是3，获取"de"首次出现位置的下标

int index = str1.indexOf('c', 3);
System.out.println(index);//输出结果是-1，从下标为3的位置开始找'c'，找不到返回-1

int index = str1.indexOf("ab", 3);//从下标为3的位置开始找"ab"，找不到返回-1
        
String str2 = "ababcdabcdef";
int index2= str2.lastIndexOf('a');
System.out.println(index2);//输出结果是6，从后往前找，获取'a'首次出现位置的下标(而下标却是从前往后递增的)

String str2 = "ababcdabcdef";
int index2 = str2.lastIndexOf('a', 5);
System.out.println(index2);//输出结果是2，从下标为5的位置开始从后往前找，获取'a'首次出现位置的下标，下标为5的是'd'，从'd'开始从后往前找，找到'a'的下标为2

还有lastIndexOf(“ab”)和lastIndexOf(“ab”，5)，即把字符改为字符串

1.6字符串转换

String s1 ＝String.valueOf(1234);//将整型数据1234转换为字符串

String s1 ＝String.valueOf(12.34);//将浮点型数据12.34转换为字符串

String s1 ＝String.valueOf(true);//将布尔型数据转换为字符串

int data1＝Integer.parseInt("1234");//将字符串"1234"转换为整型数值1234

double data2＝Double.parseDouble("12.34");//将字符串"12.34"转换为浮点型数值12.34

String str1＝"heLLo";
String ret1＝str1.toUpperCase();
System.out.println(ret1);//输出HELLO，将字符串全部内容转换为大写
String ret2＝str1.toLowerCase();
System.out.println(ret2);//输出hello，将字符串全部内容转换为小写

String str＝"hello";
char[] array＝str.toCharArray();//将字符串转换为数组
for(int i＝0; i < array.length; i++){
System.out.print(array[i]+" ");//输出h e l l o
}

String s＝String.format("%d-%d-%d", 2019，9，14);
System.out.println(s);//输出2019-9-14，将数值格式化地转换为字符串

在Java中字符串是不可变的，如"heLLo"转换为"hello"这个转换不是在原来的字符串上面进行转换，而是生成了一个新的对象

1.7字符串替换

String str＝"ababababcd";
String ret＝str.replace("ab", "oo");//将字符串中的ab全部替换为oo，将字符串中的某个字符串全部替换为另外一个字符串，这个替换也不是在原来字符串上替换，而是生成了一个新的对象

String ret＝str.replace('a', 'z');//将字符串中的a全部替换为z，将字符串中的某个字符全部替换为另外一个字符

replace有replace(char oldChar，char newChar)和replace(CharSequence target，CharSequence replacement)，String类实现了CharSequence接口，所以可以传字符串作为replace的参数(即向上转型)

String ret＝str.replaceFirst("ab", "kk");//从头到尾查找遇到第一个ab就替换为kk

String ret＝str.replaceall("ab", "kk");//将所有的ab都替换为kk

1.8字符串分割

String str＝"hello word hello";
String[] string＝str.split(" ");//以空格字符为分隔符将字符串分割，因为字符串里有两个空格，所以分成了三段，分割后要用字符串类型的数组进行接收
for(int i＝0; i < string.length; i++){
System.out.println(string[i]);
}

打印结果：

String str = "hello word hello";
        String[] string = str.split(" ",2);//以空格字符为分隔符将字符串分割为两段
        for(int i = 0; i < string.length; i++){
            System.out.println(string[i]);
        }

打印结果为：

以I、*、.、+作为分隔符分割字符串时，I、*、.、+前面都要加上转义字符\\，如：

String[] string＝str.split("\\.");

String str＝"hello\\word\\hello";//输出结果是hello\word\hello
String[] string＝str.split("\\\\");//可以认为两个\\是一个\，\\\\就表示\\

分割后打印结果为：

String str = "name=hello&10";
String[] string＝str.split("&|=");//以两个分隔符分割，分割为三段

1.9字符串截取

String s = "abcdef";
String ret = s.substring(1);//从1下标开始截取字符串
System.out.println(ret);//输出结果为bcdef。如果从0下标开始截取，那么输出原字符串，如果从其它下标开始截取，那么输出的字符串是一个新创建的对象

String ret = s.substring(1, 4);//截取1到4下标的内容，因为Java左闭右开二百[1，4)，所以截取到的是bcd
String s＝" abc def ";
String ret＝s.trim();//去除字符串两边的空格

在Java中字符串是不可变的，如"heLLo"转换为"hello"这个转换不是在原来的字符串上面进行转换，而是生成了一个新的对象。原因在于在String类中，private final char value[]有private修饰(只能在String类当中使用)，final说明的是value的指向不能改变，但不能代表value指向的内容不能发生改变

final int[] array = {1，2，3};
array[0] = 10;//不会报错
array = new int[3];//会报错

1.10StringBuffer和StringBuilder

public static void main(String[] args) {
    long start = System.currentTimeMillis();
    String s = "";
    for(int i = 0; i < 10000; i++){
        s += i;
    }
    long end = System.currentTimeMillis();
    System.out.println(end - start);

    start = System.currentTimeMillis();
    StringBuffer s1 = new StringBuffer("");
    for(int i = 0; i < 10000; i++){
        s1.append(i);
    }
    end = System.currentTimeMillis();
    System.out.println(end - start);
    start = System.currentTimeMillis();

    StringBuilder s2 = new StringBuilder();
    for(int i = 0; i < 10000; i++){
        s2.append(i);
    }
    end = System.currentTimeMillis();
    System.out.println(end - start);
}

打印结果是：

因为String类型的内容不能被修改，所以在这里用+=修改String类型的字符串每次在后面追加修改都要创建新对象，会耗费时间和资源，相比之下修改StringBuffer和StringBuilder类型的字符串不会创建新对象，效率高，StringBuilder效率最高
StringBuffer和StringBuilder之间的方法很多是类似的，下面展示的是StringBuilder的一些方法：

class Test3 {
    public static void main(String[] args) {
        StringBuilder stringBuilder = new StringBuilder("abcd");//String变为StringBuilder，利用StringBuilder的构造方法或append方法
        stringBuilder.append(1);
        stringBuilder.append("abc").append(10.0);//在原对象后面追加字符串
        System.out.println(stringBuilder);

        stringBuilder.setCharAt(0, 'z');//将0下标位置的字符改为z
        System.out.println(stringBuilder);

        stringBuilder.insert(1, "AAAAAAAA");//在1下标位置插入字符串AAAAAAAA
        System.out.println(stringBuilder);

        stringBuilder.reverse();//没有创建新对象，在原对象上翻转字符串
        System.out.println(stringBuilder);

        String str = stringBuilder.toString();
        System.out.println(str);//StringBuilder变为String；调用toString方法
    }
}

输出结果为：