java String类的概述和使用

最新推荐文章于 2023-03-06 10:00:00 发布

小白迷上java

最新推荐文章于 2023-03-06 10:00:00 发布

阅读量276

点赞数

分类专栏： java基础文章标签： java string 字符串正则表达式

本文链接：https://blog.csdn.net/Junsunnyl/article/details/119769819

版权

java基础专栏收录该内容

33 篇文章 1 订阅

订阅专栏

文章目录

javaString类的概述和使用

javaString类的概述和使用

String类的概念（重点）

java.lang.String类用于描述字符串，Java程序中所有的字符串字面值都可以使用该类的对象加以描述，如：“abc”。
该类由final关键字修饰，表示该类不能被继承。
从jdk1.9开始该类的底层不使用char[]来存储数据，而是改成 byte[]加上编码标记，从而节约了一些空间。
该类描述的字符串内容是个常量不可更改，因此可以被共享使用。

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

常量池的概念（原理）

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

 		// 1.验证常量池的存在
        // 到目前为止 只有String这个特殊类除了new的方式还可以直接通过字符串进行赋值 (包装类除外）
        String s1 = "123";
        String s2 = "123";
        System.out.println(s1 == s2); 
        // true 是因为常量池的 把相同的字符串放到池中 如果有相同的字符串直接赋值常量池中的地址值
        String s3 = new String("123");
        String s4 = new String("123");
        System.out.println(s3 == s4); 
        // false new出来的 不会被Jvm放到常量值中 而是放到堆区内存里 由于对象不同 所以地址值不相同

常用的构造方法（练熟、记住）

方法声明	功能介绍
String()	使用无参方式构造对象得到空字符序列
String(byte[] bytes, int offset, int length)	使用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) {
        // 1.String类常用的构造方法
        String s1 = new String();
        // "" 表示空字符串 有对象没有内容
        // null 表示空 没有对象
        System.out.println(s1);

        System.out.println("--------------------------");
        // 2.与byte[]数组的构造方法
        // byte 数组对相应的是 字符的ASCII码值
        // byte[] byteArr = {3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; 处理结果和预期结果不相同 原因byte 数组对相应的是 字符的ASCII码值
        byte[] byteArr = {97, 98, 99, 100, 101, 102, 103, 104, 105, 106};
        String s2 = new String(byteArr, 3, 5); // 注意数组越界问题 ArrayIndexOutOfBoundsException
        String s = new String(byteArr);
        System.out.println(s2);
        System.out.println(s);
        String s5 = "3456789101112";
        System.out.println(s5);

        System.out.println("--------------------------");
        // 3.与char[]数组的构造方法
        char[] charArr = {'a', 'b', 'c', 'd', 'f', 'g', 'h', 'i', 'g', 'k', 'l'};
        String s3 = new String(charArr, 4, 3); // 注意数组越界问题 ArrayIndexOutOfBoundsException
        String s4 = new String(charArr);
        System.out.println(s3);System.out.println(s4);
    }

String构造方法常量池和构造方法的区别

    public static void main(String[] args) {
        // 1.请问下面的代码会创建几个对象？ 分别存在在什么地方
        String str1 = "hello";  // 1个对象 存放在常量池中
        String str2 = new String("hello"); // 2个对象 1个在常量池中 一个在堆区(堆区是常量池中复制出来的)

        // 2.常量有优化机制 变量没有
        String str3 = "abcd";
        String str4 = "ab" + "cd";
        System.out.println(str3 == str4); //  true 常量优化机制 "abcd"

        String str5 = "ab";
        String str6 = str5 + "cd";
        System.out.println(str6 == str3); // false 变量没有优化 所以是false
    }

常用的成员方法（练熟、记住）

方法声明	功能介绍
String toString()	返回字符串本身
byte[] getBytes()	将当前字符串内容转换为byte数组并返回
char[] toCharArray()	用于将当前字符串内容转换为char数组并返回

