JAVA核心类库(上)_String类的概述和使用

1.1String类的概念

• java.lang.String类用于描述字符串，java程序中所有的字符串字面值都可以使用该类的对象加以描述。

• 该类由final关键字修饰，表示该类不可以继承。

• 从jdk1.9开始该类底层不使用charr[]来存储数据，而是改byte[]加上编码标记，从而节约了一些空间。

• 该类描述的字符串内容是个常量不可更改，因此可以被共享使用。

String str1 = “abc”; - 其中"abc"这个字符串是个常量不可改变。 str1 = “123”; - 将“123”字符串的地址赋值给变量str1。 - 改变str1的指向并没有改变指向的内容

1.2 常量池的概念(原理)

由于String类描述的字符串内容是常量不可改变，因此Java虚拟机将首次出现的字符串放入常量池中，若后续代码中出现了相同字符串内容则直接使用池中已有的字符串对象而无需申请内存及创建对象，从而提高了性能。

1.3常用的构造方法

方法声明	功能介绍
String()	使用无参方式构造对象得到空字符序列
String(byte[] bytes, int offset, intlength)	使用bytes数组中下标从offset位置开始的length个字节来构造对象
String(byte[] bytes)	使用bytes数组中的所有内容构造对象
String(char[] value, int offset, int count)	使用value数组中下标从offset位置开始的count个字符来构造对象
String(char[] value)	使用value数组中的所有内容构造对象
String(String original)	根据参数指定的字符串内容来构造对象，新创建对象为参数对象的副本

//代码示例 验证常量池的存在
public static void main(String[] args) {
       
        String str1 = "abc";
        String str2 = "abc";
        System.out.println(str1 == str2);  //比较地址，结果为true
    }

---

public static void main(String[] args) {
        //1.使用无参方式构造对象
        String str1 = new String();
        // "" 表示空字符串对象，有对象只是里面没有内容
        // null 表示空，连对象都没有
        System.out.println(str1);
​
        // 2.使用参数指定的byte数组来构造对象并打印
        byte[] bArr = {97, 98, 99, 100, 101};
        String str2 = new String(bArr,1,3); //从下标1开始的3个字节长度来构造对象
        // 使用字节数组中的一部分内容来构造对象，表示使用数组bArr中下标从1开始的3个字节构造字符串对象
        // 构造字符串的思路：就是先将每个整数翻译成对应的字符，再将所有的字符串起来。
        // 98 - 'b'   99 - 'c'  100 - 'd'   => bcd
        System.out.println(str2);  //bcd
​
        //使用整个字节数组来构造对象
        String str3 = new String(bArr);
        System.out.println(str3);  //abcde
        // 3.使用字符数组来构造字符串对象
        char[] cArr = {'h', 'e', 'l', 'l', 'o'};
        // 使用字符数组中的一部分内容来构造对象
        // 思路：直接将字符串起来
        String str4 = new String(cArr,1,3); //ell
        System.out.println(str4);
​
        // 使用整个字符数组来构造对象
        String str5 = new String(cArr);
        System.out.println("str5 = " + str5); // hello
​
        // 4.使用字符串来构造字符串对象
        String str6 = new String(cArr);
        System.out.println(str6);
    }

1.4 成员方法

方法声明	功能介绍
String toString()	返回字符串本身
byte[] getBytes()	将当前字符串内容转换为byte数组并返回
char[] toCharArray()	用于将当前字符串内容转换为char数组并返回
char charAt(int index)	方法charAt用于返回字符串指定位置的字符
int length()	返回字符串字符序列的长度
boolean isEmpty()	判断字符串是否为空

public static void main(String[] args) {
        //1.构造String对象并打印
        String str = new String("hello");
        //2.获取字符的长度和每个字符并打印
        System.out.println("字符的长度是："+str.length());
        for(int i=0;i<str.length();i++){
            System.out.println("下标为"+i+"的字符是"+str.charAt(i));
        }
​
        // 3.判断字符串是否为空
        System.out.println(str.isEmpty());
        System.out.println(0 == str.length());
        
    }

---

