Java——String类

一 、String类

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

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

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

public static void main(String[] args) {
    // s1和s2引用的是不同对象  s1和s3引用的是同一对象
    String s1 = new String("hello");
    String s2 = new String("world");
    String s3 = s1;
    
    System.out.println(s1.length());   // 获取字符串长度---输出5
    System.out.println(s1.isEmpty());  // 如果字符串长度为0，返回true，否则返回false

}

二、 常用方法

1. 字符串常量池

为了使程序的运行速度更快、更节省内存，
Java为8种基本数据类型和String类都提供了常量池。

Class文件常量池：
每个.Java源文件编译后生成.Class文件中会保存当前类中的字面常量以及符号信息。

运行时常量池：
在.Class文件被加载时，.Class文件中的常量池被加载到内存中称为运行时常量池，运行时常量池每个类都有一份。

字符串常量池在JVM中是StringTable类，
实际是一个固定大小的HashTable。

不同JDK版本下字符串常量池的位置以及默认大小是不同的：

2. 字符串构造

使用字符数组构造。
直接使用字符串常量进行赋值。
通过new创建String类对象。

public static void main(String[] args) {
	// 使用字符数组进行构造
	char[] array = {'h','e','l','l','o','b','i','t'};
	String s3 = new String(array);
	System.out.println(s1);
}

     //直接使用字符串常量进行赋值
 public static void main(String[] args) {
    String s1 = "hello";
    String s2 = "hello";
    System.out.println(s1 == s2);    // true

}

//通过new创建String类对象。
//只要是new的对象，都是唯一的。

  // 用 intern 方法，将创建的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对象中。

3. String对象的比较

• ==比较是否引用同一个对象。

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

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

}

• 按照字典序比较。
  boolean equals(Object anObject) 方法：
  String类重写了父类Object中equals方法，
  Object中equals默认按照==比较，
  String重写equals方法后，按照如下规则进行比较，
  比如：s1.equals(s2)

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

}

public boolean equals(Object anObject) {
   // 1. 先检测this 和 anObject 是否为同一个对象比较，如果是返回true
   if (this == anObject) {
       return true;
   }
   
   // 2. 检测anObject是否为String类型的对象，如果是继续比较，否则返回false
   if (anObject instanceof String) {
       // 将anObject向下转型为String类型对象
       String anotherString = (String)anObject;
       int n = value.length;
       
       // 3. this和anObject两个字符串的长度是否相同，是继续比较，否则返回false
       if (n == anotherString.value.length) {
           char v1[] = value;
           char v2[] = anotherString.value;
           int i = 0;
           
           // 4. 按照字典序，从前往后逐个字符进行比较
           while (n-- != 0) {
               if (v1[i] != v2[i])
                   return false;
               i++;
           }
           return true;
       }
   }
      return false;
}
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

}

• 按照字典序进行比较。

int compareTo(String s) 方法:

equals返回的是boolean类型，
而compareTo返回的是int类型。

具体比较方式：

先按照字典次序大小比较，
如果出现不等的字符，直接返回这两个字符的大小差值。

如果前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
}

• 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

}

4.字符串查找

public static void main(String[] args) {
    String s = "aaabbbcccaaabbbccc";
    System.out.println(s.charAt(3));                             // 'b'
    System.out.println(s.indexOf('c'));                          // 6
    System.out.println(s.indexOf('c', 10));                      // 15
    System.out.println(s.indexOf("bbb"));                        // 3
    System.out.println(s.indexOf("bbb", 10));                    // 12
    System.out.println(s.lastIndexOf('c'));                      // 17
    System.out.println(s.lastIndexOf('c', 10));                  // 8
    System.out.println(s.lastIndexOf("bbb"));                    // 12
}

5. 转化

• 数值和字符串转化

public static void main(String[] args) {
    String s = "aaabbbcccaaabbbccc";
    System.out.println(s.charAt(3));                             // 'b'
    System.out.println(s.indexOf('c'));                          // 6
    System.out.println(s.indexOf('c', 10));                      // 15
    System.out.println(s.indexOf("bbb"));                        // 3
    System.out.println(s.indexOf("bbb", 10));                    // 12
    System.out.println(s.lastIndexOf('c'));                      // 17
    System.out.println(s.lastIndexOf('c', 10));                  // 8
    System.out.println(s.lastIndexOf("bbb"));                    // 12
    System.out.println(s.lastIndexOf("bbb", 10));                // 3

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));

