【Java】String类

1. 什么是String类

首先，在c语言里面是没有字符串类型的。但是在C语言中表示字符串只能使用字符数组或者字符指针，可以使用标准库提供的字符串系列函数完成大部分操作，但是这种将数据和操作数据方法分离开的方式不符合面相对象的思想，而字符串应用又非常广泛，因此Java语言专门提供了String类。

       char *p = "Hello World"
       //          //这是字符串 

2. String的用法

2.1 字符串的构造

//String类提供的构造方式非常多，常用的就以下三种：

    public static void main(String[] args) {
        //这是第一种
        String str1 = "Hello World";
        //这是第二种
        String str2 = new String("Hello World");
        //这是第三种
        char[] array1 = {'H','e','l','l','o',' ','W','o','r','l','d'};

        String str3 = new String(array1);
        System.out.println(str3);

        System.out.println(Arrays.toString(array1));

        System.out.println(str1);

        System.out.println(str2);

    }

String的更多用法

1. String是引用类型，内部并不存储字符串本身，在String类的实现源码中，String类实例变量如下：

 2. 在Java中“”引起来的也是String类型对象。

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

2.2 String对象的比较

1. ==比较是否引用同一个对象

    public static void main(String[] args) {
            int a = 10;
            int b = 20;
            int c = 10;
            // 对于基本类型变量，==比较两个变量中存储的值是否相同
            System.out.println(a == b); // false
            System.out.println(a == c); // true
            // 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
            String s1 = new String("hello");
            String s2 = new String("hello");
            String s3 = new String("world");
            String s4 = s1;
            System.out.println(s1 == s2); // false
            System.out.println(s2 == s3); // false
            System.out.println(s1 == s4); // true
    }
      //注意：对于内置类型，==比较的是变量中的值；对于引用类型==比较的是引用中的地址。

注意：对于内置类型，==比较的是变量中的值；对于引用类型==比较的是引用中的地址。

2. boolean equals(Object anObject) 方法：按照字典序比较.

public static void main(String[] args) {
  String s1 = new String("hello");
  String s2 = new String("hello");
  String s3 = new String("Hello");
  // s1、s2、s3引用的是三个不同对象，因此==比较结果全部为false
  System.out.println(s1 == s2);    // false
  System.out.println(s1 == s3);    // false
  // equals比较：String对象中的逐个字符
  // 虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true
  // s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false
  System.out.println(s1.equals(s2));  // true
  System.out.println(s1.equals(s3));  // false
}

3. int compareTo(String s) 方法: 按照字典序进行比较

compareTo返回的是int类型。具体比较方式：
1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
2. 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值

public static void main(String[] args) {
  String s1 = new String("abc");
  String s2 = new String("ac");
  String s3 = new String("abc");
  String s4 = new String("abcdef");
  System.out.println(s1.compareTo(s2));  
  // 不同输出字符差值-1
  System.out.println(s1.compareTo(s3));  
  // 相同输出 0
  System.out.println(s1.compareTo(s4));  
  // 前k个字符完全相同，输出长度差值 -3
}

4. int compareToIgnoreCase(String str) 方法：与compareTo方式相同，但是忽略大小写比。

public static void main(String[] args) {
  String s1 = new String("abc");
  String s2 = new String("ac");
  String s3 = new String("ABc");
  String s4 = new String("abcdef");
  System.out.println(s1.compareToIgnoreCase(s2));  
  // 不同输出字符差值-1
  System.out.println(s1.compareToIgnoreCase(s3));  
  // 相同输出 0
  System.out.println(s1.compareToIgnoreCase(s4));  
  // 前k个字符完全相同，输出长度差值 -3
}

2.3 字符串查找

    public static void main(String[] args) {
        String str = "absdefgabcdefg";
        System.out.println(str.charAt(3));//d
        System.out.println(str.indexOf('f'));//5
        System.out.println(str.indexOf('d',7));//10
        System.out.println(str.indexOf("fg"));//5
        System.out.println(str.indexOf("bc",5));//8
        System.out.println(str.lastIndexOf("cd"));//9
        System.out.println(str.lastIndexOf("cd",5));//-1
        System.out.println(str.lastIndexOf('d'));//10
        System.out.println(str.lastIndexOf('d',5));//3
    }

2.4 转化

1. 数值和字符串转化

class Student {
    public String name;
    public int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class TestDemo {

    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("zhangsan", 18));
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);

        // 字符串转数字
        // 注意：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 str = "adsfasfdsf";
        char[] ch = str.toCharArray();
        System.out.println(Arrays.toString(ch));

        String str2 = new String(ch);
        System.out.println(str2);
    }

4. 格式化

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

2.5 字符串替换

2.6 字符串拆分 

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

注意事项:
1. 字符"|","*","+"都得加上转义字符，前面加上 "\\" .
2. 而如果是 "\" ，那么就得写成 "\\\\" .
3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符.

2.7 字符串截取

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

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

2.8 其他操作方法

 2.9 字符串常量池

由于不同JDK版本对字符串常量池的处理方式不同，此处在Java8 HotSpot上分析

