String类，StringBuilder类，StringBuffer类

String类

String类概述

1. 在Java中，字符串是使用“String类的对象”来表示的，字符串不是基本类型，它是“引用类型”。
2. java.lang.String(类)：它表示一个字符串。
   注意：java.lang下的类在我们使用时，可以不用导包。其他包的类，在使用时，必须导包。
3. 成员属性：private final char value[]; 它内部就是使用一个char[]数组来存储每个字符，表示字符串的。

String类的使用

之前我们使用String类都是：【常用】
String str = “呵呵”;
String类比较特殊：由于应用频率高，为了方便使用，所以：直接赋值，不用显示的new String对象。

String类构造方法

1. String()：无参构造方法：
2. String str = new String();//相当于：String str = “”;
3. String(char[] chars)：使用一个char[]数组构造字符串；
4. String(char[] chars,int off,int len):使用char数组的一部分构造字符串；
5. String(String s)：使用一个String构造一个字符串。

代码演示：

	public class Demo01 {
    public static void main(String[] args) {
        //1.String()：
        String s1 = new String();//相当于：String s1 = "";

        System.out.println("s1 = " + s1);

        //2.String(byte[] bytes)
        byte[] bytes = {97, 98, 99, 100};
        String s2 = new String(bytes);
        System.out.println("s2 = " + s2);

        //3.String(char[] chars)
        char[] chars = {'a', 'b', 'c', '我', '爱', 'J', 'a', 'v', 'a'};
        String s3 = new String(chars);
        System.out.println("s3 = " + s3);

        //4.String(char[] chars,int off,int len)
        //我们使用chars数组的：'我', '爱', 'J', 'a', 'v', 'a'几个字符构造字符串
        String s4 = new String(chars, 3, 6);
        System.out.println("s4 = " + s4);

        //5.String(String s):
        String s5 = new String("呵呵");
        System.out.println("s5 = " + s5);
    }
}

String类_创建字符串对象两种方式的区别

1. 第一种：
   String str = “Hello”;//存储在“堆中—常量池”

2. 第二种：
   String str = new String(“Hello”);//存储在“堆中”的对象空间。

    注意：String类有一个重要的特性：不可变的。它内部的字符序列，一旦创建后，是不可改变的。
    	String s1 = “Hello”;
    	s1 = “World”;//改变了s1的地址，并没有更改原“Hello”的内容
    	System.out.println(s1);//World	
   

常量池的存储机制：

相同的字符串，地址会被重复使用。
	String s3 = "hello";//在常量池中开辟空间，存储"hello"，然后将地址存到s3中
	String s4 = "hello";//会先在常量池中找，有没有"hello"，有，将"hello"的地址直接赋给s4	
	System.out.println(s3 == s4);//true

堆中的存储机制：

每个String对象，就是一个单独的空间，一个单独的地址。
String s5 = new String("World");
String s6 = new String("World");
System.out.println(s5 == s6);//false

代码演示：

	String s1 = “HelloWorld”;
	String s2 = “Hello” + “World”;//都是字符串常量，结果就是：HelloWorld
	System.out.println(s1 == s2);//true
	
	String s1 = “Hello”;
	String s2 = s1 + “World”;//由于有变量，所以结果就是一个“新字符串”
	String s3 = “HelloWorld”;
	System.out.println(s2 == s3);//false

String类的常用方法

判断功能（5个）

1. public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。区分大小写
2. public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小写。
3. public boolean contains (CharSequence s) ：判断参数字符串在当前字符串中是否存在(区分大小写)。存在，返回true，否则，返回false。
4. public boolean endsWith(String suffix) ：测试此字符串是否以指定的后缀结尾(区分大小写)。
5. public boolean startsWith(String prefix) ：测试此字符串是否以指定的前缀开始(区分大小写)

代码演示：

public static void main(String[] args) {
    String s1 = "Hello";
    String s2 = new String("hello");

    System.out.println("地址：" + (s1 == s2));//false
    System.out.println("内容：" + s1.equals(s2));//false
    System.out.println("忽略大小写比较：" + s1.equalsIgnoreCase(s2));//true

    s1 = "我附加贷款特朗普Java";
    //判断s1字符串中，是否包含：特朗普
    System.out.println("判断s1中是否包含特朗普：" + s1.contains("特朗普"));//true

    System.out.println("判断s1是否以'Java'结尾：" + s1.endsWith("Java"));//true
    System.out.println("判断s1是否以'我'开头：" + s1.startsWith("我"));//true
}