方法声明	功能介绍
char charAt(int index)	方法charAt用于返回字符串指定位置的字符
int length()	返回字符串字符序列的长度
boolean isEmpty()	判断字符串是否为空

方法使用

		// 1.创建String类型的对象并打印
        String str1 = new String("world");
        System.out.println(str1.toString());
        // 2.将String类型的数据转变为byte[]数组
        byte[] bytes = str1.getBytes(); // 传入的是ASCII码值 可以使用强制类型转换转换为字符串类型
        for (byte aByte : bytes) {
            System.out.print((char) aByte);
        }
        System.out.println();
        // 3.将string类型的字符串转换为 char[]数组
        char[] chars = str1.toCharArray();
        for (char aChar : chars) {
            System.out.print(aChar);
        }
        System.out.println();
        System.out.println(str1.length()); // 获取字符串长度
        System.out.println(str1.charAt(2)); // 获取指定位置的字符
        System.out.println(str1.isEmpty()); // 判断字符串是否为字符串
    }

案例题目

判断字符串“上海自来水来自海上”是否为回文并打印，所谓回文是指一个字符序列无论从左向右读还是从右向左读都是相同的句子。

	public static void main(String[] args) {
        String str1 = "上海自来水来自海上";
        // 1.第一种方法
        char[] chars = str1.toCharArray();
        // 用来记录str 和 倒置的str1 相同的数 如果 count和str.length() 相同是回文 否则不是
        int count = 0;
        // 循环遍历str1 和 chars
        for (int i = 0; i < chars.length; i++){
            // 判断 str1顺序和 chars倒置的字符是否相同
            if (chars[str1.length() -1 -i] == str1.charAt(i)) count ++;
        }
        if (count == str1.length()) System.out.println(str1 + "是回文");
        // 2.第二种方式采用对称方式
        for (int i = 0; i < str1.length() / 2 ; i++){
            if(str1.charAt(i) != str1.charAt(str1.length() - 1 - i)){
              flag = false;
              return; // 仅仅用来实现方法的结束
            }
        }
         System.out.println(str1 + " 是回文");
    }

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

