String类和StringBuffer类

String类

• String是final类型的，使用String定义的字符串是一个常量，一旦创建，其内容和长度无法改变

1. String类的初始化

String 变量名 = 字符串;  
//初始化字符串时，既可以将字符串对象的初始值设为空，也可以初始化为一个具体的字符串

String str1 = null;//初始化为空
String str2 = "";//初始化为空字符串
String str3 ="abc";//初始化为abc

2. 使用String的构造方法初始化字符串对象

String 变量名 = new String(字符串);
//字符串同样可以为空或一个具体的空字符串

//String类的常用构造方法
//方法声明                   功能描述
String()               //创建一个为空的字符串
String(String value)  //根据指定的字符串内容创建对象  
String(char[] value)  //根据指定的字符数组创建对象   

package com;

public class Test {
    public static void main(String[] args) {
        //创建一个空的字符串
        String str1 = new String();
        //创建一个内容为abc的字符串
        String str2 = new String("abc");
        //创建一个内容为字符串数组的字符串
        char[] charArray = {'A', 'B', 'C'};
        String str3 = new String(charArray);

        System.out.println("a"+str1+"b");//ab
        System.out.println(str2);//abc
        System.out.println(str3);//ABC
    }
}

字符串的基本操作

package com;

public class Test {
    public static void main(String[] args) {
        String s = "abacbacbabacbab";   //初始化字符串
        System.out.println("字符串的长度为:"+s.length());//字符串的长度为:15
        System.out.println("字符串中的第一个字符:"+s.charAt(0));//字符串中的第一个字符:a
        System.out.println("字符c第一次出现的位置:"+s.indexOf('c'));//字符串c第一次出现的位置:3
        System.out.println("字符c最后一次出现的位置:"+s.lastIndexOf('c'));//字符串最后一次出现的位置:11
        System.out.println("子字符串第一次出现的位置:"+s.indexOf("ab"));//子字符串第一次出现的位置:0
        System.out.println("子字符串最后一次出现的位置:"+s.lastIndexOf("ab"));//子字符串最后一次出现的位置:13
    }
}

字符串的转换操作

package com;

public class Test {
    public static void main(String[] args) {

        String str = "java";
        char[] charArray = str.toCharArray();  //字符串转换为字符数组
        System.out.println("将字符串转换为字符数组的遍历结果:");//将字符串转换为字符数组的遍历结果:
        for (int i = 0; i < charArray.length; i++) {      //j,a,v,a
            if (i != charArray.length-1){
                //如果不是最后一个元素，在元素后面加逗号
                System.out.print(charArray[i]+",");
            }else {
                //数组的最后一个不加逗号
                System.out.println(charArray[charArray.length-1]);
            }
        }

        System.out.println("将int值转换为String类型之后的结果:"+String.valueOf(65));//将int值转换为String类型之后的结果:65
        System.out.println("将float值转换为String类型之后的结果:"+String.valueOf(65.2));//将float值转换为String类型之后的结果:65.2
        System.out.println("将double值转换为String类型之后的结果:"+String.valueOf(65.20));//将double值转换为String类型之后的结果:65.2
        System.out.println("将char值转换为String类型之后的结果:"+String.valueOf('A'));//将char值转换为String类型之后的结果:A

        System.out.println("将字符串转换为大写之后的结果:"+str.toUpperCase())//;将字符串转换为大写之后的结果:JAVA
    }
}

字符串的替换和去除空操作

trim()：方法用于去除字符串中首尾的空格

replace()：方法用于将字符串中所有与指定字符串匹配的子字符串替换成另一个字符串

package com;

public class Test {
    public static void main(String[] args) {
        String s = "  https: //  www.  bilibili .com/    ";
        //字符串去除空格操作
        System.out.println("去除字符串两端空格后的结果:"+s.trim());
        //去除字符串两端空格后的结果:https: //  www.  bilibili .com/
        
        
        //字符串替换操作
        System.out.println("去除字符串中所有的空格后的结果:"+s.replace(" ",""));
        //去除字符串中所有的空格后的结果:https://www.bilibili.com/

    }
}

字符串的判断操作

1. 用于判断字符串的方法，返回值均为boolean类型
2. "=="和equals()的区别：
   • equals()：方法用于比较两个字符串中的值是否相等
   • “==”：用于比较两个字符串对象的内存地址是否相等

package com;

