一、String的使用及常用方法

1、概述

        String:表示字符串，使用""引起来。
            1.1、String类是声明为final的，不可被继承。
            1.2、String类实现了Serializable接口，表示字符串支持序列化。
                                      Comparable接口，表示字符串可以比较大小。

            1.3、String类内部声明了final char[] value,用于存储字符串数据。

            1.4、String使用字面量的方式（区别于new的方式创造的字符串，声明在方法区的常量池中）。
            1.5、方法区的常量池中不会存储相同内容的字符串数据。

 

2、String的不可变性

        2.1 说明
            String代表不可变的字符序列。体现为不可变性。

            体现：
                1)给已经赋值的字符串变量再赋不同的值，会在常量池中重新开辟空间进行赋值。不能在原有的value进行赋值。
                2)对字符串进行连接操作时，不会在原的基础上增加，而是重新在内存中开辟空间，不能在原有的value进行赋值。
                3)调用现的字符串的replace()方法对指定的字符进行更改时，会重新在内存中开辟空间，不能在原有的value进行赋值。

         2.2 代码举例

        String s1 = "abc";//字面量的定义方式
        String s2 = "abc";

        s1 = "hello";

        System.out.println(s1 == s2);

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

        String s3 = "abc";
        s3 += "edf";
        System.out.println(s3);
        System.out.println("********************");

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

        2.3 图示

 

3、String实例化的不同方式

        3.1 方式说明
                ①通过字面量的方式实例化。
                ②通过"new + 构造器"的方式实例化。
        3.2 代码举例

//通过字面量的方式实例化:此时s1和s2的abc数值存在方法区的常量池中。
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(s3 == s4);//false

        3.3 面试题
        String str = new String("abc");创建了几个对象？
        答：两个，一个是堆空间new出来的结构，另一个是常量池中的char[]中的数据"abc"。

        3.4、图示

 

4、字符串拼接方式赋值的对比

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

        4.2 代码举例 

        String s1 = "helloJavaEE";
        String s2 = "hello";
        String s3 = s2 + "JavaEE";
        System.out.println(s1 == s3);//false

        final String s4 = "hello";
        String s5 = s4 + "JavaEE";
        System.out.println(s1 == s5);//true
        System.out.println("****************");

        String s1 = "hello";
        String s2 = "world";

        String s3 = "helloworld";
        String s4 = "hello" + "world";
        String s5 = s1 + s2;
        String s6 = s1 + "world";
        String s7 = "hello" + 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 = s7.intern();
        System.out.println(s3 == s8);//true

5、常用方法  

/*
    字符串常用方法1：
 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(不包含)的一个子字符串。
 */
public class StringMethod {
    @Test
    public void test2(){
        String s1 = "abc";
        String s2 = "ABC";
        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equalsIgnoreCase(s2));//true

        String s3 = "abc";
        String s4 = s3.concat("def");
        System.out.println(s4);//abcdef

        String s5 = "abe";
        int i = s3.compareTo(s5);
        System.out.println(i);//-2

        String s6 = "落霞与孤鹜齐飞，秋水共长天一色";
        String s7 = s6.substring(2);
        System.out.println(s6);//落霞与孤鹜齐飞，秋水共长天一色
        System.out.println(s7);//与孤鹜齐飞，秋水共长天一色

        String s8 = s6.substring(2,8);
        System.out.println(s8);//与孤鹜齐飞，


    }


    @Test
    public void test1(){
        String s1 = "HelloWorld";
        System.out.println(s1.length());//10
        System.out.println(s1.charAt(0));//h
//        System.out.println(s1.charAt(10));//报错StringIndexOutOfBoundsException
//        s1 = "";
        System.out.println(s1.isEmpty());//false //true
        String s2 = s1.toLowerCase();
        System.out.println(s1);//HelloWorld,不改变现有结构
        System.out.println(s2);//helloworld

        String s3 = s1.toUpperCase();
        System.out.println(s1);//HelloWorld,不改变现有结构
        System.out.println(s3);//HELLOWORLD

        String s4 = "   hell o wor ld  ";
        String s5 = s4.trim();//经常使用在账户密码的注册
        System.out.println("-----" + s4 + "-----");//-----   hell o wor ld  -----
        System.out.println("-----" + s5 + "-----");//-----hell o wor ld-----

    }

 /*
    字符串常用方法2：
        boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
        boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
        boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串
            是否以指定前缀开始
        boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true
        int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
        int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，
            从指定的索引开始
        int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
        int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的
            索引，从指定的索引开始反向搜索
        注：indexOf和lastIndexOf方法如果未找到都是返回-1

     */
    @Test
    public void test3(){
        String s1 = "hellowoworld";
        boolean b1 = s1.endsWith("orld");
        System.out.println(b1);//true

        boolean b2 = s1.startsWith("he");
        System.out.println(b2);//true

        boolean b3 = s1.startsWith("ow", 4);
        System.out.println(b3);//true

        boolean b4 = s1.contains("lo");
        System.out.println(b4);//true

        int i = s1.indexOf("ow");
        System.out.println(i);//4

        int i1 = s1.indexOf("ow", 5);
        System.out.println(i1);//6

        int i2 = s1.lastIndexOf("wo");
        System.out.println(i2);//7

        String s2 = "hellowoloworld";
        int i3 = s2.lastIndexOf("wo",8);
        System.out.println(i3);//5


        //什么情况下调用indexOf(str)和lastindexOf(str)返回的值一样？
        //情况一：只有唯一的一个str。情况二：不存在
    }

    /*
    字符串常用方法3：
    替换：
    String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar替换
        此字符串中出现的所有 oldChar 得到的。
    String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列
        替换此字符串所有匹配字面值目标序列的子字符串。
    String replaceAll(String regex, String replacement) ：使用给定的replacement替换
        此字符串所有匹配给定的正则表达式的子字符串。
    String replaceFirst(String regex, String replacement) ：使用给定的replacement替换
        此字符串匹配给定的正则表达式的第一个子字符串。
    检验：
    boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。
    String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
    String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多
        不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。
     */

    @Test
    public void test4(){
        String str1 = "北京尚硅谷教育北京";
        String str2 = str1.replace("北", "东");
        System.out.println(str1);//"北京尚硅谷教育北京"
        System.out.println(str2);//东京尚硅谷教育东京

        String str3 = str1.replace("北京", "上海");
        System.out.println(str3);//上海尚硅谷教育上海

        String str = "12hello34world5java7891mysql456";
        //把字符串中的数字替换成,，如果结果中开头和结尾有，的话去掉
        String string = str.replaceAll("\\d+", ",").replaceAll("^,|,$", "");
        System.out.println(string);//hello,world,java,mysql

         str = "12345";
        //判断str字符串中是否全部有数字组成，即有1-n个数字组成
        boolean matches = str.matches("\\d+");
        System.out.println(matches);//true
        String tel = "0571-4534289";
        //判断这是否是一个杭州的固定电话
        boolean result = tel.matches("0571-\\d{7,8}");
        System.out.println(result);//true

        str = "hello|world|java";
        String[] strs = str.split("\\|");
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
        System.out.println();
        str2 = "hello.world.java";
        String[] strs2 = str2.split("\\.");
        for (int i = 0; i < strs2.length; i++) {
            System.out.println(strs2[i]);
        }
    }

