02-5-1常用API之String类

Java字符串就是Unicode字符序列。例如，串“Java\u2122”由5个Unicode字符J、a、v、a和TM。Java没有内置的字符串类型，而是在标准Java类库中提供了一个预定义类String。每个用双引号括起来的字符串都是String类的一个实例

1String类的特性

①String类：代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。 ②String是一个final类，代表不可变的字符序列，不可被继承。
③String实现了Serializable接口：表示字符串是支持序列化的。
④实现了Comparable接口：表示String可以比较大小
⑤字符串是常量，用双引号引起来表示。它们的值在创建之后不能更改。 String对象的字符内容是存储在一个字符数组final char value[]中的。

 ⑥String不可变性（代表不可变的字符序列 ）

体现：

• 当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
• 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
• 用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。

  @Test
    public void test01(){
        String s1 = "abc";//字面量的定义方式
        String s2 = "abc";
        System.out.println(s1 == s2);//比较s1和s2的地址值  true
        s1 = "hello";
        System.out.println(s1);//hello
        System.out.println(s2);//abc
        System.out.println("*****************");

        String s3 = "abc";
        s3 += "def";
        System.out.println(s3);//abcdef
        System.out.println(s2);

        System.out.println("*****************");
        String s4 = "abc";
        String s5 = s4.replace('a', 'm');
        System.out.println(s4);//abc
        System.out.println(s5);//mbc
    }

理解String不可变性：String s1="abc";当s1赋值为"hello"时，会新增一个字符串"hello"放入字符串常量池中，而不会修改之前"abc"的值

就像如下代码

int num1=3;

num1=3+1;

数值3修改为4后，3的值永远是3不会是4，字符串也是同样的道理"abc"的值永远是"abc"。

值传递+字符串的一个面试题

public class StringTest {

    String str = new String("good");
    char[] ch = { 't', 'e', 's', 't' };

    public void change(String str, char ch[]) {
        str = "test ok";
        ch[0] = 'b';
    }
    public static void main(String[] args) {
        StringTest ex = new StringTest();
        ex.change(ex.str, ex.ch);
        System.out.println(ex.str);//good
        System.out.println(ex.ch);//best
    }
}

⑦通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。 ⑧字符串常量池中是不会存储相同内容的字符串的。  

2String的创建方式

String的实例化方式：
        方式一：通过字面量定义的方式
        方式二：通过new + 构造器的方式

    @Test
    public void test2(){
        //通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中。
        String s1 = "abc";
        String s2 = "abc";
        //通过new + 构造器的方式:此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
        String s3 = new String("abc");
        String s4 = new String("abc");

        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
        System.out.println(s1 == s4);//false
        System.out.println(s3 == s4);//false

        System.out.println("***********************");
        Person p1 = new Person("Tom",12);
        Person p2 = new Person("Tom",12);

        System.out.println(p1.name.equals(p2.name));//true
        System.out.println(p1.name == p2.name);//true

        p1.name = "Jerry";
        System.out.println(p2.name);//Tom
    }
 class Person {

    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }
}

String str1 = “abc”;与String str2 = new String(“abc”);的区别？

• 字符串常量存储在字符串常量池，目的是共享
• 字符串非常量对象存储在堆中

面试题：String s = new String("abc");方式创建对象，在内存中创建了几个对象？
两个:一个是堆空间中new结构，另一个是char[]对应的常量池中的数据："abc"

3字符串拼接

1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
2.只要其中有一个是变量，结果就在堆中。
3.如果拼接的结果调用intern()方法，返回值就在常量池中

   @Test
    public void test3(){
        String s1 = "javaEE";
        String s2 = "hadoop";

        String s3 = "javaEEhadoop";
        String s4 = "javaEE" + "hadoop";
        String s5 = s1 + "hadoop";
        String s6 = "javaEE" + s2;
        String s7 = s1 + s2;

        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//false
        System.out.println(s3 == s6);//false
        System.out.println(s3 == s7);//false
        System.out.println(s5 == s6);//false
        System.out.println(s5 == s7);//false
        System.out.println(s6 == s7);//false

        String s8 = s6.intern();//返回值得到的s8使用的常量值中已经存在的“javaEEhadoop”
        System.out.println(s3 == s8);//true

    }

