Java 字符串

迈不过友情╰ 2023-09-24 17:58 46阅读 0赞

#### 文章目录 ####

*   *  一、API
     *  二、String
     *   *  1. String 构造方法
         *  2. String 对象的特点
         *  3. 字符串的比较
         *  4. 用户登录案例
         *  5. 遍历字符串
         *  6. 统计字符次数
         *  7. 拼接字符串
         *  8. 字符串反转
     *  三、StringBuilder
     *   *  1. 构造方法
         *  2. 添加及反转方法
         *  3. 与 String 相互转换
         *  4. 拼接字符串升级版
         *  5. 字符串反转升级版

### 一、API ###

API：即应用程序编程接口。  
Java API：指的就是 JDK 中提供的各种功能的 Java 类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些 API 如何使用。

[jdk11 API 帮助文档中文版下载步骤！][jdk11 API]

### 二、String ###

String 类在 java.lang 包下，所以使用的时候不需要导包。  
String 类代表字符串，Java 程序中的所有字符串文字（例如 “abc”）都被实现为此类的实例，也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。

> 字符串的特点：  
> ① 字符串是不可变的，它们的值在创建后不能被更改；  
> ② 虽然String 的值是不可变的，但是它们可以被共享；  
> ③ 字符串效果上相当于字符数组，但是底层原理是字节数组。

#### 1. String 构造方法 ####

![在这里插入图片描述][da773d96c60042d0b84d884f18a6b080.png]

//1.创建一个空白字符串对象，不含任何内容
    String s1 = new String();
    //2.根据字符数组的内容，来创建字符串对象
    char[] chs = {
        'a', 'b', 'c'};
    String s2 = new String(chs);
    System.out.println(s2); //abc
    //3.根据字节数组的内容，来创建字符串对象
    byte[] bys = {
        97, 98, 99};
    String s3 = new String(bys);
    System.out.println(s3); //abc
    //4.直接赋值的方式创建字符串对象
    String s4 = "abc";
    System.out.println(s4); //abc

> s3 的输出结果为什么是 abc 呢？  
> ASCLL码，数字的 97、98、99 依次对应字符的 a、b、c。

`推荐使用直接赋值的方式得到字符串！`

#### 2. String 对象的特点 ####

（1）通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值是不同的；

（2）以双引号的方式给出的字符串，只要字符序列相同（顺序及大小写），无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中进行维护。

#### 3. 字符串的比较 ####

> 使用 == 做比较：  
> 对于基本类型，比较的是数据值是否相同；  
> 对于引用类型，比较的是地址值是否相同。

而我们的字符串是一个类，所以它的对象做等号比较的时候比较的也是地址值是否相同，我们如果想要比较字符串的内容是否相同，又该怎么做呢？

字符串是对象，它比较内容是否相同，是通过一个方法来实现的，这个方法叫 **equals()**。  
public boolean equals(Object anObject)：将此字符串与指定对象进行比较，由于我们比较的是字符串对象，所以参数直接传递一个字符串

//比较地址是否相同
    System.out.println(s1 == s2); //false
    //比较内容是否相同
    System.out.println(s1.equals(s2)); //true

#### 4. 用户登录案例 ####

需求：已知用户名和密码，请用程序实现模拟用户登录，总共有三次机会，登录之后给出相应提示。

思路：  
① 已知用户名和密码，定义两个字符串表示即可；  
② 键盘录入要登录的用户名和密码，用 Scanner 实现；  
③ 拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示，对于字符串内容的比较，用 equals() 方法实现；  
④ 用循环实现多次机会，这里的次数明确，采用 for 循环实现，并在登录成功的时候，使用 break 结束循环。

package com.zxe;
    
    import java.util.Scanner;
    
    public class login {
        
        public static void main(String[] args) {
        
            String username = "tyut520";
            String password = "123456";
            Scanner sc = new Scanner(System.in);
            for (int i = 0; i < 3; i++) {
        
                System.out.println("请输入用户名：");
                String name = sc.nextLine();
                System.out.println("请输入密码：");
                String pwd = sc.nextLine();
                if (name.equals(username) && pwd.equals(password)) {
        
                    System.out.println("登录成功！");
                    break;
                } else {
        
                    if (i == 2) {
        
                        System.out.println("您的账号已锁定！");
                    } else {
        
                        System.out.println("登录失败，您还有" + (2 - i) + "次机会！");
                    }
                }
            }
        }
    }