public class Test {
    public static void main(String[] args) {
        String s1 = "Starter";
        String s2 = "St";

        System.out.println("判断字符串是否以字符串St开头:"+s1.startsWith("St"));//判断字符串是否以字符串St开头:true
        System.out.println("判断字符串是否以字符串er结尾:"+s1.endsWith("er"));//判断字符串是否以字符串er结尾:true
        System.out.println("判断字符串是否以包含字符串ar:"+s1.contains("ar"));//判断字符串是否以包含字符串ar:true
        System.out.println("判断字符串是否为空:"+s1.isEmpty());//判断字符串是否为空:false
        System.out.println("判断两个字符串是否相等:"+s1.equals(s2));//判断两个字符串是否相等:false


        String str1 = new String("abc");
        String str2 = new String("abc");

        //结果为false，因为str1和str2是两个对象，使用"=="比较的是内存地址
        System.out.println(str1==str2);
        //结果为true，因为str1和str2两个字符串内容相等
        System.out.println(str1.equals(str2));
        
    }
}

字符串的截取和分割

String[] strArray = str.split("-");
//split()方法会根据指定的符号”-“将字符串分割成三部分，保存放到一个String类型的数组中

package com;

public class Test {
    public static void main(String[] args) {
        String str = "2018-01-25";

        //字符串的截取
        System.out.println("从第6个到末尾:"+str.substring(5));//从第6个到末尾:01-25
        System.out.println("从第6个到第7个:"+str.substring(5,7));//从第6个到第7个:01

        //字符串的分割
        System.out.println("分割后的字符串数组中的元素以此为:");//分割后的字符串数组中的元素以此为:
        //通过横线连接符”-“将字符串转换为字符串数组
        String[] strArray = str.split("-");
        System.out.println(strArray);        //循环输出数组中的元素
        for (int i = 0; i < strArray.length; i++) {      //2018,01,25
            if (i != strArray.length-1){
                //如果不是最后一个元素，在元素后面加逗号
                System.out.print(strArray[i]+",");
            }else {
                //数组的最后一个不加逗号
                System.out.println(strArray[i]);
            }
        }

    }
}

字符串下标越界异常：StringIndexOutOfBoundsException

StringBuffer类

• StringBuffer类（也称字符串缓冲区）来操作字符串，其内容和长度都是可以改变的。
• StringBuffer类似一个容器，当在其添加或删除字符时，所操作的都是这个容器，因此不会产生新的StringBuffer对象

package com.sgl;

public class Test {
    public static void main(String[] args) {
        Test test = new Test();

        System.out.println("1.添加-------------------------");
        new Test().add();
        System.out.println("1.修改-------------------------");
        update();//定义的静态方法
        System.out.println("1.删除-------------------------");
        test.delete();
    }

    //添加
    public void add() {
        StringBuffer sb = new StringBuffer();//定义一个字符串缓冲区
        sb.append("ABC");//添加的结果:ABC
        System.out.println("添加的结果:" + sb);
        sb.insert(3, "DE");   //在指定位置插入字符串
        System.out.println("inset添加后的结果:" + sb);//inset添加后的结果:ABCDE
    }

    //修改     静态方法
    public static void update(){
        StringBuffer sb = new StringBuffer("ABAAA");
        sb.setCharAt(2,'C');  //修改指定位置的字符串
        System.out.println("修改指定字符的结果:"+sb);//修改指定字符的结果:ABCAA
        sb.replace(3,5,"DE");
        System.out.println("替换指定字符串的结果:"+sb);//替换指定字符串的结果:ABCDE
        System.out.println("字符反转的结果:"+sb.reverse());//字符串反转字符     反转的结果:EDCBA

    }
    //删除
    public void delete(){
        StringBuffer sb = new StringBuffer("ABCDEFG");
        sb.delete(3,7);  //删除指定范围
        System.out.println("删除指定位置的结果:"+sb);//删除指定位置的结果:ABC
        sb.deleteCharAt(2);  //指定位置删除
        System.out.println("删除指定位置的结果:"+sb); // 删除指定位置的结果:AB
        sb.delete(0,sb.length());  //清除缓冲区
        System.out.println("清除缓冲区的结果:"+sb);//清除缓冲区的结果:

    }
}

String和StringBuffer总结：

• String类定义的字符串时常量，一旦创建后。内容和长度都是无法改变的。StringBuffer表示字符容器**，其内容和长度可以随时修改**
• String类重写了Object类的equal()方法，而StringBuffer类没有重写Object类的equal()方法，如下：

package com.sgl;

public class Test {
    public static void main(String[] args) {

        String str1 = new String("abc");
        String str2 = new String("abc");
        
        System.out.println(str1.equals(str2));  //true
        
        StringBuffer sb1 = new StringBuffer("abc");
        StringBuffer sb2 = new StringBuffer("abc");
        
        System.out.println(sb1.equals(sb2));  //false
        
    }
}

• String类对象可以用操作符"+"进行连接，而StringBuffer对象之间不能，如下：

package com.sgl;

public class Test {
    public static void main(String[] args) {

        String str1 = new String("abc");
        String str2 = new String("abc");

        System.out.println(str1+str2);  //abcabc

        StringBuffer sb1 = new StringBuffer("abc");
        StringBuffer sb2 = new StringBuffer("abc");

        System.out.println(sb1+ab2);  //编译报错

    }
}