内存图为

    @Test
    public void test4(){
        String s1 = "javaEEhadoop";
        String s2 = "javaEE";
        String s3 = s2 + "hadoop";
        System.out.println(s1 == s3);//false

        final String s4 = "javaEE";//s4:常量
        String s5 = s4 + "hadoop";
        System.out.println(s1 == s5);//true
    }

4String常用API

Java中的String类包含了50多个方法。绝大多数都很有用，可以使用的频繁非常高

举一些方法剩余查看API文档

 int length()：返回字符串的长度： return value.length

 char charAt(int index)： 返回某索引处的字符return value[index] 

 boolean isEmpty()：判断是否是空字符串：return value.length == 0 

 String toLowerCase()：使用默认语言环境，将 String 中的所有字符转换为小写

 String toUpperCase()：使用默认语言环境，将 String 中的所有字符转换为大写

 String trim()：返回字符串的副本，忽略前导空白和尾部空白

 boolean equals(Object obj)：比较字符串的内容是否相同

 boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写

 String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+” 

 int compareTo(String anotherString)：比较两个字符串的大小

String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。 

String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。

 @Test
    public void test01(){
        String s1 = "abcdeF";
        System.out.println(s1.length());
        char c = s1.charAt(2);
        System.out.println(c);
        String s2= "";
        System.out.println(s1.isEmpty());
        System.out.println(s2.isEmpty());
        String s3 = s1.toLowerCase();
        System.out.println(s1);//字符串不可变性
        System.out.println(s3);
        System.out.println(s1.toUpperCase());

        String s4 = "   a b c def  ";
        String s5 = s4.trim();
        System.out.println(s4);
        System.out.println(s5);
    }

5String与char[]和byte[]转换

5.1String 与 char[]之间的转换

String --> char[]:调用String的toCharArray()
char[] --> String:调用String的构造器

    public void test2(){
        String str1 = "abc123";

        char[] charArray = str1.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            System.out.println(charArray[i]);
        }

        char[] arr = new char[]{'h','e','l','l','o'};
        String str2 = new String(arr);
        System.out.println(str2);
    }

5.2 String 与 byte[]之间的转换

编码：String --> byte[]:调用String的getBytes()
解码：byte[] --> String:调用String的构造器

编码：字符串 -->字节  (看得懂 --->看不懂的二进制数据)
解码：编码的逆过程，字节 --> 字符串 （看不懂的二进制数据 ---> 看得懂）

说明：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。

    @Test
    public void test3() throws UnsupportedEncodingException {
        String str1 = "abc123中国";
        byte[] bytes = str1.getBytes();//使用默认的字符集，进行编码。
        System.out.println(Arrays.toString(bytes));

        byte[] gbks = str1.getBytes("gbk");//使用gbk字符集进行编码。
        System.out.println(Arrays.toString(gbks));

        System.out.println("******************");

        String str2 = new String(bytes);//使用默认的字符集，进行解码。
        System.out.println(str2);

        String str3 = new String(gbks);
        System.out.println(str3);//出现乱码。原因：编码集和解码集不一致！

        String str4 = new String(gbks, "gbk");
        System.out.println(str4);//没有出现乱码。原因：编码集和解码集一致！

    }

 涉及到IO流时场景较多

6StringBuffer和Stringbuilder类

String、StringBuffer、StringBuilder三者的异同？

• String:不可变的字符序列；底层使用char[]存储
• StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储
• StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储

源码分析

StringBuffer创建对象 源码分析：

StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];
底层创建了一个长度是16的数组。
sb1.append('a');//value[0] = 'a';
sb1.append('b');//value[1] = 'b';

StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char["abc".length() + 16];

底层创建了一个长度是16+"abc".length()的数组。

1. System.out.println(sb2.length());//3
2. 扩容问题:如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中的元素复制到新的数组中。

StringBuffer的append()源码分析

    @Test
    public void test2(){
        StringBuffer sb1 = new StringBuffer("abc");//初始化长度为19 
        //追加的长度50 新的数组长度为53（因为19*2+2的长度也不够使用）
        sb1.append("qrwetryutiqrwetryutiqrwetryutiqrwetryutiqrwetryuti");
        sb1.append("中国");//新的长度为53*2+2=108
    }

 

 

建议：当日常开发中字符串长度过长时建议使用：StringBuffer(int capacity) 或 StringBuilder(int capacity) 以防多次创建数组造成内存的浪费