23-String类

String 类的特点

1. Java程序中，所有双引号字符串，都是String这个类的对象

2. 字符串一旦被创建，就不可更改（如果想更改，只能使用新的对象做替换）

3. 字符串常量池，让我们使用双引号创建字符串对象时，会先去常量池中查找有没有相同内容的字符串对象，如果有，则直接使用该对象，如果没有，则在常量池中创建一个字符串对象，然后再使用该对象

public class StringDemo1 {
    public static void main(String[] args){
        // 1.Java程序中，所有双引号字符串，都是String这个类的对象
        String s = "abc";
        System.out.println(s); // abc

        // 字符串一旦被创建，就不可更改（如果想更改，只能使用新的对象做替换）
        s = "def";
        System.out.println(s); // def，字符串一旦被创建，就应该不可更改，这里为什么改变了，这是因为s指向了新的字符串对象"def"

        // 等价于上面的，s指向了新的字符串对象"def"
        Student stu = new Student("张三", 20);
        stu = new Student("李四", 21);
        System.out.println(stu.getName() + "\t" + stu.getAge()); // 李四    21

        // 2.字符串常量池，让我们使用双引号创建字符串对象时，会先去常量池中查找有没有相同内容的字符串对象，如果有，则直接使用该对象，如果没有，则在常量池中创建一个字符串对象，然后再使用该对象
        String s1 = "abc";
        String s2 = "abc";

        // == 比较的是两个对象的地址值是否相同
        System.out.println(s1 == s2); // true，因为s1和s2都指向了常量池中的同一个字符串对象"abc"
        // equals 比较的是两个对象的内容是否相同
        System.out.println(s1.equals(s2)); // true，因为s1和s2指向的字符串对象内容相同

    }
}

这里注意：不同的JDK版本，字符串常量池的位置是不一样的

JDK7版本之前，StringTable是在方法区中

JDK7版本开始之后，StringTable被挪到了堆内存中

 

String类常见的构造方法

1. public String()：创建一个空白字符串，里面不包含任何内容

2. public String(char[] chs)：根据传入的字符串数组，创建字符串对象

3. public String(String original)：根据传入的字符串，来创建字符串对象

public class StringDemo2 {
    public static void main(String[] args){
        // public String():创建一个空白字符串对象，不含有任何内容
        String s1 = new String();
        System.out.println("s1:" + s1);

        // public String(char[] chs):根据传入的字符数组，来创建字符串对象
        char[] chs = {'a', 'b', 'c'};
        String s2 = new String(chs);
        System.out.println("s2:" + s2);

        // public String(String original):根据传入的字符串，来创建字符串对象
        String s3 = new String("abc");
        System.out.println("s3:" + s3);
    }
}

 

字符串对象，两种创建方式的区别

String s1 = "abc";

String s2 = new String("abc");

 

String类的常见面试题

 上面是字符串变量进行拼接，其结果是false，那要是字符串常量进行拼接呢，如下所示：

相当于从字符串池进行对比，其结果应该是true

 

String类用于遍历的方法：

1）public char[] toCharArray() ：将此字符串转换为一个新的字符数组

public class StringDemo3 {
    public static void main(String[] args){
        String s = "malingshu";

        // toCharArray():把字符串转换为字符数组
        char[] chs = s.toCharArray();

        for(int i=0; i < chs.length; i++){
            System.out.print(chs[i] + "\t");
        }
    }
}

2）public char charAt() ：返回指定索引处的char值

public class StringDemo3 {
    public static void main(String[] args){
        String s = "malingshu";

        // public char charAt(int index):获取指定索引位置的字符
        for(int i=0; i < s.length(); i++){
            System.out.print(s.charAt(i) + "\t");
        }
    }
}

3) public int length() ：返回字符串的长度

public class StringDemo3 {
    public static void main(String[] args){
        String s = "malingshu";
        String[] strArray = {"ma", "ling", "shu"};

        // 获取字符串的长度
        System.out.println("s.length():" + s.length()); // 10

        // 获取字符串数组的长度
        System.out.println("strArray.length:" + strArray.length); // 3


    }
}

 

案例：键盘录入一个字符串，统计该字符串中大写字母、小写字母、数字分别有多少个（不考虑其它字符的情况）

import java.util.Scanner;