方法演示

    public static void main(String[] args) {

        // 1.构造String类型的对象并打印
        String str1 = new String("hello");
        System.out.println("str1 = " + str1); // 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 str1 = new String("     Let Me Give You Some Color To See See!");
        System.out.println("str1 = " + str1); //      Let Me Give You Some Color To See See!

        // 2.实现各种成员方法的调用和测试
        boolean b1 = str1.contains("some");
        System.out.println("b1 = " + b1); // false  区分大小写
        b1 = str1.contains("Some");
        System.out.println("b1 = " + b1); // true

        System.out.println("----------------------------------------------");
        // 将所有字符串转换为大写  小写  以及去除两边的空白字符
        String str2 = str1.toUpperCase();
        System.out.println("str2 = " + str2); //    LET ME GIVE YOU SOME COLOR TO SEE SEE!
        System.out.println("str1 = " + str1); //    Let Me Give You Some Color To See See!   常量

        String str3 = str1.toLowerCase();
        System.out.println("str3 = " + str3); //    let me give you some color to see see!
        System.out.println("str1 = " + str1); //    Let Me Give You Some Color To See See!

        String str4 = str1.trim();
        System.out.println("str4 = " + str4); //Let Me Give You Some Color To See See!     奇点

        System.out.println("----------------------------------------------");
        // 判断字符串是否以...开头  以...结尾
        b1 = str1.startsWith("Let");
        System.out.println("b1 = " + b1); // false
        b1 = str1.startsWith(" ");
        System.out.println("b1 = " + b1); // true
        // 从下标5开始是否以"Let"开头
        b1 = str1.startsWith("Let", 5);
        System.out.println("b1 = " + b1); // true

        b1 = str1.endsWith("See");
        System.out.println("b1 = " + b1); // false
        b1 = str1.endsWith("See!");
        System.out.println("b1 = " + b1); // true

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

案例题目

提示用户从键盘输入用户名和密码信息，若输入”admin”和”123456”则提示“登录成功，欢迎使用”，否则提示“用户名或密码错误，您还有n次机会”，若用户输入三次后依然错误则提示“账户已冻结，请联系客服人员！”

    public static void main(String[] args) {
        // 1.设置账号和密码信息
        String usrName = "admin";
        String password = "123456";
        // 2.提示用户从键盘输入账号和密码信息并使用变量记录
        Scanner sc = new Scanner(System.in);
        boolean flag = false;
        for (int i = 0; i < 3; i++) {
            System.out.println("请输入用户名");
            String inputUserName = sc.next();
            System.out.println("请输入密码");
            String inPassword = sc.next();
            // 注意不要采用用户输入的字符信息进行调用 防止空指针异常
            // 3.判断账号和密码信息是否正确并提示还剩余几次机会
            if (usrName.equals(inputUserName.trim()) && password.equals(inPassword)) flag = true;
            if (flag) {
                System.out.println("登录成功 欢迎使用");
                // 4.输入正确直接结束方法的执行
                return;
            } else
                System.out.println("用户名和密码输入错误 请重新输入 你还有" + (2 - i) + "次机会");
        }
        // 5.输入账号和密码错误 账号冻结
        System.out.println("账号已冻结 请联系客服人员");
        // 6.关闭扫描器
        sc.close();
    }

方法声明	功能介绍
int indexOf(int ch)	用于返回当前字符串中参数ch指定的字符第一次出现的下标
int indexOf(int ch, int fromIndex)	用于从fromIndex位置开始查找ch指定的字符
int indexOf(String str)	在字符串中检索str返回其第一次出现的位置，若找不到返回-1
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位置开始反向搜索的第一次出现的下标。

注意事项

indexOf 是从左往右查找 lastIndexOf 从右往左查找

方法演示

public static void main(String[] args) {
        // 1.构造String类型的对象并打印
        String str1 = new String("Good Good Study, Day Day Up!");
        System.out.println("str1 = " + str1);

        // 2.使用字符串的指定字符和字符查找功能
        int pos = str1.indexOf('g');
        System.out.println("pos = " + pos); // -1 表示该字符串中没有该字符
        pos = str1.indexOf('G');
        System.out.println("pos = " + pos); // 0 表示该字符第一次出现的索引位置 找到之后不进行后续查找
        pos = str1.indexOf('G', 2); // 2表示从何处开始查找
        System.out.println("pos = " + pos); // 5 表示从第三个字符开始查找 该字符第一次出现的索引位置 找到之后不进行后续查找

        System.out.println("----------------------");
        // 3.使用字符串查找的指定字符串查找功能
        pos = str1.indexOf("go");
        System.out.println("pos = " + pos); // -1 表示该字符串中没有该字符
        pos = str1.indexOf("Go");
        System.out.println("pos = " + pos); // 0 表示该字符串第一次出现的索引位置 找到之后不进行后续查找
        pos = str1.indexOf("Go", 2);
        System.out.println("pos = " + pos); // 5 表示从第三个字符开始查找 该字符串第一次出现的索引位置 找到之后不进行后续查找

        System.out.println("----------------------");
        // 4.s实现字符和字符串你的反向查找
        pos = str1.lastIndexOf('G');
        System.out.println("pos = " + pos); // 5
        pos = str1.lastIndexOf('G', 2);
        System.out.println("pos = " + pos); // 0 从下标0开始 到2  索引位置最后出现的位置
        pos = str1.lastIndexOf("G");
        System.out.println("pos = " + pos);  // 5
        pos = str1.lastIndexOf("G", 6);
        System.out.println("pos = " + pos);  // 0 从下标0开始 到 6 索引位置最后出现的位置
    }

案例题目

编写通用的代码可以查询字符串"Good Good Study, Day Day Up!"中所有"Day"出现的索引位置并打印出来。

public static void main(String[] args) {
        // 1.定义一个String类型的字符串
        String str1 = new String("Good Good Study, Day Day Up!");
        // 2.查找所有Day的字符
        int index = 0; // 用来记录Day的下标
        index = str1.indexOf("Day", index);
        while (true){
            // 当查找不到的时候为 -1 跳出循环 否则执行else
            if (index == -1){
                break;
            }else {
                System.out.println("Day 出现的位置是 " + index);
                index = str1.indexOf("Day", index + 3);
            }
        }
   		// 代码优化
        while ((index = str1.indexOf("Day", index)) != -1){
            System.out.println("Day 出现的位置是 " + index);
            index = "Day".length() + index;
        }
    }

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

案例题目

提示用户从键盘输入一个字符串和一个字符，输出该字符(不含)后面的所有子字符串。

 public static void main(String[] args) {
        // 1.提示用户输入一个字符串 和 一个字符
        System.out.println("请输入字符串");
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        System.out.println("请输入不包括后面的字符");
        String str1 = sc.next();
        // 2.输出该字符后面的字符
        int index = str.indexOf(str1) + 1;
        String substring = str.substring(index);
        System.out.println(substring);
    }

正则表达式的概念（了解）

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

正则表达式的规则（了解）

正则表达式	说明
[abc]	可以出现a、b、c中任意一个字符
[^abc]	可以出现任何字符，除了a、b、c的任意字符
[a-z]	可以出现a、b、c、……、z中的任意一个字符
[a-zA-Z0-9]	可以出现a_z、AZ、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次

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

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

案例题目

使用正则表达式描述一下银行卡密码的规则：

要求是由6位数字组成。

// 银行卡密码的规则的正则表达式
String reg = “^\d{6} $^[0-9]{6}$ ”


使用正则表达式描述一下QQ号码的规则：

要求是由非0开头的5~15位数组成。
```java
// QQ号码的规则的正则表达式
String reg = "[1-9]\\d{4,15}";

使用正则表达式描述一下手机号码的规则：

要求是由1开头，第二位数是3、4、5、7、8中的一位，总共11位

// 手机号码的规则的正则表达式
String reg = "1[34578]\\d{9}";

描述身份证号码的规则：

总共18位，6位数字代表地区，4位数字代表年，2位数字代表月，2位数字代表日期， 3位数字代表个人，最后一位可能数字也可能是X。

  // 身份证号码的规则的正则表达式 小括号代表正则分组
  String reg = "(\\d{6})(\\d{4})(\\d{2})(\\d{2})(\\d{3})([0-9|X])";

方法名称	方法说明
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

方法的使用

 public static void main(String[] args) {
        // 1.定义一个字符串变量
        String str = "1001,zhangfei,30";
        // 2.按照,的方式进行切割 返回数组类型
        String[] strArr = str.split(",");
        for (String s : strArr) {
            System.out.println(s); // 1001 zhangfei 30
        }
        // 3.替换, 使用空格进行
        System.out.println(str.replace(",", " ")); // 1001 zhangfei 30
        // 4.符合正则表达式的进行替换
        String reg = "\\d+"; // 表示数字
        System.out.println(str.replaceFirst(reg,"1002")); // 1002,zhangfei,30
        System.out.println(str.replaceAll(reg,"1002")); // 1002,zhangfei,1002
    }

小白迷上java

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
java String类的概述和使用

javaString类的概述和使用String类的概念（重点）java.lang.String类用于描述字符串，Java程序中所有的字符串字面值都可以使用该类的对象加以描述，如：“abc”。该类由final关键字修饰，表示该类不能被继承。从jdk1.9开始该类的底层不使用char[]来存储数据，而是改成 byte[]加上编码标记，从而节约了一些空间。该类描述的字符串内容是个常量不可更改，因此可以被共享使用。 String str1 = “abc”; // 其中"abc"
复制链接

扫一扫