一、String 类的基础概念

1.1 Java 中的字符串

Java 中的字符串，其实是一个类

• final 表示这个 String类 无法被继承
• String 类关联了 java.io.Serializable, Comparable, CharSequence 这三个接口
• String是引用类型，内部并不存储字符串本身
  • String 中的成员变量是 char value[ ] 和 hash
• 在Java中“”引起来的也是String类型对象

// 打印"hello"字符串(String对象)的长度
System.out.println("hello".length());

1.2 字符串的构造

public class Test {
    public static void main(String[] args) {
        String name = "hello";
        System.out.println(name);    //和下面那个相比，只是省略了一些标识符而已，意义一样

        String name1 = new String("world");
        System.out.println(name1);

        char[] ch = {'a','b','c','d'};
        String name2 = new String(ch);
        System.out.println(name2);

    }
}

二、String 类的进阶概念

由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串

2.1 求字符串的长度

Java 当中，没有说过字符串是以 ‘\0’ 结尾的

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

2.2 isEmpty()

public class Test {
    public static void main(String[] args) {
        String str4 = "";      //指向的对象中没有任何数据
        System.out.println(str4.isEmpty());    //如果里面没有数据就返回true，否则返回false
        String str5 = null;       //代表不指向任何对象
        System.out.println(str5.isEmpty());    //空指针异常
    }
}

2.3 字符串的比较

• 比较是否引用同一个对象
  注意：对于内置类型， == 比较的是变量中的值；对于引用类型==比较的是引用中的地址。
• boolean equals(Object anObject)方法：按照字典序比较
  字典序：字符大小的顺序
• int compareTo(String s) 方法: 按照字典序进行比较
  与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。具体比较方式：
  1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
  2. 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值
• int compareToIgnoreCase(String str)
  方法：与compareTo方式相同，但是忽略大小写比较

public class Test{
    public static void main(String[] args) {
        String str1 = new String("hello");
        String str2 = new String("hello");
        System.out.println(str1 == str2);
        System.out.println(str1.equals(str2));    //String 里面自己重写了equals方法
        System.out.println("=========");
        String str3 = "abc";
        String str4 = "abc";
        System.out.println(str3 == str4);

        System.out.println("====");
        String str5 = "abcd";     //直接赋值，且存放的值是一样的情况下，会被认为指向的是同一块空间
        String str6 = "abCd";

        System.out.println(str5.compareTo(str6));    
        System.out.println(str5.compareToIgnoreCase(str6));
    }
}

2.4 字符串的查找

2.5 字符串的转换

• 数值和字符串转换

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");
        int data2 = Integer.valueOf("1234");
        double data3 = Double.parseDouble("12.34");
        System.out.println(data1);
        System.out.println(data2);
        System.out.println(data3);

    }
}

• 大小写转换

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

• 字符串转数组

public class Test {
    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);
    }
}

• 格式化

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

2.6 字符串的替换

2.6 字符串的拆分

可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串

• 注意事项:
  • 字符"|“，”*“，”+“，”."都得加上转义字符，前面加上 “\” .
    • 理解：一个 ‘.’ 需要一个’\’ 进行转义，但是要识别一个’\'，需要两个\\
  • 而如果是 “\” ，那么就得写成 “\\” .

public class Test {
    public static void main(String[] args) {
        String str2 = "192\\168\\0\\0\\1";     //用两个\\表示一个\
        String[] ret2 = str2.split("\\\\");   //表示的是\\
        for (int i = 0; i < ret2.length; i++) {
            System.out.println(ret2[i]);
        }
    }
}

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

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

• 多次拆分

public class Test {
    public static void main(String[] args) {
        String str2 = "name=zhangsan&age=18";
        String[] ret2 = str2.split("&");
        for (int i = 0; i < ret2.length; i++) {
            String[] strings = ret2[i].split("=");
            for (String s : strings) {
                System.out.println(s);
            }
        }
    }
}

2.7 字符串的截取

2.8 去掉字符串的左右空白字符

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

public class Test {
    public static void main(String[] args) {
        String str = "   hell  oo  p   0   pppp";
        System.out.println(str.trim());
        System.out.println(str);    //是产生一个新的字符串，并没有在原字符串的基础上，进行修改
    }
}

2.9 StringBuilder和StringBuffer

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

• String和StringBuilder类的转换
  • String和StringBuilder类不能直接转换
  • 下面是依靠方法进行转换的方法

public class Main {
    public static void main(String[] args) {
        StringBuilder stringBuilder = new StringBuilder();     //String变为StringBuilder: 利用StringBuilder的构造方法或append()方法
        stringBuilder.append("12");
        System.out.println(stringBuilder);


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

三、字符串的不可修改性

3.1 原因

String是一种不可变对象. 字符串中的内容是不可改变，这个原因取决于String的内部定义

• String类中的字符实际保存在内部维护的value字符数组中
• final 表示不能修改这个引用的指向，且该类不能被继承
• String类并没有提供一个get()方法，或者set()方法，来访问这个字符串，所以这个内容是不可以被修改的

3.2 字符串的修改

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

• 总结：
  • 待在对String类进行修改时，效率是非常慢的，会创建多个对象，所以不建议在循环里进行拼接
  • 如果要修改，尽量使用StringBuilder和StringBuffer