Java的String类常用方法 |StringBuilder和StringBuffer

String类常用方法

字符串查找

方法	功能
char charAt(int index)	返回index位置上字符，如果index为负数或者越界，抛出 IndexOutOfBoundsException异常
int indexOf(int ch)	返回ch第一次出现的位置，没有返回-1
int indexOf(int ch, int fromIndex)	从fromIndex位置开始找ch第一次出现的位置，没有返回-1
int indexOf(String str)	返回str第一次出现的位置，没有返回-1
int indexOf(String str, int fromIndex)	从fromIndex位置开始找str第一次出现的位置，没有返回-1
int lastIndexOf(int ch)	从后往前找，返回ch第一次出现的位置，没有返回-1
int lastIndexOf(int ch, int fromIndex)	从fromIndex位置开始找，从后往前找ch第一次出现的位置， 没有返回-1
int lastIndexOf(String str)	从后往前找，返回str第一次出现的位置，没有返回-1
int lastIndexOf(String str, int fromIndex)	从fromIndex位置开始找，从后往前找str第一次出现的位置， 没有返回-1

注意：上述方法都是实例方法。

转化

1. 数值和字符串转化

数字转字符串	String.valueOf
字符串转int	Integer.parseInt
字符串转double	Double.parseDouble

class Student {
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class Test {
    public static void main (String[] args) {
        // 数字转字符串
        String s1 = String.valueOf(1234);
        String s2 = String.valueOf(12.34);
        String s3 = String.valueOf(true);
        String s4 = String.valueOf(new Student("Hanmeimei", 18));
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
        System.out.println("=================================");
        // 字符串转数字
        // 注意：Integer、Double等是Java中的包装类型
        int data1 = Integer.parseInt("1234");
        double data2 = Double.parseDouble("12.34");
        System.out.println(data1);
        System.out.println(data2);
    }
}

2. 大小写转换

public static void main(String[] args) {
	String s1 = "hello";
	String s2 = "HELLO";
	// 小写转大写
	System.out.println(s1.toUpperCase());
	// 大写转小写
	System.out.println(s2.toLowerCase());
}

3. 字符串转数组

public static void main(String[] args) {
	String s = "hello";
	// 字符串转数组
	char[] ch = s.toCharArray();
	for (int i = 0; i < ch.length; i++) {
		System.out.print(ch[i]);
	}
	System.out.println();
	// 数组转字符串
	String s2 = new String(ch);
	System.out.println(s2);
}

4. 格式化

public static void main(String[] args) {
	String s = String.format("%d-%d-%d", 2019, 9,14);
	System.out.println(s);
}

字符串替换

方法	功能
String replaceAll(String regex, String replacement)	替换所有的指定内容
String replaceFirst(String regex, String replacement)	替换首个内容

public static void main(String[] args) {
        String str = "helloworld" ;
        System.out.println(str.replaceAll("l", "_"));
        System.out.println(str.replaceFirst("l", "_"));
    }

注意事项: 由于字符串是不可变对象, 不修改当前字符串, 而是产生一个新的字符串

字符串拆分

方法	功能
String[] split(String regex)	将字符串全部拆分
String[] split(String regex, int limit)	将字符串以指定的格式，拆分为limit组

public static void main(String[] args) {
        String str = "hello world hello bit" ;
        String[] result = str.split(" ") ; // 按照空格拆分
        for(String s: result) {
            System.out.println(s);
        }
        System.out.println("------------------");
        String[] result2 = str.split(" ",2) ;
        for(String s: result2) {
            System.out.println(s);
        }
    }

split根据给定的正则表达式的匹配来拆分此字符串

有些特殊字符( [ { / ^ - $ | } ]) ? * + . 作为分割符可能无法正确切分, 需要加上转义.

在其他语言中，\\ 表示：我想要在正则表达式中插入一个普通的（字面上的）反斜杠，请不要给它任何特殊的意义。
在 Java 中，\\ 表示：我要插入一个正则表达式的反斜线，所以其后的字符具有特殊的意义。
所以，在其他的语言中（如 Perl），一个反斜杠 \ 就足以具有转义的作用，而在 Java 的正则表达式中则需要有两个反斜杠才能被解析为其他语言中的转义作用。也可以简单的理解在 Java 的正则表达式中，\\ 代表其他语言中的 \，这也就是为什么表示一位数字的正则表达式是\\d，而表示一个普通的反斜杠是 \\。

public static void main(String[] args) {
        String str = "192.168.1.1" ;
        String[] result = str.split("\\.") ;
        for(String s: result) {
            System.out.println(s);
        }
    }

如果分隔符是 “\” ，那么就得写成 “\\\\”

public static void main(String[] args) {
        String str = "192\\168\\1\\1" ;
        System.out.println(str);
        String[] result = str.split("\\\\") ;
        for(String s: result) {
            System.out.println(s);
        }
    }

如果一个字符串中有多个分隔符，可以用"|"作为连字符

public static void main(String[] args) {
        String str = "name@zhangsan&age=18" ;
        String[] result = str.split("&|=|@") ;
        for (int i = 0; i < result.length; i++) {
            System.out.println(result[i]);
        }
    }

public static void main(String[] args) {
        String str = "name=zhangsan&age=18" ;
        String[] result = str.split("&") ;
        for (int i = 0; i < result.length; i++) {
            String[] temp = result[i].split("=") ;
            System.out.println(temp[0]+" = "+temp[1]);
        }
    }

字符串截取

方法	功能
String substring(int beginIndex)	从指定索引截取到结尾
String substring(int beginIndex, int endIndex)	截取部分内容

public static void main(String[] args) {
        String str = "helloworld" ;
        System.out.println(str.substring(5));
        System.out.println(str.substring(0, 5));

    }

注意事项:

1. 索引从0开始
2. 注意前闭后开区间的写法, substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标

其他操作方法

方法	功能
String trim()	去掉字符串中的左右空格,保留中间空格

public static void main(String[] args) {
        String str = " hello world " ;
        System.out.println("["+str+"]");
        System.out.println("["+str.trim()+"]");
    }

trim 会去掉字符串开头和结尾的空白字符(空格, 换行, 制表符等)

字符串的不可变性

String是一种不可变对象. 字符串不可被修改，是因为：

1. String类在设计时就是不可改变的，String类实现描述中已经说明了