• 大小写转换

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

}

• 字符串转数组

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 static void main(String[] args) {
    String s = String.format("%d-%d-%d", 2019, 9,14);
    System.out.println(s);
}

6.字符串替换

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

String str = "helloworld" ; 
System.out.println(str.replaceAll("l", "_"));
System.out.println(str.replaceFirst("l", "_"));

7. 字符串拆分

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

有些特殊字符作为分割符可能无法正确切分, 需要加上转义.

字符"|“,”*“,”+“都得加上转义字符，前面加上 “\” .
如果是 “” ，那么就得写成 “\\” .
如果一个字符串中有多个分隔符，可以用”|"作为连字符.

String str = "hello world hello bit" ; 
String[] result = str.split(" ") ; // 按照空格拆分
for(String s: result) {
    System.out.println(s);
}

字符串的部分拆分
String str = "hello world hello bit" ; 
String[] result = str.split(" ",2) ; 
for(String s: result) {
    System.out.println(s);

}

拆分IP地址
String str = "192.168.1.1" ; 
String[] result = str.split("\\.") ; 
for(String s: result) {
    System.out.println(s);

}

多次拆分
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]);

}

8. 字符串截取

从一个完整的字符串之中截取出部分内容。

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

String str = "helloworld" ; 
System.out.println(str.substring(5));
System.out.println(str.substring(0, 5));

9. 其他方法

trim 会去掉字符串开头和结尾的空白字符(空格, 换行, 制表符等).
String str = "   hello  world   " ; 
System.out.println("["+str+"]");
System.out.println("["+str.trim()+"]");


大小写转换
String str = "   hello%$$%@#$%world 哈哈哈  " ; 
System.out.println(str.toUpperCase());
System.out.println(str.toLowerCase());

10. 字符串的不可变性

三 、 字符串修改

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

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

尽量避免对String的直接修改，
如果要修改建议尽量使用StringBuffer或者StringBuilder。

1. StringBuilder和StringBuffer

为了方便字符串的修改，
Java中又提供StringBuilder和StringBuffer类。
这两个类大部分功能是相同的。

String和StringBuilder最大的区别在于String的内容无法修改，
而StringBuilder的内容可以修改。

频繁修改字符串的情况考虑使用StringBuilder。

String和StringBuilder类不能直接转换。

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

StringBuilder变为String:
调用toString()方法。

 public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder("hello");
        StringBuilder sb2 = sb1;
        // 追加：即尾插-->字符、字符串、整形数字
          sb1.append(' ');                  // hello
        sb1.append("world");              // hello world
        sb1.append(123);                  // hello world123
        System.out.println(sb1);          // hello world123
        System.out.println(sb1 == sb2);   // true
        System.out.println(sb1.charAt(0));   // 获取0号位上的字符  h
        System.out.println(sb1.length());    // 获取字符串的有效长度14
        System.out.println(sb1.capacity());  // 获取底层数组的总大小
        sb1.setCharAt(0, 'H');     // 设置任意位置的字符 Hello world123
        sb1.insert(0, "Hello world!!!");         // Hello world!!!Hello world123
        System.out.println(sb1);
        System.out.println(sb1.indexOf("Hello"));          // 获取Hello第一次出现的位置
        System.out.println(sb1.lastIndexOf("hello"));  // 获取hello最后一次出现的位置
        sb1.deleteCharAt(0);                               // 删除首字符
        sb1.delete(0,5);                                   // 删除[0, 5)范围内的字符

        String str = sb1.substring(0, 5);                  // 截取[0, 5)区间中的字符以String的方式返回
        System.out.println(str);
        sb1.reverse();                      // 字符串逆转
        str = sb1.toString();               // 将StringBuffer以String的方式返回
        System.out.println(str);
    }

2. String、StringBuffer、StringBuilder的区别？

String的内容不可修改，
StringBuffer与StringBuilder的内容可以修改。

StringBuffer与StringBuilder大部分功能是相似的。

StringBuffer采用同步处理，属于线程安全操作；
而StringBuilder未采用同步处理，属于线程不安全操作。

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

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