String类、StringBuilder类、StringBuffer类---常用类

java.lang.String类代表字符串

程序中所有的双引号字符串，都是string类的对象（就算没有new，也照样是）

字符串的特点：

1.字符串的内容永不改变【重点】

2.正式字符串内容永不改变，所以字符串是可以共享使用的

3.字符串效果上相当于char[]字符串数组，但是底层原理是byte[]字节数组

创建字符串的常用3+1种方法

三种构造方法：

public String():创建一个空白字符串，不含有任何信息

public String(char[] array):通过一个字符数组，来创建字符串

public String(byte[] array):通过一个字节数组来创建字符串（本质）

一种直接创建:

String s = "hello";

注意：直接写上双引号，就是字符串对象。jvm会自动帮你创建

package commonclass;

public class TestString01 {
    public static void main(String[] args) {
        //空参构造创建字符串
        String s1 = new String();
        System.out.println(s1);

        //运用字符数组，创建字符串
        char[] chars = {'a','b','c','d'};
        String s2 = new String(chars);
        System.out.println(s2);

        //根据字节数组，创建字符串
        byte[] bytes = {97,98,99};
        String s3 = new String(bytes);
        System.out.println(s3);
        
        //直接""创建字符串
        String s4="abcd";
        System.out.println(s4);
    }
}

字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。

对于基本类型来说，==是进行数值的比较

对于引用类型来说，==是进行【地址值】的比较

package commonclass;

public class TestString02 {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";

        byte[] bytes = {97,98,99};
        String str3 = new String(bytes);

        char[] chars = {'a','b','c'};
        String str4 = new String(chars);

        //对于基本类型来说，==是进行数值的比较

        //对于引用类型来说，==是进行【地址值】的比较

        System.out.println(str1 == str2);//true
        System.out.println(str2 == str3);//false
        System.out.println(str3 == str4);//false
        System.out.println(str2 == str4);//false

    }
}

string类常用方法

1.对字符串内容的比较：

1.1

public boolean equals(Object anObject)//对字符串内容的比较，而==是对地址值的比较

注意：

1.equals方法具有对称性，a.equals(b)和b.equals(a)效果是一样的

2.如果比较双方一个常量，一个变量，推荐将常量写在前面，变量写在后面

推荐： "abc".equlas(str) 不推荐：str.equlas("abc")

原因：

String str5 = null;
System.out.println("abc".equals(str5));//false
System.out.println(str5.equals("abc"));//会出现NullPointerException

1.2

public boolean equalsIgnoreCase(String anotherString)//忽略大小写，对内容字符串进行比较

2.字符串获取的相关方法

public int length()//返回字符串中字符的长度（个数）
public String concat(String str)//将字符串拼接到原字符串后面，并返回
public char charAt(int index)//返回字符串中指定索引值的字符
public int indexOf(String str)//返回参数中的字符串在原字符串中第一次出现的索引值，-1没找到
public int indexOf(String str, int fromIndex)//第fromIndex次出现的索引值，-1没找到

package commonclass;

public class TestString03 {
    public static void main(String[] args) {
        String str1 = "sdosnksmklmsklmcsdlkmcdskld";
        System.out.println("字符串的长度："+str1.length());

        System.out.println("abc".concat("de"));

        String str2 = "abcdefghijl";
        System.out.println(str2.charAt(2));


        String str3 = "dhdh000dhdh";
        String str4 ="dh";
        System.out.println(str3.indexOf(str4));
        System.out.println(str3.indexOf(str4,3));//第三次出现的索引值


    }
}

3.字符串的截取方法

public String substring(int beginIndex)//截取返回从beginIndex到末尾索引的字符串
public String substring(int beginIndex, int endIndex)//截取从索引beginIndex，到endIndex索引的字符串，注意：[beginIndex,endIndex),左边索引字符包含，右边字符不包含

4.字符串的转化相关方法

public char[] toCharArray()//将字符串变为字符数组，并返回
public byte[] getBytes()//将字符串变为字节数组，并返回
public String replace(CharSequence target, CharSequence replacement)//将原字符串中的一部分字符串替换成新的字符串，并返回。CharSequence，可以接受字符串类型

5.字符串的分割（将一个字符串分割成两个字符串）

public String[] split(String regex) //按照切割规则，将一个字符串分割成字符串数组
 public String[] split(String regex, int limit) //分割成limit部分（返回的字符串数组的长度）（"aa,bb,cc，dd"如果limit是2，结果为"aa"和"bb,cc,dd"）
    /*
    *注意：regex是一个正则表达式，如果按"."进行切分，需要转义"\\."
    */