![在这里插入图片描述][ce5c209120354a1bbf6cea8660a8f4e7.png]

#### 5. 遍历字符串 ####

//遍历字符串的通用格式
    for (int i = 0; i < s.length(); i++) {
        
        System.out.print(s.charAt(i)); //输出指定索引处的字符值
    }

`charAt() 方法返回指定索引处的 char 值，数组名.length 返回数组的长度，字符串对象.length() 返回字符串的长度！`

#### 6. 统计字符次数 ####

需求：键盘录入一个字符串，统计该字符中大写字母字符、小写字母字符、数字字符出现的次数。

package com.zxe;
    
    import java.util.Scanner;
    
    public class login {
        
        public static void main(String[] args) {
        
            int bigCount = 0;
            int smallCount = 0;
            int numberCount = 0;
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个字符串：");
            String s = sc.nextLine();
            for (int i = 0; i < s.length(); i++) {
        
                char ch = s.charAt(i);
                if (ch >= 'A' && ch <= 'Z') {
        
                    bigCount++;
                } else if (ch >= 'a' && ch <= 'z') {
        
                    smallCount++;
                } else if (ch >= '0' && ch <= '9') {
        
                    numberCount++;
                }
            }
            System.out.println("大写字母有" + bigCount + "个！");
            System.out.println("小写字母有" + smallCount + "个！");
            System.out.println("数字有" + numberCount + "个！");
        }
    }

![在这里插入图片描述][48b614c317674037b29ef936a538e0e3.png]

#### 7. 拼接字符串 ####

需求：定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。

package com.zxe;
    
    import java.util.Arrays;
    import java.util.Scanner;
    
    public class login {
        
        public static void main(String[] args) {
        
            Scanner sc = new Scanner(System.in);
            String[] str;
            System.out.println("请输入一组整数，以逗号分隔：");
            str = sc.nextLine().split(",");
            int[] arr = new int[str.length];
            for (int i = 0; i < arr.length; i++) {
        
                arr[i] = Integer.valueOf(str[i]);
            }
            /*
            以数组的格式打印数组
            System.out.println(Arrays.toString(arr));
            */
            String result = together(arr);
            System.out.println(result);
        }
        public static String together(int[] arr) {
        
            String s = "<";
            for (int i = 0; i < arr.length; i++) {
        
                s += arr[i];
                if (i == arr.length - 1) {
        
                    s += ">";
                } else {
        
                    s += ", ";
                }
            }
            return s;
        }
    }

![在这里插入图片描述][a973205394e14ce0805253a043290f4d.png]

> java 中可以直接输入字符串数组，但是输入 int\[\] 数组时需要事先定义长度，但有些题目中的长度是可变的，不能事先固定数组长度。首先输入字符串的数组，中间用逗号分隔，然后获取字符串长度，作为 int\[\] 初始数组的长度，再将 String 字符串数组转化为 int 数组。

#### 8. 字符串反转 ####

需求：定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果。

package com.zxe;
    
    import java.util.Arrays;
    import java.util.Scanner;
    
    public class ReverseTest {
        
        public static void main(String[] args) {
        
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个字符串：");
            String s = sc.nextLine();
            String result;
            result = reverse(s);
            System.out.println(result);
        }
        public static String reverse(String s) {
        
            String ss = "";
            for (int i = s.length() - 1; i >= 0; i--) {
        
                ss += s.charAt(i);
            }
            return ss;
        }
    }

### 三、StringBuilder ###

如果对字符串进行拼接操作，每次拼接，都会构建一个新的 String 对象，既耗时，又浪费内存，而这种操作还不可避免。  
那么有没有一种比较好的方式可以解决这个问题呢？答案是肯定的，我们可以通过 Java 提供的 StringBuilder 类来解决这个问题。

StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的。

`String 内容不可变，而StringBuilder 内容是可变的！`