public static void main(String[] args) {
        //1.创建String类型的对象
        String str = new String("world");
        // 2.实现将String类型转换为byte数组类型并打印
        // 思路：先将字符串拆分为字符，将再每个字符转换为byte类型，也就是获取所有字符的ASCII
        byte[] bArr = str.getBytes();
        for(int i =0;i<bArr.length;i++){
            System.out.println(bArr[i]);
        }
        // 将byte数组转回String类型并打印
        String str2 = new String(bArr);
        System.out.println(str2);
​
        // 3.实现将String类型转换为char数组类型并打印
        // 思路：将字符串拆分为字符并保存到数组中
        char[] cArr = str.toCharArray();
        for(int i =0;i<cArr.length;i++){
            System.out.println(cArr[i]);
        }
    }

---

方法声明	功能介绍
int compareTo(String anotherString)	用于比较调用对象和参数对象的大小关系
int compareToIgnoreCase(String str)	不考虑大小写，也就是'a'和'A'是相等的关系

public static void main(String[] args) {
        // 1.构造String类型的对象并打印
        String str1 = new String("hello");
        // 2.使用构造好的对象与其它字符串对象之间比较大小并打印
        System.out.println(str1.compareTo("world"));  // 'h' - 'w' => 104 - 119 => -15
        System.out.println(str1.compareTo("haha"));   // 'e' - 'a' => 101 - 97  => 4
        System.out.println(str1.compareTo("hehe"));   // 'l' - 'h' => 108 - 104 => 4
        System.out.println(str1.compareTo("heihei")); // 'l' - 'i' => 108 - 105 => 3
        System.out.println(str1.compareTo("helloworld")); // 长度： 5 - 10 => -5
        System.out.println(str1.compareToIgnoreCase("HELLO")); // 0
    }

---

方法声明	功能介绍
String concat(String str)	用于实现字符串的拼接
boolean contains(CharSequence s)	用于判断当前字符串是否包含参数指定的内容
String toLowerCase()	返回字符串的小写形式
String toUpperCase()	返回字符串的大写形式
String trim()	返回去掉前导和后继空白的字符串
boolean startsWith(String prefix)	判断字符串是否以参数字符串开头
boolean startsWith(String prefix, int toffset)	从指定位置开始是否以参数字符串开头
boolean endsWith(String suffix)	判断字符串是否以参数字符串结尾

public static void main(String[] args) {
        //1.构造String类型的对象并打印
        String str = new String("     Let Me Give You Some Color To See See!");
        boolean b = str.contains("some");
        System.out.println(b);  //false  区分大小写
        b = str.contains("Some");
        System.out.println(b);
​
        // 将所有字符串转换为大写  小写  以及去除两边的空白字符
        String str1 = str.toUpperCase();
        System.out.println(str1);
        str1 = str.toLowerCase();
        System.out.println(str1);
        str1 = str.trim();
        System.out.println(str1);
​
        // 判断字符串是否以...开头  以...结尾
        System.out.println(str.startsWith("Let"));  //false
        System.out.println(str.startsWith(" "));  //true
​
​
        // 从下标5开始是否以"Let"开头
        boolean b1 = str1.startsWith("Let", 5);
        System.out.println("b1 = " + b1); //
​
        b1 = str1.endsWith("See");
        System.out.println("b1 = " + b1); // false
        b1 = str1.endsWith("See!");
        System.out.println("b1 = " + b1); // true
​
        //字符串拼接  推荐使用+
        String str3 = str.concat(str1);
        System.out.println(str3);
    }

方法声明	功能介绍
boolean equals(Object anObject)	用于比较字符串内容是否相等并返回
int hashCode()	获取调用对象的哈希码值
boolean equalsIgnoreCase(String anotherString)	用于比较字符串内容是否相等并返回，不考虑大小写， 如：'A'和'a'是相等

---

方法声明	功能介绍
int indexOf(int ch)	用于返回当前字符串中参数ch指定的字符第一次出现的 下标
int indexOf(int ch, int fromIndex)	用于从fromIndex位置开始查找ch指定的字符
int indexOf(String str, int fromIndex)	表示从字符串的fromIndex位置开始检索str第一次出现 的位置
int lastIndexOf(int ch)	用于返回参数ch指定的字符最后一次出现的下标
int lastIndexOf(int ch, int fromIndex)	用于从fromIndex位置开始查找ch指定字符出现的下标
int lastIndexOf(String str)	返回str指定字符串最后一次出现的下标
int lastIndexOf(String str, int fromIndex)	用于从fromIndex位置开始反向搜索的第一次出现的下 标。