public class StringDemo4 {
    public static void main(String[] args){
        // 键盘录入一个字符串，统计该字符串中大写字母、小写字母、数字分别有多少个（不考虑其它字符的情况）

        // 1.键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.nextLine();

        // 2.定义三个统计变量，初始化值都是0
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;

        // 3.遍历字符串，获取到每一个字符，并进行判断大写字母、小写字母、数字
        for(int i = 0; i < str.length(); i++){
            // 获取到每一个字符
            char ch = str.charAt(i);
            
            // 判断该字符属于哪种类型
//            if(ch >= 'A' && ch <= 'Z'){
//                bigCount++;
//            }else if(ch >= 'a' && ch <= 'z'){
//                smallCount++;
//            }else if(ch >= '0' && ch <= '9'){
//                numberCount++;
//            }

            // 也可以通过 ASCII 码来判断
            if(ch >= 81 && ch <= 106){
                bigCount++;
            }else if(ch >= 97 && ch <= 122){
                smallCount++;
            }else if(ch >= 64 && ch <= 73){
                numberCount++;
            }
        }
        
        System.out.println("大写字母：" + bigCount + "个");
        System.out.println("小写字母：" + smallCount + "个");
        System.out.println("数字：" + numberCount + "个");
    }
}

 

String字符串的截取方法（左闭右开）

1）public String substring(int beginIndex) ：根据传入的索引开始做截取，截取到字符串的末尾

2）public String substring(int beginIndex, int endIndex) ：根据传入的开始和结束做索引，对字符串做截取

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

        // public String substring(int beginIndex):截取从参数位置一直到字符串末尾，返回新字符串
        String s1 = "malingshu";
        String s2 = s1.substring(2);
        System.out.println("s2:" + s2); // lingshu

        // public String substring(int beginIndex,int endIndex):截取从beginIndex开始，一直到endIndex结束，中间的字符串
        // 左闭右开
        String s3 = s1.substring(2, 6);
        System.out.println("s3:" + s3); // ling
    }
}

 

String类的替换方法

public String replace(CharSequence target, CharSequence replacement) ：将字符串中的旧字符，替换成新的字符，并返回新的字符串

参数1：旧值

参数2：新值

public class StringDemo5 {
    public static void main(String[] args){
        // public String replace(char oldChar,char newChar):将字符串中的旧字符，替换成新的字符，并返回新的字符串
        String s1 = "hello world";
        String s2 = s1.replace("world", "malingshu");
        System.out.println("s2:" + s2); // s2:hello malingshu
    }
}

 

String类的切割方法

public String[] split(String regex) ：将字符串切分成若干部分，返回一个字符串数组

public class StringDemo5 {
    public static void main(String[] args){
        // public String[] split(String regex):将字符串切分成若干部分，返回一个字符串数组
        String s = "ma,ling,shu";
        String[] strArray = s.split(",");

        for(int i = 0; i < strArray.length; i++){
            System.out.print(strArray[i] + "\t");
        }
    }
}

 

 

StringBuilder 介绍：

1）StringBuilder是一个可变的字符序列（String是不可变的字符序列）

2）StrinBuilder是字符串缓冲区，可以将其理解是容器，这个容器可以存储任意数据类型，但是只要进入到这个容器，全部变成字符串

public class StringBuilderDemo1 {
    public static void main(String[] args){
        // public StringBuilder():创建一个空白可变字符串对象，不含有任何内容
        StringBuilder sb1 = new StringBuilder();
        sb1.append("abc");
        System.out.println("sb1:" + sb1); 

        // public StringBuilder(String str):根据字符串的内容，来创建可变字符串对象
        StringBuilder sb2 = new StringBuilder("abc");
        System.out.println("sb2:" + sb2); 
    }
}

 

StringBuilder常用的成员方法

1）public StringBuilder append(任意类型)：添加数据，并返回对象自己

（当调用的方法，返回的结果是对象时，就可以继续往下调用方法，也就是链式编程）

public class StringBuilderDemo2 {
    public static void main(String[] args){
        // public StringBuilder append(任意类型):添加数据，并返回对象本身
        StringBuilder sb = new StringBuilder();

        sb.append("红色");
        System.out.println(sb);

        sb.append("蓝色").append("绿色").append("黄色");
        System.out.println(sb);
    }
}

 2）public StringBuilder reverse()：将缓冲区中的内容，进行反转

public class StringBuilderDemo2 {
    public static void main(String[] args){
        // public StringBuilder reverse():返回相反的字符序列
        StringBuilder sb = new StringBuilder("abc123");
        System.out.println("反转前：" + sb);

        sb.reverse();
        System.out.println("反转后：" + sb);
    }
}

3）public StringBuilder toString()：将缓冲区的内容，以String字符串类型返回

public class StringBuilderDemo2 {
    public static void main(String[] args){
        // public StringBuilder toString():将缓冲区的内容，以String字符串类型返回
        // 实现把可变字符串对象转换为不可变字符串对象
        StringBuilder sb = new StringBuilder();
        sb.append("红色").append("绿色").append("蓝色");
        
        String s = sb.toString();
        System.out.println("s:" + s);
    }
}

 

扩展：String与StringBuidler类型之间的相互转换

1）StringBuilder类型转换为String类型

StringBuilder sb1 = new StringBuilder();
sb1.append("hello");
String s = sb1.toString();

2）String类型转换为StringBuilder类型

String s = "hello";   
StringBuilder sb2 = new StringBuilder(s);