1. 直接使用字符串常量进行赋值

public static void main(String[] args) {
  String s1 = "hello";
  String s2 = "hello";
  System.out.println(s1 == s2);
  //结果是： true
}

在Java程序中，类似于：1， 2， 3，3.14，“hello”等字面类型的常量经常频繁使用，为了使程序的运行速度更快、更节省内存，Java为8种基本数据类型和String类都提供了常量池。

为了节省存储空间以及程序的运行效率，Java中引入了：
1. Class文件常量池：每个.Java源文件编译后生成.Class文件中会保存当前类中的字面常量以及符号信息。
2. 运行时常量池：在.Class文件被加载时，.Class文件中的常量池被加载到内存中称为运行时常量池，运行时常量池每个类都有一份。
3. 字符串常量池。

2.9.2 字符串常量池

字符串常量池在JVM中是StringTable类，实际是一个固定大小的HashTable，不同JDK版本下字符串常量池的位置以及默认大小是不同的：

JDK版本 字符串常量池位置 大小设置
Java6 (方法区)永久代 固定大小：1009
Java7 堆中 可设置，没有大小限制，默认大小：60013
Java8 堆中 可设置，有范围限制，最小是1009

注意：
1. 在JVM中字符串常量池只有一份，是全局共享的;
2. 刚开始字符串常量池是空的，随着程序不断运行，字符串常量池中元素会越来越多;
3. 当类加载时，字节码文件中的常量池也被加载到JVM中，称为运行时常量池，同时会将其中的字符串常量保存在字符串常量池中;
4. 字符创常量池中的内容：一部分来自运行时常量池，一部分来自程序动态添加.

2.9.3 再谈String对象创建

1. 直接使用字符串常量进行赋值

public static void main(String[] args) {
  String s1 = "hello";
  String s2 = "hello";
  System.out.println(s1 == s2);   // true
}

2. 通过new创建String类对象

结论：只要是new的对象，都是唯一的。
通过上面例子可以看出：使用常量串创建String类型对象的效率更高，而且更节省空间。用户也可以将创建的字符串对象通过 intern 方式添加进字符串常量池中。

intern 是一个native方法(Native方法指：底层使用C++实现的，看不到其实现的源代码)，该方法的作用是手动将创建的String对象添加到常量池中。

public static void main(String[] args) {
  char[] ch = new char[]{'a', 'b', 'c'};
  String s1 = new String(ch);   // s1对象并不在常量池中
  //s1.intern();         // s1.intern()；调用之后，会将s1对象的引用放入到常量池中
  String s2 = "abc";     // "abc" 在常量池中存在了，s2创建时直接用常量池中"abc"的引用
  System.out.println(s1 == s2);
}
// 输出false
// 将上述方法打开之后，就会输出true

 面试题：请解释String类中两种对象实例化的区别

JDK1.8中
1. String str = "hello"
只会开辟一块堆内存空间，保存在字符串常量池中，然后str共享常量池中的String对象。
2. String str = new String("hello")
会开辟两块堆内存空间，字符串"hello"保存在字符串常量池中，然后用常量池中的String对象给新开辟的String对象赋值。
3. String str = new String(new char[]{'h', 'e', 'l', 'l', 'o'})
现在堆上创建一个String对象，然后利用copyof将重新开辟数组空间，将参数字符串数组中内容拷贝到String对象中。

 2.10 字符串的不可变性

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

1. String类在设计时就是不可改变的；

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

2.11 字符串修改

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

public static void main(String[] args) {
  String s = "hello";
  s += " world";
  System.out.println(s);  // 输出：hello world
}

像这样，在程序运行是会发生很对的临时对象，效率低下。

我们可以下这样一个代码。

public static void main(String[] args) {
  long start = System.currentTimeMillis();
  String s = "";
  for(int i = 0; i < 100000; ++i){
    s += i;
 }
  long end = System.currentTimeMillis();
  System.out.println(end - start);
  //StringBuffer
  start = System.currentTimeMillis();
  StringBuffer sbf = new ("");
  for(int i = 0; i < 100000; ++i){
    sbf.append(i);
 }
  end = System.currentTimeMillis();
  System.out.println(end - start);
  //StringBuilder
  start = System.currentTimeMillis();
  StringBuilder sbd = new StringBuilder();
  for(int i = 0; i < 100000; ++i){
    sbd.append(i);
 }
  end = System.currentTimeMillis();
  System.out.println(end - start);
}

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

那么我们接下来就看看StringBuffer或者StringBuilder。

3. StringBuilder和StringBuffer

3.1 StringBuilder的介绍

我们可以在这个链接下学习StringBuilder的一些方法。

Java Platform SE 8https://docs.oracle.com/javase/8/docs/api/总结：

String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可以
修改。频繁修改字符串的情况考虑使用StringBuilder。

注意：

String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则:
String变为StringBuilder: 利用StringBuilder的构造方法或append()方法
StringBuilder变为String: 调用toString()方法

3.2 面试题

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

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

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


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