public static void main(String[] args) {
        // 1.构造String类型的对象并打印
        String str = new String("Good Good Study, Day Day Up!");
        // 2.实现字符串中指定字符和字符串的查找功能
        int pos = str.indexOf('g');
        System.out.println(pos);  // -1  代表查找失败
​
        pos = str.indexOf('G');
        System.out.println("pos = " + pos); // 0   该字符第一次出现的索引位置
​
        // 表示从下标0开始查找字符'G'第一次出现的索引位置，包含0
        pos = str.indexOf('G',0);
        System.out.println(pos);
        pos = str.indexOf('G', 1);
        System.out.println("pos = " + pos); // 5
​
        // 查找字符串
        pos = str.indexOf("day");
        System.out.println(pos); // -1
​
        pos = str.indexOf("Day");
        System.out.println("pos = " + pos); // 17   字符串中第一个字符的下标
        pos = str.indexOf("Day", 17);
        System.out.println("pos = " + pos); // 17   字符串中第一个字符的下标
        pos = str.indexOf("Day", 18);
        System.out.println("pos = " + pos); // 21   字符串中第一个字符的下标
​
        // 编写通用代码实现将字符串str中所有"Day"出现的索引位置找到并打印出来
        pos = 0;
        while ((pos = str.indexOf("Day",pos))!=-1){
            System.out.println(pos);
            pos+= "Day".length();
        }
​
        //3.实现字符和字符串内容的反向查找
        pos = str.lastIndexOf('G');
        System.out.println("pos = " + pos); // 5
        // 从下标5的位置开始反向查找
        pos = str.lastIndexOf('G', 5);
        System.out.println("pos = " + pos); // 5
​
        pos = str.lastIndexOf('G', 6);
        System.out.println("pos = " + pos); // 5
​
        pos = str.lastIndexOf('G', 4);
        System.out.println("pos = " + pos); // 0
​
        System.out.println("------------------------------------------------------");
        pos = str.lastIndexOf("Day");
        System.out.println("pos = " + pos); // 21
        pos = str.lastIndexOf("Day",  21);
        System.out.println("pos = " + pos); // 21
        pos = str.lastIndexOf("Day", 20);
        System.out.println("pos = " + pos); // 17
        pos = str.lastIndexOf("Day", 15);
        System.out.println("pos = " + pos); // -1
    }

方法声明	功能介绍
String substring(int beginIndex, int endIndex)	返回字符串中从下标beginIndex（包括）开始到endIndex（不包括）结束的子字符串
String substring(intbeginIndex)	返回字符串中从下标beginIndex（包括）开始到字符串结尾的子字符串

 public static void main(String[] args) {
​
        // 1.构造String类型的对象并打印
        String str1 = new String("Happy Wife, Happy Life!");
        System.out.println("str1 = " + str1); // Happy Wife, Happy Life!
​
        // 2.获取字符串中的一部分内容并打印
        // 表示从当前字符串中下标12开始获取子字符串
        String str2 = str1.substring(12);
        System.out.println("str2 = " + str2); // Happy Life!
        // 可以取到6但是取不到10
        String str3 = str1.substring(6, 10);
        System.out.println("str3 = " + str3); // Wife
​
        System.out.println("---------------------------------------------------------");
        // 3.获取输入字符串中从输入字符起的子字符串内容
        System.out.println("请输入一个字符串：");
        Scanner sc = new Scanner(System.in);
        String str4 = sc.next();
        System.out.println("请输入一个字符：");
        String str5 = sc.next();
        // 从str4中查找str5第一次出现的索引位置
        int pos = str4.indexOf(str5);
        System.out.println("pos = " + pos);
        // 根据该位置获取子字符串
        String str6 = str4.substring(pos+1);
        System.out.println("获取到的子字符串是：" + str6);
    }

1.5 正则表达式

正则表达式本质就是一个“规则字符串”，可以用于对字符串数据的格式进行验证，以及匹配、查 找、替换等操作。该字符串通常使用^运算符作为开头标志，使用$运算符作为结尾标志，当然也可以省 略 。

1.6正则表达式规则

正则表达式	说明
[abc]	可以出现a、b、c中任意一个字符
[^abc]	可以出现任何字符，除了a、b、c的任意字符
[a-z]	可以出现a、b、c、……、z中的任意一个字符
[a-zA-Z0-9]	可以出现a~z、A~Z、0~9中任意一个字符