6、String与其它结构的转换     

        6.1、与基本数据类型、包装类之间的转换
                String——>基本数据类型、包装类：调用包装类的相对应的parseXxx(str)方法。
                基本数据类型、包装类——>String：调用String重载的String.valueOf()方法。连接操作（+""）

String s1 = "123";
int num = Integer.parseInt(s1);

String s2 = String.valueOf(num);
String s3 = num + "";

System.out.println(s1 == s3);

        6.2、与字符数组之间的转换
                String-->char[]:调用str.toCharArray()方法。
                char[]-->String：调用String的构造器。

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

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

        6.3、与字节数组之间的转换
                编码：String-->byte[]：调用str.getBytes()方法进行转换。
                解码：byte[]-->String：调用String的构造器。

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

        说明：当进行解码时，需要要求编码时试用的字符集与解码时使用的字符集一致，否则会出现乱码。

String s1 = "abc123中国";
byte[] arr1 = s1.getBytes();//使用默认的编码集进行编码
System.out.println(Arrays.toString(arr1));

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

String s2 = new String(arr1);//使用默认的编码集进行解码
System.out.println(s2);

String s3 = new String(gbks);//使用gbk编码集进行解码
System.out.println(s3);//出现乱码，因为编码集与解码集不一致

String s4 = new String(gbks, "gbk");
System.out.println(s4);//没出现乱码，因为编码集与解码集一致

         6.4、与StringBuffer、StringBuilder之间的转换
        Sring——>StringBuffer、StringBuilder：调用StringBuffer、StringBuilder构造器（public StringBuffer(String str) {}）
        StringBuffer、StringBuilder——>Sring：调用String构造器（public String(StringBuffer buffer) {}）

7、JVM中字符串常量池存放位置说明：

        jdk1.6：存在方法区的常量池（永久区）
        jdk1.7：存在堆空间的常量池
        jdk1.8：存在方法区的常量池中（元空间）

二、StringBuffer、StringBuilder的使用及常用方法

1、String、StringBuffer、StringBuilder三者的对比       

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

2、StringBuffer与StringBuilder的内存解析

以StringBuffer为例：
源码：
1.

String str = new String();//char[] value = new char[0];
String str1 = new String("abc");//char[] value = new char[]{'a','b','c'};

2.

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

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

问题1：sout(sb2.length());//3
问题2：如果在添加数据过程中，底层数组盛不下了，那么需要扩容底层数组。
 默认情况下，扩容到原来底层数组长度的2倍+2，同时将之前的数据都复制到扩容后的数组。

开发中优先使用StringBuffer(int capacity)或者StringBuilder(int capacity)来指定底层数组长度。

3、对比String、StringBuffer、StringBuilder三者的执行效率

效率由高到低：StringBuilder > StringBuffer > String

@Test
    public void test3(){
        //初始设置
        long startTime = 0L;
        long endTime = 0L;
        String text = "";
        StringBuffer buffer = new StringBuffer("");
        StringBuilder builder = new StringBuilder("");
//开始对比
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer的执行时间：" + (endTime - startTime));

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的执行时间：" + (endTime - startTime));

        startTime = System.currentTimeMillis();
        for (int i = 0; i < 20000; i++) {
            text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的执行时间：" + (endTime - startTime));

    }

运行结果：

4、StringBuffer、StringBuilder中的常用方法

增：str.append(xxx);
删：str.delete(int start,int end);
改：replace(int start, int end, String str);\setCharAt();
查：charAt();
插：insert(int offset, xxx);
长度：length();
遍历：fori + charAt();/toString();

@Test
    public void test2(){
        StringBuffer str = new StringBuffer("abc123");
        str.append(1);
        str.append('b');
//        str.delete(2,4);
//        str.replace(3,5,"def");
        str.insert(2,"false");
        str.reverse();
        System.out.println(str);

    }