获取功能（7个）

1. public int length () ：返回此字符串的长度。
2. public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
3. public char charAt (int index) ：返回指定索引处的 char值。
4. public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
5. public int lastIndexOf(String str) ：返回指定子字符串最后一次出现的字符串中的索引。 如果不包含，则返回-1。
6. public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
7. public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。

代码演示：

public static void main(String[] args) {
        //1).public int length () ：返回此字符串的长度。
        String s1 = "HelloWorld我爱Java";
        System.out.println("字符串长度：" + s1.length());

        String s2 = "";//空字符串
        String s3 = null;//空指针
//        System.out.println(s2.length());//0
//        System.out.println(s3.length());//运行时异常：NullPointerException(空指针异常)

        //2).public String concat (String str) ：将指定的字符串连接到该字符串的末尾。相当于：+
        //比+符号效率高一些，但在字符串拼接时，也不建议使用。建议使用后边学的StringBuilder类。
        s1 = "Hello";
        String newStr = s1.concat("World");
        System.out.println("拼接后的结果：" + newStr);//HelloWorld
        System.out.println("原字符串：" + s1);//不变：Hello

        //3).public char charAt (int index) ：返回指定索引处的 char值。
        s1 = "我爱Java";
        System.out.println("获取索引0位置上的字符：" + s1.charAt(0));
        System.out.println("获取最后索引位置上的字符：" + s1.charAt(s1.length() - 1));
//        System.out.println("要注意索引正确：" + s1.charAt(s1.length()));//抛出异常：StringIndexOutOfBoundsException

        //可以使用length() + charAt()结合，做字符串的遍历
        for (int i = 0; i < s1.length(); i++) {
            char c = s1.charAt(i);
            System.out.println(c);
        }

        //4).public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。如果没找到，返回-1，区分大小写。
        s1 = "我爱Java";
        System.out.println("s1中'Java'的位置：" + s1.indexOf("Java"));//2
        System.out.println("s1中'java'的位置：" + s1.indexOf("java"));//-1(没找到)

        //5).public int lastIndexOf(String str) ：返回指定子字符串最后一次出现的字符串中的索引。 如果不包含，则返回-1
        s1 = "我爱Java，我一定要学好Java，我要月薪过万！！";
        System.out.println("s1中'Java'第一次出现的位置：" + s1.indexOf("Java"));//2
        System.out.println("s1中'Java'最后一次出现的位置：" + s1.lastIndexOf("Java"));//13

        //6).public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
        s1 = "我爱Java";
        System.out.println("从2开始截取，到末尾：" + s1.substring(2));//"Java"
        System.out.println("原字符串：" + s1);//不变："我爱Java"

        //7).public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex(含)到endIndex(不含)截取字符串。
        s1 = "我爱Java";
        System.out.println("截取'爱J'两个字符：" + s1.substring(1,3));//"爱J"
    }

转换功能（5个）

1. public char[] toCharArray () ：将此字符串转换为新的字符数组。
2. public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
3. public String toLowerCase() ：使用默认语言环境的规则将此 String所有字符转换为小写。
4. public String toUpperCase() ：将此 String所有字符转换为大写，使用默认语言环境的规则。
5. public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使用replacement字符串替换。

代码演示：

public static void main(String[] args) {
    //1).public char[] toCharArray () ：将此字符串转换为新的字符数组。
    String s1 = "HelloWorld";
    char[] chars = s1.toCharArray();
    System.out.println(chars);//只有char[]数组可以直接打印，其他类型数组，打印的都是地址值

    //2).public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
    byte[] bytes = s1.getBytes();
    for (int i = 0; i < bytes.length; i++) {
        System.out.println(bytes[i]);//每个字符的编码值
    }

    //3).public String toLowerCase() ：使用默认语言环境的规则将此 String所有字符转换为小写。
    System.out.println("将s1转换为小写：" + s1.toLowerCase());//helloworld
    System.out.println("原字符串：" + s1);//不变：HelloWorld

    //4).public String toUpperCase() ：将此 String所有字符转换为大写，使用默认语言环境的规则。
    System.out.println("将s1转换为大写：" + s1.toUpperCase());//HELLOWORLD

    //5).public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使用replacement字符串替换。

    s1 = "减肥特朗普绝非我方特朗普减肥哦我菲欧特朗普放假饿哦I我减肥克里斯特朗普";
    //将字符串中"特朗普"替换为"*"
    System.out.println("将字符串中\"特朗普\"替换为\"*\":" + s1.replace("特朗普","*"));
    System.out.println("原字符串：" + s1);//不变
}

