13.【String类】

概述

​ java.lang.String类代表字符串。 Java程序中的所有字符串文字（例如"abc"）都被实现为此类的实例。实例就是根据类创建出来的一个个具体的“对象”。

​ 类String中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取字符串以及创建具有翻译为大写或者小写的所有字符的字符串的副本。

特点

1. 字符串不变：字符串的值在创建后不能被更改。是个常量

String s1 = "abc";
s1 += "d";
System.out.println(s1); // "abcd"
// 内存中有"abc","abcd"两个对象，s1由指向"abc",改变指向了"abcd".

2. 因为字符串不可变，所以字符串是可以共享的。

String s1 = "abc";
String s2 = "abc";
// 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

3. "abc"等效于char[] ch ={'a','b','c'}

例如：
String str = "abc";

相当于：

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

// 字符串效果上相当于是char型字符数组。但是底层原理是 byte[] 字节数组。1 byte = 8bit

使用步骤

• 查看类

  • java.lang.String：此类不需要导入。

• 查看构造方法

  • public string()：初始化新创建的String对象，以使其表示空字符序列。
  • public String（char[]value）：通过当前参数中的字符数组来构造新的String。
  • public string(byte[]bytes)：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的String。

创建字符串的3+1种方式

1. 三种构造方法： 构造方法没有返回值
   2. 直接创建

直接写上双引号，就是字符串对象（new不new没关系）。

String str = "Hello"; // 右边直接用双引号。

构造举例，代码如下：

package cn.luis.demo1;

public class Demo01String {

    public static void main(String[] args) {
        // 使用无参构造
        String str1 = new String(); // 小括号留空，说明字符串不含有任何内容
        System.out.println("使用空参构造：" + str1);

        // 根据字符串数组创建字符串
        char[] charArray = {'A', 'B', 'C'};
        String str2 = new String(charArray);
        System.out.println("根据字符串数组创建字符串：" + str2);

        // 根据字节数组创建字符串
        byte[] byteArray = {97, 98, 99};
        String str3 = new String(byteArray);
        System.out.println("根据字节数组创建字符串：" + str3); // abc

        // 直接创建
        String str4 = "Hello";
        System.out.println("直接创建：" + str4);
    }
}

结果：

使用空参构造：
根据字符串数组创建字符串：ABC
根据字节数组创建字符串：abc
直接创建：Hello

字符串常量池

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

双引号直接写的字符串在常量池当中，new的不在池当中.

• 对于基本类型来说： == 是进行数值的比较
• 对于引用类型来说： == 是进行【地址值】的比较

package cn.luis.demo1;

public class Demo02StringPool {

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

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

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

常用方法

1. 判断功能的方法

• public boolean equals（Object anobject）：将此字符串与指定对象进行比较。
• public boolean equalsIgnorecase（String anotherstring）：将此字符串与指定对象进行比较，忽略大小写。

Object是“对象”的意思，也是一种引用类型。作为参数类型，表示任意对象都可以传递到方法中。

字符串的内容比较

== 是进行对象的地址值比较，如果确实需要字符串的【内容】比较，可以使用equals方法。

1. 严格区分大小写，进行内容比较

public boolean equals(Object obj)

参数可以是任何对象，只有参数是一个字符串并且内容相同时才会给true，否则返回false。

2. 忽略大小写，进行内容比较

public boolean equalsIngoreCase(String str)

注意

1. 任何对象都能用Object进行接收。
2. equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果相同
3. 如果比较双方一个是常量、一个是变量，推荐【把常量写前边】，避免空指针异常

代码如下：

package cn.luis.demo2;

public class Demo01StringEquals {