正则表达式	说明
.	任意一个字符（通常不包含换行符）
\d	任意一个数字字符，相当于[0-9]
\D	任意一个非数字字符
\s	空白字符，相当于[\t\n\x0B\f\r]
\S	非空白字符
\w	任意一个单词字符，相当于[a-zA-Z_0-9]
\W	任意一个非单词字符

 

正则表达式	说明
X?	表示X可以出现一次或一次也没有，也就是0 ~ 1次
X*	表示X可以出现零次或多次，也就是0 ~ n次
X+	表示X可以出现一次或多次，也就是1 ~ n次
X{n}	表示X可以出现恰好 n 次
X{n，}	表示X可以出现至少 n 次，也就是>=n次
X{n，m}	表示X可以出现至少 n 次，但是不超过 m 次，也就是>=n并且<=m次

12.7 正则表达式相关的方法（熟悉）

方法名称	方法说明
boolean matches(String regex)	判断当前正在调用的字符串是否匹配参数指定的正则表达式规 则

 

方法名称	方法说明
String[] split(String regex)	参数regex为正则表达式，以regex所表示的字符串为分隔 符，将字符串拆分成字符串数组
String replace(char oldChar, char newChar)	使用参数newChar替换此字符串中出现的所有参数 oldChar
String replaceFirst(String regex, String replacement)	替换此字符串匹配给定的正则表达式的第一个子字符串
String replaceAll(String regex, String replacement)	将字符串中匹配正则表达式regex的字符串替换成 replacement

  // 1.准备一个字符串对象并打印
        String str1 = "1001,zhangfei,30";
        System.out.println("str1 = " + str1); // 1001,zhangfei,30
        // 2.按照逗号对字符串内容进行切割
        String[] sArr = str1.split(",");
        for (int i = 0; i < sArr.length; i++) {
            System.out.println("下标为" + i + "的字符串是：" + sArr[i]); // 1001 zhangfei 30
        }
​
        System.out.println("--------------------------------------------------------------");
        // 3.准备一个字符串内容并进行替换
        String str2 = "我的小名叫大帅哥";
        // 将字符串中所有的字符'我'替换为'你'
        String str3 = str2.replace('我', '你');
        System.out.println("str2 = " + str2); // 我的小名叫大帅哥
        System.out.println("str3 = " + str3); // 你的小名叫大帅哥
        // 将字符串中所有的字符'大'替换为'小'
        String str4 = str3.replace('大', '小');
        System.out.println("str4 = " + str4); // 你的小名叫小帅哥
        // 将字符串中所有的字符'小'替换为'大'
        String str5 = str4.replace('小', '大');
        System.out.println("str5 = " + str5); // 你的大名叫大帅哥
​
        System.out.println("--------------------------------------------------------------");
        // 4.准备一个字符串进行字符串内容的替换
        String str6 = "123abc456def789ghi";
        // 将第一个数字字符串替换为"#"
        String str7 = str6.replaceFirst("\\d+", "#");
        System.out.println("替换第一个字符串后的结果是：" + str7); // #abc456def789ghi
        // 将所有字母字符串替换为"$$$"
        String str8 = str7.replaceAll("[a-z]+", "A");
        System.out.println("str8 = " + str8); // #A456A789A

public static void main(String[] args) {
​
        // 1.请问下面的代码会创建几个对象？分别存放在什么地方？
        //String str1 = "hello";  // 1个对象  存放在常量池中
        //String str1 = new String("helo"); // 2个对象  1个在常量池中，1个在堆区
​
        // 2.常量池和堆区对象的比较
        String str1 = "hello";  // 常量池
        String str2 = "hello";  // 常量池
        String str3 = new String("hello"); // 堆区
        String str4 = new String("hello"); // 堆区
​
        System.out.println(str1 == str2);       // 比较地址  true
        System.out.println(str1.equals(str2));  // 比较内容  true
        System.out.println(str3 == str4);       // 比较地址  false
        System.out.println(str3.equals(str4));  // 比较内容  true
        System.out.println(str2 == str4);       // 比较地址  false
        System.out.println(str2.equals(str4));  // 比较内容 true
​
        System.out.println("------------------------------------------------------------");
        // 3.常量有优化机制，变量没有
        String str5 = "abcd";
        String str6 = "ab" + "cd";  // 常量优化机制  "abcd"
        System.out.println(str5 == str6); // 比较地址  true
​
        String str7 = "ab";
        String str8 = str7 + "cd"; // 没有常量优化
        System.out.println(str5 == str8); // 比较地址 false
​
​
    }