分割功能（2个）

1. public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。以参数字符串为“分隔符”切割字符串
2. public String trim() ：去掉当前字符串的前后空格，并返回一个新字符串，原字符串不变。

代码演示：

	public static void main(String[] args) {
    //1).public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。
    //以参数字符串为“分隔符”切割字符串
    String s1 = "1,张三,22,1.87";
    String[] arr = s1.split(",");
    System.out.println("数组长度：" + arr.length);
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);

    }
    //2).public String trim() ：去掉当前字符串的前后空格，并返回一个新字符串，原字符串不变。
    s1 = "        zhang  san    ";
    System.out.println("原字符串：|" + s1 + "|");
    System.out.println("去掉前后空格：|" + s1.trim() + "|");
}

StringBuilder类

StringBuilder类概述

java.lang.StringBuilder(类)：它对字符串操作的“工具类”，可以将各种类型数据拼接成字符串。
	String类：不可变的；拼接时会产生很多垃圾，效率低；
	StringBuilder类：可变的；拼接时不会产生垃圾，始终是同一个StringBuilder对象，效率高。
		所以，做大量“字符串拼接”时，建议用：StringBuilder类。

StringBuilder的使用

StringBuilder构造方法

1. StringBuilder()：内部没有任何字符的空构建器。初始容量：16个空间。
2. StringBuilder(CharSequence seq)：可以使用一个String，StringBuilder等子类对象构造一个构建器。

StringBuilder成员方法

1. public StringBuilder append(各种类型 e)：将各种类型数据转换为字符串，并追加到当前序列的末位：
   注意：返回值的StringBuilder就是当前对象本身，意味着可以：方法链编程，连续的调用append()方法
2. public StringBuilder reverse()：将内部的字符反转。

代码演示：

	public class Demo08 {
    public static void main(String[] args) {
        //1.创建一个StringBuilder对象
        StringBuilder bld = new StringBuilder();
        //2.append()方法
        bld.append("Hello");
        bld.append("World");
        bld.append(10);
        bld.append(3.14);
        bld.append('你');
        bld.append(true);

        System.out.println(bld);//HelloWorld103.14你true

        //关于append()方法返回值：StringBuilder append(各种类型)
        StringBuilder bld2 = new StringBuilder();
        StringBuilder bld3 = bld2.append("Hello");//append()返回的就是bld2自己的引用
        System.out.println(bld2);//Hello
        System.out.println(bld3);//Hello
        System.out.println(bld2 == bld3);//true

        //可以根据这种返回值，使用"方法链"编程，连续的添加内容
        bld2.append("Hello").append("World").append(10).append(3.14).append(true);

        System.out.println(bld2);//HelloHelloWorld103.14true
        //将bld2中的所有字符：反转
        bld2.reverse();
        System.out.println(bld2);//eurt41.301dlroWolleHolleH

    }
}

注意！！！

1).String和StringBuilder是两种类型，不能搞混。但可以相互转换
	String转换为StringBuilder：使用StringBuilder的构造方法：StringBuilder bld = new StringBuilder(“Hello”);
	StringBuilder转换为String：调用StringBuilder的toString()方法。String s = bld.toString();
2).StringBuilder和StringBuffer的区别：
	1).这两个类的功能是一样的。
	2).StringBuilder是单线程版，在多线程环境下不安全，但：效率高；
	    StringBuffer是线程安全的，可以在多线程环境下使用，但：效率低；

使用案例：数组转化为字符串

public class Demo09 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 3, 5, 5, 2, 56};

        //转换为字符串表示："[1, 2, 3, 3, 5, 5, 2, 56]"
        String s = arrayToString(arr);
        System.out.println(s);
    }

    public static String arrayToString(int[] arr) {
        StringBuilder str = new StringBuilder("[");
        for (int i = 0; i < arr.length; i++) {
            str.append(arr[i]);
            if (i < arr.length - 1) {
                str.append(", ");
            }else{
                str.append("]");
            }
        }
        //将StringBuilder转换为字符串：
        return str.toString();
    }
}

StringBuffer类

未完待续，想知后续如何，请听下回分解~~~