String

构造String

常用的三种方法

public class Main {

    public static void main(String[] args) {
        //使用常量直接进行赋值
        String s1 = "hello";
        System.out.println(s1);
        //直接new一个对象
        String s2 = new String("hello");
        System.out.println(s2);
        //使用字符数组进行构造
        char[] array = {'h','e','l','l','o'};
        String s3 = new String(array);
        System.out.println(s3);
    }
}
        //输出结果
        //hello
        //hello
        //hello

注：

String 是引用类型，内部不会存储字符串实际存储在char类型的数组中。

引号” “引起来的也是String类型对象

        System.out.println("hello".length());

String的比较

1.==比较是否引用同一个对象对于基本类型变量==比较的是变量的值，对于引用类型比较的是地址。

        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) 方法：按照字典序比较(字符大小的顺序)

String类重写了父类Object中equals方法，equals方法默认按照==比较，String重写equals方法。

        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) 方法: 按照字典序进行比较

与equals方法不同的是，equals方法返回的是boolean类型，而compareTo方法返回的是int类型。具体比较方式：

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

2. 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值

        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方式相同，但是忽略大小写比较

        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

字符串的转化

1.大小写转化

        String s1 = "hello";
        String s2 = "HELLO";
        // 小写转大写
        System.out.println(s1.toUpperCase());//HELLO
        // 大写转小写
        System.out.println(s2.toLowerCase());//hello

2.字符串转数组

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

字符串的不可变性

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

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

     String类中的字符实际保存在内部维护的value字符数组中。

      String类被final修饰，表明该类不能被继承

       value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中 的内容可以修改。

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

     字符串不可变是因为其内部保存字符的数组被final修饰了？？？错误

    final修饰类表明该类不想被继承，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内 容是可以修改的。不可变性是因为其数组被private修饰，外部无法改变。

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

1. 方便实现字符串对象池. 如果 String 可变, 那么对象池就需要考虑写时拷贝的问题了.

2. 不可变对象是线程安全的.

3. 不可变对象更方便缓存 hash code, 作为 key 时可以更高效的保存到 HashMap

StringBuilder和StringBuffer

对String类进行修改时，效率是非常慢的（因为其内部要创建许多临时变量） 使用StringBuffer或者StringBuilder是快的。

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

                上述代码结果

hello world123
true
h
14
21
Hello world!!!Hello world123
0
-1
world
321dlrow olleH!!!dlrow

从上述代码可以看出

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

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

String、StringBuffer、StringBuilder的区别

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

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

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

第一个代码，会创建一个对象。因为使用 new 关键字明确创建了一个字符串对象。

第二个代码会创建三个对象：

两个对象是使用 new 关键字分别创建的字符串对象 "a" 和 "b"。

第三个对象是通过字符串拼接创建的结果字符串对象 "ab"。