String str4 = "aaa.bbb.ccc.ddd";
String[] split1 = str4.split("\\.");//如果是String[] split1 = str4.split(".")，split1的长度为0
for (String s : split1) {
    System.out.println(s);
}

练习：

package commonclass;

import java.lang.reflect.Array;

//将一个数组{1,2,3}拼接成字符串[word1#word2#word3]
/*思路
* 方案一：(不可行，string本身值不变)
* 1.先创建一个字符串”[“
* 2.依次读取数组中的数据，拼接成Word1#，与原字符串拼接str=str+string（最后一个数据须特别对待）
* 3.再拼接字符串”]"
* 方案二：
* 先将数组变为字符串，再拼接*/
public class PracticeString01 {

    public static void myConcat1(int[] arr){
       String str1 = "[";

        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length-1){
                str1 = str1 + "word" + arr[i] + "]";
            }else {
                str1 = str1 + "word" + arr[i] +"#";
            }
        }
        System.out.println(str1);
    }

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

package commonclass;

import java.util.Scanner;

//题目：键盘输入一个字符串，统计字符的类型个数
//字符类型可分为大写字母，小写字母，数字，其他
/*思路：
* 1.读取控制台输入的字符串
* 2.将字符串变为字符数组，依次遍历字符，判断字符类型
* 3,。输出不同类型的个数*/
public class PracticeString02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入字符串：");
        String str = scanner.next();
        char[] chars = str.toCharArray();
        int M = 0;
        int m = 0;
        int n =0;
        int other = 0;

        for (char c : chars) {
            if('A' <=c && c <= 'Z') {
                M++;
            }else if ('a' <= c && c<= 'z'){
                m++;
            }else if ('0' <= c && c <= '9' ){
                n++;
            }else {
                other++;
            }

        }
        System.out.println("大写字母有"+M+"个。");
        System.out.println("小写字母有"+m+"个。");
        System.out.println("数字有"+n+"个。");
        System.out.println("其他字符有"+other+"个。");

    }
}

Stringbuilder类（字符串缓存区,字符串可变化）----常用类

java.lang.StringBuilder类：字符串缓冲区，可以提高字符串的效率，可以改变字符串的内容

构造方法：

public StringBuilder()//构造一个16个字符的初始容量的空字符串
public StringBuilder(String str)//创建一个给定str内容的字符串

常用的成员方法：

public StringBuilder append(....)//往字符缓冲区添加数据

package commonclass;

public class TestStringBuilder01 {
    public static void main(String[] args) {
        StringBuilder stringBuilder = new StringBuilder();
        //append方法返回的是this，调用方法的对象为stringBuilder，this == stringBuilder
        StringBuilder stringBuilder2 = stringBuilder.append("abc");//将stringBuilder的地址赋值给stringBuilder2
        System.out.println(stringBuilder);//abc
        System.out.println(stringBuilder2);//abc
        System.out.println(stringBuilder == stringBuilder2);//true，比较的是地址

        //使用append方法无需接受返回值

        stringBuilder.append(1);
        stringBuilder.append(1.1);
        stringBuilder.append('好');
        stringBuilder.append(true);
        stringBuilder.append("是多少");
        System.out.println(stringBuilder);//abc11.1好true是多少

        //链式编程：方法返回一个对象，可以继续调用这个对象

        stringBuilder.append(3).append(3.3).append('坏').append(true).append("安师大");
        System.out.println(stringBuilder);//abc11.1好true是多少33.3坏true安师大
    }
}

stringBuilder和String可以相互转化

String--->stringBuilder:可以使用stringBuilder的构造方法

​ public StringBuilder(String str)，构造一个指定字符串的字符串缓冲区

StringBuilder--->String :使用stringBuilder的toString()方法

​ public String toString()---将StringBuilder转化为string

package commonclass;

public class TestStringBuilder02 {
    public static void main(String[] args) {
        String str = "abc";
        System.out.println(str);
        //String-->StringBuilder
        StringBuilder stringBuilder = new StringBuilder(str);
        //往StringBuilder中添加数据
        stringBuilder.append("cde");
        System.out.println(stringBuilder);
        //StringBuilder-->String
        String string = stringBuilder.toString();
        System.out.println(string);
    }
}

StringBuffer跟StringBuilder的构造方法与成员方法一样

两者区别：