String类

java.lang.String类代表字符串

Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。

特点

• 字符串的内容不可变！！
• 因为 String 对象是不可变的，所以可以共享。
• 字符串效果上相当于是char[]字符数组，但底层原理是byte[]字节数组（JDK9）

构造方法

package com;

public class StringTest {
    public static void main(String[] args) {
        // 常见创建字符串的3+1的方式
        String str1 = new String();
        System.out.println("第一种无参构造方法创建字符串："+str1);

        char[] array = {‘A‘,‘B‘,‘C‘};
        String str2 = new String(array);
        System.out.println("第二种传入字符数组创建字符串："+str2);

        byte[] array2 = {65,66,67};
        String str3 = new String(array2);
        System.out.println("第三种传入字节数组创建字符串："+str3);

        String str = "hello";
        System.out.println("直接创建字符串:"+str);
    }
}

注意

• 直接用双引号创建的字符串，JVM会自动将它new成字符串对象

字符串常量池

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

package com;

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

        char[] charArray = {‘1‘, ‘2‘, ‘3‘};
        String str3 = new String(charArray);

        System.out.println(str1 == str2);
        System.out.println(str1 == str3);
        System.out.println(str2 == str3);
    }
}

结果

true
false
false

示意图

注意

• 对于基本类型 --> 两个等号是比较【数值】是否相等
• 对于引用类型 --> 两个等号是比较【地址值】是否相等
• 直接用双引号创建的字符串会先到常量池看存不存在，字符串共享
• 使用new创建的字符串与常量池无关，会在堆中开辟新的空间

常用方法

查找方法

indexOf 和 lastIndexOf的多种重载方法

转换方法

?

其他方法

案例

package com;

/**
 * equals方法的使用
 * equalsIgnoreCase 忽略大小写的比较
 */
public class StringEquals {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        char[] array = {‘H‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘};
        String str3 = new String(array);

        System.out.println(str1.equals(str3));
        System.out.println(str2.equals(str3));
        System.out.println(str3.equals("Hello"));
        System.out.println("Hello".equals(str3));
        // 推荐常量字符串写在前面。变量写前面可能会出现空指针异常

        System.out.println("=============");
        String str4 = "hello";
        System.out.println(str3.equals(str4));
        // 忽略大小写
        System.out.println(str3.equalsIgnoreCase(str4));

    }
}

注意事项

• 任何对象都可以用Object进行接收
• equals方法具有对称性！即 a.equals(b) 和 b.equals(a)效果一样
• 如果一个常量和一个变量比较，推荐把常量字符串写在前面！

package com;

/**
 * length() 返回长度
 * concat 拼接
 * charAt 获取指定索引位置的单个字符
 * indexOf 查找首次出现的索引位置，无返回-1
 */
public class StringGet {
    public static void main(String[] args) {
        System.out.println("Hello world".length());

        // 拼接字符串 （String不可变！！）
        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);
        System.out.println(str1); // 原封不动
        System.out.println(str2); // 原封不动
        System.out.println(str3); // 新的字符串

        // 获取指定索引位置的单个字符
        System.out.println("Hello在0号索引位置的字符是："+"Hello".charAt(0));
        System.out.println("Hello在4号索引位置的字符是："+"Hello".charAt(4));

        // 查询参数字符串在原字符串当中出现的第一次索引位置
        System.out.println();
        String strA = "Hello World Hello1";
        System.out.println(strA.indexOf("hello")); // 查不到返回 -1
        System.out.println(strA.indexOf("Hello1"));// 首次出现的索引

    }
}

package com;

/**
 * 字符的截取方法
 * substring(int index)
 * substring(int begin, int end) 【b,n)左闭右开
 *
 */
public class StringSub {
    public static void main(String[] args) {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5);
        // 字符串不能发生改变，每当对原值操作就是生产新的字符串
        System.out.println(str1);
        System.out.println(str2);

        String str3 = str1.substring(4, 7);
        // 左闭右开
        System.out.println(str3);

    }
}

package com;

/**
 * 转换相关的方法
 * toCharArray[] 将当前字符串拆分为字符数组
 * getBytes() 获得当前字符串的底层字节数组
 * replace替换
 * valueOf 转换成字符串
 *
 */
public class StringConvert {
    public static void main(String[] args) {
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]);
        System.out.println(chars.length);
        System.out.println("===========");

        // IO经常用的字节流写入
        byte[] bytes = "abc".getBytes();
        for (byte b : bytes) {
            System.out.print(b + "\t");
        }
        System.out.println();

        String str1 = "Hi boy";
        String str2 = str1.replace("boy", "girl");
        System.out.println(str1);
        System.out.println(str2);
        System.out.println("===========");
        
        // 八大基本数据类型转换为字符串
        int num = 123;
        double d = 999.999;
        boolean b = false;
        char ch = ‘a‘;

        System.out.println(String.valueOf(num));
        System.out.println(String.valueOf(d));
        System.out.println(String.valueOf(b));
        System.out.println(String.valueOf(ch));
        
    }
}

package com;

/**
 * 分割方法split
 * String[] split(String regex)
 * split 的参数 regex是一个正则表达式
 * 英文句点“.” 写成“\\.”
 */