#### 1. 构造方法 ####

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public StringBuilder()</td> 
   <td>创建一个空白可变字符串对象，不含任何内容</td> 
  </tr> 
  <tr> 
   <td>public StringBuilder(String str)</td> 
   <td>根据字符串的内容，来创建可变字符串对象</td> 
  </tr> 
 </tbody> 
</table>

StringBuilder sb = new StringBuilder("hello");
    System.out.println(sb); //hello
    System.out.println(sb.length()); //5

#### 2. 添加及反转方法 ####

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public StringBuilder append(任意类型)</td> 
   <td>添加数据，并返回对象本身</td> 
  </tr> 
  <tr> 
   <td>public StringBuilder reverse()</td> 
   <td>返回相反的字符序列</td> 
  </tr> 
 </tbody> 
</table>

StringBuilder sb = new StringBuilder();
    StringBuilder sb2 = sb.append("hello");
    System.out.println(sb); //hello
    System.out.println(sb2); //hello
    System.out.println(sb == sb2); //true

`sb 和 sb2 是同一个对象！`

因为返回的是对象本身，且可以传任意类型的数据，所以这里我们就不需要再用 StringBuilder 来接收了。

StringBuilder sb = new StringBuilder();
    sb.append("hello");
    sb.append("world");
    sb.append("java");
    sb.append(99);
    System.out.println(sb); //helloworldjava99
    
    //也可以使用链式编程
    sb.append("hello").append("world").append("java").append(99);
    System.out.println(sb); //helloworldjava99

StringBuilder sb = new StringBuilder("hello");
    sb.reverse(); //olleh

#### 3. 与 String 相互转换 ####

//1.StringBuilder转换为String，toString()
    StringBuilder sb = new StringBuilder();
    sb.append("hello");
    String s = sb.toString(); 
    
    //2.String转换为StringBuilder，构造方法
    String s = "hello";
    StringBuilder sb = new StringBuilder(s);

#### 4. 拼接字符串升级版 ####

在方法中用 StringBuilder 进行拼接，并把结果转换成 String 类型返回。

package com.zxe;
    
    import java.util.Arrays;
    import java.util.Scanner;
    
    public class Test {
        
        public static void main(String[] args) {
        
            int[] arr = {
        1, 2, 3};
            String result = arrToString(arr);
            System.out.println(result);
        }
        public static String arrToString(int[] arr) {
        
            StringBuilder sb = new StringBuilder();
            sb.append("<");
            for (int i = 0; i < arr.length; i++) {
        
                if (i == arr.length - 1) {
        
                    sb.append(arr[i]);
                } else {
        
                    sb.append(arr[i]).append(", ");
                }
            }
            sb.append(">");
            String s = sb.toString();
            return s;
        }
    }

![在这里插入图片描述][eb845ebdd4fb476ba44b7e79b3e94322.png]

#### 5. 字符串反转升级版 ####

在方法中用 StringBuilder 实现字符串的反转，并把结果转换成 String 返回。

package com.zxe;
    
    import java.util.Arrays;
    import java.util.Scanner;
    
    public class Test {
        
        public static void main(String[] args) {
        
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个字符串：");
            String str = sc.nextLine();
            String result = reverse(str);
            System.out.println(result);
        }
    
        public static String reverse(String s) {
        
            StringBuilder sb = new StringBuilder(s);
            sb.reverse();
            String ss = sb.toString();
            return ss;
        }
    }

[jdk11 API]: https://blog.csdn.net/m0_52861684/article/details/129007290?spm=1001.2014.3001.5501
[da773d96c60042d0b84d884f18a6b080.png]: https://img-blog.csdnimg.cn/da773d96c60042d0b84d884f18a6b080.png
[ce5c209120354a1bbf6cea8660a8f4e7.png]: https://img-blog.csdnimg.cn/ce5c209120354a1bbf6cea8660a8f4e7.png
[48b614c317674037b29ef936a538e0e3.png]: https://img-blog.csdnimg.cn/48b614c317674037b29ef936a538e0e3.png
[a973205394e14ce0805253a043290f4d.png]: https://img-blog.csdnimg.cn/a973205394e14ce0805253a043290f4d.png
[eb845ebdd4fb476ba44b7e79b3e94322.png]: https://img-blog.csdnimg.cn/eb845ebdd4fb476ba44b7e79b3e94322.png