   以下来自JDK1.8中String类的部分实现：
   
   String类中的字符实际保存在内部维护的value字符数组中，该图还可以看出：

• String类被final修饰，表明该类不能被继承
• value被final修饰，表明value只能引用原来对象，即不能引用其它字符数组，但是其引用空间中的内容可以修改。

public static void main(String[] args) {
	final int array[] = {1,2,3,4,5};
	array[0] = 100;
	System.out.println(Arrays.toString(array));
	// array = new int[]{4,5,6}; 
	// 编译报错：Error:(19, 9) java: 无法为最终变量array分配值
}

2. 所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象

字符串不可变,不是因为String类自身，或者其内部value被final修饰而不能被修改。
是因为String类不能被继承，也没有提供方法拿到value,value还是被private修饰的,也不能引用其他对象,拿不到value,就没办法对value进行修改

为什么 String 要设计成不可变的?(不可变对象的好处是什么?)

1. 方便实现字符串对象池. 如果 String 可变, 那么对象池就需要考虑写时拷贝的问题了.
2. 不可变对象是线程安全的.
3. 不可变对象更方便缓存 hash code, 作为 key 时可以更高效的保存到 HashMap 中.

StringBuilder和StringBuffer

尽量避免直接对String类型对象进行修改，因为String类是不能修改的，所有的修改都会创建新对象，效率非常低下。

有如下代码:

public class Test {
    public static void main(String[] args) {
        String str = "hello";
        str += " world";
        System.out.println(str);
    }
}

运行一下,产生字节码文件,找到字节码文件所在位置(idea是在out目录下),在上方输入cmd回车

在cmd界面输入命令javap -c 文件名查看反汇编代码

str += " world";在反汇编中
1.new 一个StringBuilder对象
2. “< init>”: ( )V是调用构造方法的意思
3. 之后是调用两个StringBuilder的append方法
4. 最后用toString方法将StringBuilder转为String

原代码也就可以改成

public class Test {
    public static void main(String[] args) {
        String str = "hello";
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(str);
        stringBuilder.append(" world");
        str = stringBuilder.toString();
        System.out.println(str);
    }
}

还可以简单测一下效率差距:

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 sbf = new StringBuffer("");
        for(int i = 0; i < 10000; ++i){
            sbf.append(i);
        }
        end = System.currentTimeMillis();
        System.out.println(end - start);
        start = System.currentTimeMillis();
        StringBuilder sbd = new StringBuilder();
        for(int i = 0; i < 10000; ++i){
            sbd.append(i);
        }
        end = System.currentTimeMillis();
        System.out.println(end - start);
    }

可以看出在对String类进行修改时，效率是非常慢的，因此：尽量避免对String的直接修改，如果要修改的话建议尽量使用StringBuffer或者StringBuilder。

StringBuilder的介绍

由于String的不可更改特性，为了方便字符串的修改，Java中又提供StringBuilder和StringBuffer类。这两个类大部分功能是相同的，这里介绍 StringBuilder常用的一些方法

方法	说明
StringBuffer append(参数)	在尾部追加，相当于String的+=，参数可以是boolean、char、char[]、double、float、int、long、String、StringBuffer等类型的变量
char charAt(int index)	获取index位置的字符
int length()	获取字符串的长度
int capacity()	获取底层保存字符串空间总的大小
void ensureCapacity(int mininmumCapacity)	扩容
void setCharAt(int index,char ch)	将index位置的字符设置为ch
int indexOf(String str)	返回str第一次出现的位置
int indexOf(String str, int fromIndex)	从fromIndex位置开始查找str第一次出现的位置
int lastIndexOf(String str)	返回最后一次出现str的位置
int lastIndexOf(String str, int fromIndex)	从fromIndex位置开始找str最后一次出现的位置
StringBuffer insert(int offset, String str)	在offset位置插入：八种基类类型 & String类型 & Object类型数据
StringBuffer deleteCharAt(int index)	删除index位置字符
StringBuffer delete(int start, int end)	删除[start, end)区间内的字符
StringBuffer replace(int start, int end, String str)	将[start, end)位置的字符替换为str
String substring(int start)	从start开始一直到末尾的字符以String的方式返回
String substring(int start，int end)	将[start, end)范围内的字符以String的方式返回
StringBuffer reverse()	反转字符串
String toString()	将所有字符按照String的方式返回

String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可以修改。频繁修改字符串的情况考虑使用StringBuilder。
注意：String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则:

• String变为StringBuilder: 利用StringBuilder的构造方法或append()方法
• StringBuilder变为String: 调用toString()方法。

面试题

1. String、StringBuffer、StringBuilder的区别

• String的内容不可修改，StringBuffer与StringBuilder的内容可以修改.
• StringBuffer与StringBuilder大部分功能是相似的
• StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作

以append方法为例

在多线程的情况下,不能同时调用synchronized修饰的方法

2. 以下总共创建了多少个String对象【前提不考虑常量池之前是否存在】

String str = new String("ab"); // 会创建多少个对象
String str = new String("a") + new String("b"); // 会创建多少个对象