public class StringSplit {
    public static void main(String[] args) {
        String str1 = "1,2,3,4,5";
        System.out.println(str1);
        String[] array1 = str1.split(",");
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + "\t");
        }
        System.out.println();

        // 特殊！！使用英文句号时（.） 需要加两个反斜杠
        String str2 = "x.y.z";
        //String[] array2 = str2.split("."); // 直接用英文点不行
        String[] array2 = str2.split("\\.");
        System.out.println("长度为：" + array2.length);
        for (String s : array2) {
            System.out.print(s + "\t");
        }

    }
}

练习

1. 定义一个方法，吧数组{1,2,3}按指定格式拼接成一个字符串。格式参照如下；[word1#word2$word3]

package com.practise;

/**
 * 定义一个方法，吧数组{1,2,3}按指定格式拼接成一个字符串。
 * 格式参照如下；[word1#word2$word3]
 */
public class StringPractise {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3};
        System.out.println(fromArrayToString(nums));
    }

    public static String fromArrayToString(int[] array) {
        String result = "[";
        for (int i = 0; i < array.length; i++) {
            if (i != array.length - 1) {
                result += "word" + array[i] + "#";
            } else {
                result += "word" + array[i];
            }
        }
        result += "]";
        return result;
    }
}

2. 键盘输入一个字符串，并且统计其中各种字符出现的次数。

   • 种类有：大写字母、小写字母、数字、其他

   package com.practise;
   
   import java.util.Scanner;
   
   /**
    * 键盘输入一个字符串，并且统计其中各种字符出现的次数。
    * 种类有：大写字母、小写字母、数字、其他
    */
   public class StringPractise2 {
       public static void main(String[] args) {
           Scanner sc = new Scanner(System.in);
           System.out.print("请输入一个字符串：");
           String str = sc.nextLine();
           char[] chars = str.toCharArray();
           int[] count = {0, 0, 0, 0,};
           for (char c : chars) {
               if (c >= ‘A‘ && c <= ‘Z‘) {
                   count[0]++;
               } else if (c >= ‘a‘ && c <= ‘z‘) {
                   count[1]++;
               } else if (c >= ‘0‘ && c <= ‘9‘) {
                   count[2]++;
               } else {
                   count[3]++;
               }
           }
   
           System.out.print("大写字母、小写字母、数字、其他依次出现次数：");
           for (int i : count) {
               System.out.print(i + "\t");
           }
       }
   
   }
   
   

StringBuilder类

字符串拼接问题

由于String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象。例如：

public class StringDemo {
    public static void main(String[] args) {
        String s = "Hello";
        s += "World";
        System.out.println(s);
    }
}

在API中对String类有这样的描述：字符串是常量，它们的值在创建后不能被更改。

根据这句话分析我们的代码，其实总共产生了三个字符串，即"Hello"、"World"和"HelloWorld"。

引用变量s首先指向Hello对象，最终指向拼接出来的新字符串对象，即HelloWord 。

由此可知，如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。

为了解决这一问题，可以使用java.lang.StringBuilder类。

StringBuilder概述

查阅java.lang.StringBuilder的API，StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，

通过某些方法调用可以改变该序列的长度和内容。

原来StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。

它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。

StringBuilder会自动维护数组的扩容。原理如下图所示：(默认16字符空间，超过自动扩充)

构造方法

根据StringBuilder的API文档，常用构造方法有2个：

• public StringBuilder()：构造一个空的StringBuilder容器。
• public StringBuilder(String str)：构造一个StringBuilder容器，并将字符串添加进去。

package com;

/**
 * 字符串缓冲区，可以提高字符串的效率
 */
public class StringBuilderTest {
    public static void main(String[] args) {
        // 无参构造
        StringBuilder sb = new StringBuilder();
        System.out.println(sb);
        System.out.println(sb.length());

        // 构造一个字符串生成器，并初始化为指定的字符串内容。
        StringBuilder sb2 = new StringBuilder("Hello");
        System.out.println(sb2);
    }
}

常用方法

StringBuilder常用的方法有2个：

• public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。
• public String toString()：将当前StringBuilder对象转换为String对象。

append方法

append方法具有多种重载形式，可以接收任意类型的参数。任何数据作为参数都会将对应的字符串内容添加到StringBuilder中。例如：

package com;

/**
 * 常用方法
 * append 添加任意类型数据的字符串形式，并返回当前对象自身
 * 可链式添加！sb.append("hello").append("world");
 */
public class StringBuilderTest {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        System.out.println("调用append方法前，sb的值：" + sb);
        sb.append("world");
        System.out.println("调用append方法后，sb的值：" + sb);


        StringBuilder builder = new StringBuilder();
        // 可以添加 任何类型
        builder.append("hello ");
        builder.append("world ");
        builder.append(true);
        builder.append(100);
        // 链式编程
        builder.append("\n---------\n").append("world ").append(true).append(100);
        System.out.println("builder:"+builder);
    }
}

备注：StringBuilder已经覆盖重写了Object当中的toString方法。

toString方法

通过toString方法，StringBuilder对象将会转换为不可变的String对象。如：

package com;

/**
 * StringBuilder 和 String 之间的转换
 * String -> StringBuilder  ： new StringBuilder("字符串")
 * StringBuilder -> String  ： toString()
 */
public class StringBuilderTest2 {
    public static void main(String[] args) {
        String str = "hello";
        System.out.println(str);

        StringBuilder sb = new StringBuilder(str);
        sb.append(" world");
        System.out.println(sb);

        String s = sb.toString();
        System.out.println(s);

    }
}

方法自查

常用API - 字符串