Java String类

String类常用方法

字符串构造

public static void main1(String[] args) {
        //字符串构造
        String str = "aaaa";
        String str2 = new String("bbbb");

        char[] value = {'a','b','c','d'};
        String str3 = new String(value);

        System.out.println(str);
        System.out.println(str2);
        System.out.println(str3);
    }

输出：
aaaa
bbbb
abcd

注意：在Java1.8中String类是引用类型，并不储存字符串本身，而是char类型的数组，这点我们可以从源码中看出。

字符串的比较

用等号比较

对于内置类型，等号比较的是值的大小，而String是引用类型，比较的是引用的地址

public static void main(String[] args) {
        String s1 = "abcd";
        String s2 = new String("abcd");

        System.out.println(s1==s2);
    }

输出：false

因为s2重新new了个对象，s1和s2所指的对象不同

用equals()方法比较字符串是否相等

String类重写了父类的equals方法，源码如下：

public boolean equals(Object anObject) {
        if (this == anObject) {  //如果指向同一个对象，则返回true
            return true;
        }
        if (anObject instanceof String) {   //如果不是string类返回false
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {  //判断长度是否相等
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {       //逐个字符按照字典序比较
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

由源码可知，equals方法内比较的是字符串值的大小，返回的是布尔类型的值

用ComparaTo()方法比较字符串

与equals不同的是，comparaTo返回的是int类型的值。具体的比较方法：

1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
2. 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值

public static void main(String[] args) {
        String s1 = "a";
        String s2 = "A";
        String s3 = new String("a");

        System.out.println(s1.compareTo(s2));
        System.out.println(s1.compareTo(s3));
        System.out.println(s2.compareTo(s3));
    }

输出
32
0
-32

用compareToIgnoreCase()方法比较字符串

和comparaTo方法相似，只是忽略了字母大小

public static void main(String[] args) {
        String s1 = "A";
        String s2 = "a";

        System.out.println(s1.compareToIgnoreCase(s2));
    }

输出：0

字符串查找

具体方法和使用看如下代码

public static void main(String[] args) {

        //从字符串中获取字符
        String str = "abcdefabc";
        char ch = str.charAt(2);
                        //此处输入下标
        System.out.println(ch);

        //获取每一个字符
        for (int i = 0; i < str.length(); i++) {
            System.out.print(str.charAt(i));
        }
        System.out.println("");

        //从指定位置开始找第一个出现的字符
        System.out.println(str.indexOf('c',1));
        System.out.println(str.indexOf('c',5));

        //在主串中查找字串,返回首字母下标
        System.out.println(str.indexOf("abcd"));
        
        //从后往前找
        System.out.println(str.lastIndexOf("efa"));

    }

输出：
c
abcdefabc
2
8
0
4

字符串转化

数值与字符串转化，具体方法以及使用看代码

public static void main(String[] args) {
        
        //数字转字符串
        String str1 = String.valueOf(123);
        System.out.println(str1);

        //此处new了个对象传过去
        String str2 = String.valueOf(new person());
        System.out.println(str2);
        //源码接收的是object类，也就是说可以传任何类过去，输出的对象所指向的地址

        //字符串转为数字，也要满足是数字的要求
        String str3 = "123";
        int date = Integer.parseInt(str3);
        System.out.println(date);
        double date1 = Double.parseDouble(str3);
        System.out.println(date1);
        //用到包装类
        
        //字符串转数组
        String str = "abcdefg";
        char[] arr = str.toCharArray();
        //遍历数组
        for(char x:arr){
            System.out.print(x + " ");
        }
    }

输出：
123
person@1b6d3586

123
123.0
a b c d e f g

字符串替换

注意: 替换不修改当前字符串, 而是产生一个新的字符串.

public static void main(String[] args) {

        //字符串替换

        String str = "abcd";

        String ret = str.replace('a','p');
        System.out.println(ret);

        String ret1 = str.replace("ab","oo");
        System.out.println(ret1);

        String ret2 = str.replaceAll("ab","666");
        System.out.println(ret2);

        String ret3 = str.replaceFirst("ab","666");
        System.out.println(ret3);
    }

输出：
pbcd
oocd
666cd
666cd

字符串拆分

拆分为字符串数组

public static void main(String[] args) {

        String str = "Hello World!";
        String[] strs = str.split(" ");  //按空格拆分字符串
        System.out.println(strs[0]);
        System.out.println(strs[1]);
    }

输出
Hello
World!

按特殊符号拆分字符串

public static void main(String[] args) {

        //一些特殊符号的拆分
        String str = "2004.10.12";
        //erro : String[] strs = str.split(".");
        String[] strs = str.split("\\.");
        for(String s : strs) {
            System.out.println(s);
        }
    }

输出：
2004
10
12

截取字符

public static void main(String[] args) {

        //截取字符
        String str = "abcdefg";
        String  ret = str.substring(2); //开始截取的下标
        System.out.println(ret);

        //区间截取，左闭右开
        String ret2 = str.substring(2,5);
        System.out.println(ret2);
    }

输出：
cdefg
cde

其他方法

public static void main(String[] args) {

        //删除字符左右两边的空格
        String str = "     Hello World     ";
        System.out.println(str);
        String ret = str.trim();
        System.out.println(ret);

        //字符串转大写
        System.out.println(str.toUpperCase());

        //字符串转小写
        System.out.println(str.toLowerCase());
    }

String类对象的不可变性

String类对象的源码

通过源码我们可以看到，string类和内部的字符数组都是被final修饰的，由此可知：

1. String类被final修饰，表示该类不能继承。
2. value被final修饰，表明value自身的值不能改变，即不能引用其他字符数组，但是引用空间中的内容可以修改。

StringBuffer类 和 StringBuilder类

正是由于String类的不可变性，Java中产生了这两个类，方便字符串的修改，两者的大部分功能都是相同的

面试题：String、StringBuffer、StringBuilder的区别

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