    public static void main(String[] args) {

//        System.out.println(equalsMethod());

        String str1 = "Hello";
        String str2 = "Hello";

        char[] charArray = {'H', 'e', 'l', 'l', 'o'};
        String str3 = new String(charArray);

        // 第1种方法：
        System.out.println(str1.equals(str2)); //  true
        System.out.println(str2.equals(str3)); //  true
        System.out.println(str3.equals("Hello")); // true
        System.out.println("Hello".equals(str1)); // true

        String str4 = "hello";
        System.out.println(str1.equals(str4)); // false
        System.out.println("=================");

        String str5 = "abc"; // 若str5 = null; 则下面会发生错误
        System.out.println("abc".equals(str5)); // 推荐,false
        System.out.println(str5.equals("abc")); // 不推荐,NullPointerException
        System.out.println("===============");


        // 第2种方法：
        String strA = "Java";
        String strB = "java";
        System.out.println(strA.equals(strB));  // false,严格区分大小写
        System.out.println(strA.equalsIgnoreCase(strB)); // true,忽略大小写

        System.out.println("abc一123".equalsIgnoreCase("abc1123")); // false

    }

/*    private static boolean equalsMethod() {
        String str1 = "Hello";
        String str2 = "Hello";
        return str1 == str2;
    }*/

}

2. 获取功能的方法

• public int 1ength（）：返回此字符串的长度。
• public string concat（String str）：将指定的字符串连接到该字符串的末尾。
• public char charAt（int index）：返回指定索引处的char值。
• public int indexof（string str）：返回指定子字符串第一次出现在该字符串内的索引。
• public string substring（int beginIndex）：返回一个子字符串，从beginlndex开始截取字符串到字符串结尾。
• public string substring（int beginIndex，int endIndex）：返回一个子字符串，从beginlndex到endindex截取字符串。含beginlndex，不含endlndex。

代码如下：

public class Demo02StringGet {

    public static void main(String[] args) {

        // 获取字符串的长度
        int length = "asdagva".length(); // 快捷键:"asdasfgg".length; 再加上ALT+回车 选第一个
        System.out.println("字符串的长度是：" + length);

        // 拼接字符串
        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);
        System.out.println(str1); // Hello，原封不动
        System.out.println(str2); // World，原封不动
        System.out.println(str3); //HelloWorld, 这是一个全新的、第三个字符串，前面两个不会变化。
        System.out.println("=============");

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

        // 查找参数字符串在本字符串当中首次出现的索引位置 若没有，返回-1值
        String original = "WO he wo de zu guo yi ke ye bu neng fen ge";
        String strA = "wo";
//        System.out.println(strA.indexOf(original));  // 写反啦！！ -1
        int index = original.indexOf(strA);
        System.out.println("第一次的索引值是：" + index);  // 从原字符串中寻找参数里的字符串

        System.out.println("Hello".indexOf("abc")); // -1
    }
}

结果：

字符串的长度是：7
Hello
World
HelloWorld
=============
在2号索引位置的字符是：l
=============
第一次的索引值是：6
-1

3. 字符串的截取方法

• public String substring(int index) : 截取从参数位置一直到字符串末尾，返回新字符串。

• public String substring(int begin, int end): 截取从begin开始，一直到end结束，返回中间的字符串。

  [begin,end)：包含左边不包含右边

public class Demo03SubString {

    public static void main(String[] args) {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5);
        System.out.println(str1); // HelloWorld,原封不动
        System.out.println(str2); // World,新字符串
        System.out.println("==================");

        String str3 = str1.substring(4,7); // shift + 向右箭头 选5、6、7就得到了--“owo”
        System.out.println(str3);

        //下面这种写法，字符串的内容仍然是没有改变的
        //下面有两个字符串："Hello"，"Java"
        //strA当中保存的是地址值。
        //本来地址值是HelLo的0x666，
        //后来地址值变成了Java的ex999
        String strA = "Hello";
        System.out.println(strA);  // HelLo
        strA = "Java";
        System.out.println(strA);  // Java
    }
}

结果：

HelloWorld
World
==================
oWo
Hello
Java

4. 转换功能的方法

• public char[]tocharArray（）：将此字符串转换为新的字符数组。

• public byte[]getBytes（）：使用平台的默认字符集将该String编码转换为新的字节数组。

• public String replace（CharSequence target，Charsequence replacement）：将与target匹配的字符串使用replacement字符串替换。

  将所有出现的老字符串替换成为新的字符串，返回替换之后的结果–新字符串。

  CharSequence意思是可以接收字符串类型。（接口）

代码如下：

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

        char[] chars = {'夏', '天'};
        System.out.println(chars); // 夏天

        // 将当前字符串拆分成为字符数组作为返回值
        char[] ch = "Hello".toCharArray();
        System.out.println(ch);  // Hello
        System.out.println(ch[0]); // H
        System.out.println(ch.length);  // 5
        System.out.println("================");

        // 获取当前字符串底层的字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]); // 97 98 99
        }
        System.out.println("==================");

        // 字符串的内容替换
        String str1 = "How do you do?";
        String str2 = str1.replace("o","*"); // 返还一个新字符串str2
        System.out.println(str1); // How do you do?
        System.out.println(str2); // H*w d* y*u d*?
        System.out.println("==================");

        String lang1 = "会不会玩啊! 你大爷的,你大爷的,你大爷的!";
        String lang2 = lang1.replace("大爷", "**");
        System.out.println(lang2); // 会不会玩啊! 你**的
    }
}

结果：

夏天
Hello
H
5
================
97
98
99
==================
How do you do?
H*w d* y*u d*?
==================
会不会玩啊! 你**的,你**的,你**的!

5. 分割功能的方法

• public string[]split（string regex）：将此字符串按照给定的regex（规则）拆分为字符串数组。

  按照参数的规则，将字符串切分成若干部分。

  split方法的参数其实是一个“正则表达式”，如果按照英文句点.进行切分，必须写成\.

方法演示，代码如下：

public class Demo05StringSplit {

    public static void main(String[] args) {
        String str1 = "aaa,bbb,ccc";
        String[] array1 = str1.split(",");

        System.out.println(array1);  // [Ljava.lang.String;@5f150435
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }
        System.out.println("===================");

        String str2 ="aaa bbb ccc";
        String[] array2 = str2.split(" ");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
        System.out.println("===================");

        String str3 = "XXX.YYY.ZZZ";
        String[] array3 = str3.split("."); // 切割失败
        String[] array4 = str3.split("\\."); // 切割成功

        // array3.length长度为：0 说明切割失败了 array3数组里啥也没有
        System.out.println(array3.length); 
        for (int i = 0; i < array3.length; i++) {  // 无法循环
            System.out.println(array3[i]);
        }

        System.out.println(array4.length); // array4.length长度为：3
        for (int i = 0; i < array4.length; i++) {
            System.out.println(array4[i]);
        }
    }
}

结果：

[Ljava.lang.String;@5f150435
aaa
bbb
ccc
===================
aaa
bbb
ccc
===================
0
3
XXX
YYY
ZZZ

案例：拼接字符串

package cn.luis.demo2;

/*
    题目：定义一个方法，把数组{1,2,3}按照指定格式拼接成一个字符串。
    格式参照如下：[word1#word#word3]

    分析：
    1. 首先准备一个int[]数组，内容是：1,2,3
    2. 定义一个方法，用来将数组变成字符串
    三要素：
    返回值类型；String
    方法名称：fromArrayToString
    参数列表：int[]
    3. 格式：[word1#word#word3]
    用到for循环、字符串拼接、每个数组元素之间都有一个word字样，用#分隔，要区分元素是不是最后一个
    4. 调用方法，得到返回值，并打印结果字符串
 */
public class Demo06StringPractise {

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

        String result = fromArratToString(array);
        System.out.println(result);  [word1#word2#word3]
    }

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

案例：统计字符个数

package cn.luis.demo2;

import java.util.Scanner;

/*
    题目： 键盘输入一个字符，并且统计其中各种字符串出现的次数。
    种类有：大写字母、小写字母、数字、其他

    思路：
    1. 既然用到键盘输入，肯定是Scanner
    2. 键盘输入的是字符串，那么：String str = sc.next();
    3. 定义四个变量，分别代表四种字符串各自的出现次数。
    4. 需要对字符串一个字一个字检查，String--->char[],方法就是tocharArray()
    5. 遍历char[]字符数组，对当前字符的种类进行判断，并且用四个变量进行++动作。
    6. 打印输出四个变量，分别代表四中字符出现的次数。
*/
public class Demo07StringCount {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String input = sc.next();  // 获取键盘输入的一个字符串

        int countUpper = 0; // 大写字母出现次数
        int countLower = 0; // 小写字母出现次数
        int countNumber = 0; // 数字出现次数
        int countOther = 0; // 其他字符出现次数

        char[] charArray = input.toCharArray();  // 将字符串装换成为字符数组用charArray数组接收
        for (int i = 0; i < charArray.length; i++) {
            char ch = charArray[i]; // 当前单个字符
            if ('A' <= ch && ch <= 'Z') {
                countUpper++;
            } else if ('a' <= ch && ch <= 'z') {
                countLower++;
            } else if ('0' <= ch && ch <= '9') {
                countNumber++;
            } else {
                countOther++;
            }
        }

        System.out.println("大写字母出现次数：" + countUpper);
        System.out.println("小写字母出现次数：" + countUpper);
        System.out.println("数字出现次数：" + countUpper);
        System.out.println("其他字符出现次数：" + countUpper);
    }
}

结果：

请输入一个字符串：
ASDasd123,./
大写字母出现次数：3
小写字母出现次数：3
数字出现次数：3
其他字符出现次数：3

END