Java 字符串（笔记）

Binary Stars System

已于 2022-04-02 18:42:17 修改

阅读量218

点赞数

文章标签： java 开发语言蓝桥杯

于 2022-03-17 22:49:15 首次发布

本文链接：https://blog.csdn.net/J_ioi/article/details/123426014

版权

1. API 115

API:应用程序编程接口

2. String

1.概述

2.构造方法

3.特点

4.字符串的比较

案例：

package myself_02;

import java.util.Scanner;

public class YongHuDengLu {
    public static void main(String[] args){
        /*
        需求：已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示
        思路：
        ①已知用户名和密码，定义两个字符申表示即可
        ②键盘录入要登录的用户名和密码，用Scanner 实现
        ③拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。字符串的内容比较，用equals()方法实现
        ④用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环
         */
        //①已知用户名和密码，定义两个字符申表示即可
        String Y1 = "彭于晏";  //用户名
        String M1 = "123456789";    //密码
        for(int i=1;i<=3;i++){
            //②键盘录入要登录的用户名和密码，用Scanner 实现
            //创建Scanner对象
            Scanner sc = new Scanner(System.in);

            System.out.print("输入用户名：");
            String y1 = sc.nextLine();   //输入用户名

            System.out.print("输入密码：");
            String m1 = sc.nextLine();       //输入密码

            if(Y1.equals(y1) && M1.equals(m1)){
                System.out.println("登录成功");
                break;
            }
            else{
                if(3-i==0){
                    System.out.println("你的账户被锁定，请与管理员联系");
                }
                else{
                    System.out.println("输入错误，你还有" + (3 - i) + "机会");
                }
            }
        }
    }
}

案例：遍历字符串

package myself_02;

import java.util.Scanner;

public class YongHuDengLu {
    public static void main(String[] args){
        /*
        需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串
        思路：
        ①键盘录入一个字符串，用Scanner实现
        ②历字符串，首先要能够获取到字符串中的每—个字符
        public char charAt(int index)：返回指定索引处的char值，字符串的索引也是从0开始的
        遍历字符串，其次要能够获取到字符串的长度

        public int length()：返回此字符串的长度
        数组的长度：数组名.length
        字符串的长度：字符串对象length()
        遍历字符串的通用格式
        for (int i=0; i<s.length0);i++){
            s.charAt (i);   //就是指定索引处的字符值
        }
         */
        //键盘录入字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        //遍历字符串，获取字符串长度  line.length()
        System.out.println(line.length());

        //遍历字符串
        for(int i=0;i<line.length();i++){
            System.out.println(line.charAt(i));
        }
    }
}

案例：统计字符次数

import java.util.Scanner;

public class YongHuDengLu {
    public static void main(String[] args){
        /*
        需求：键盘录入一个字符申，统计该字符申中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符
        思路：
        ① 键盘录入一个字符串，用Scanner 实现
        ② 要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
        ③遍历字符串，得到每一个字符
        ④ 判断该字符属于哪种类型，然后对应类型的統计变量+1
        假如ch是一个字符，我要判断它属于大写字母，小写字母，还是数字，直接判断该字符是否在对应的范围即可
        •大写字母：ch>='A'&&ch<='z'
        • 小写宇母：ch>='a'&&ch<='z
        •数字：ch>= '0' && ch<='9'
        ⑤ 输出三种类型的字符个数

         */
        //① 键盘录入一个字符串，用Scanner 实现
        System.out.print("请输入一个字符串:");
        //创建Scanner对象
        Scanner input = new Scanner(System.in);
         String line = input.nextLine();
         int capital = 0;
         int lower = 0;
         int digit = 0;
         for(int i=0;i<line.length();i++){
             char ch = line.charAt(i);
             if(ch>='A' && ch <='Z'){
                 capital++;
             }
             else if(ch>='a' && ch <= 'z'){
                 lower++;
             }
             else if(ch>='0' && ch<='9'){
                 digit++;
             }
         }
         System.out.println("数字：" + digit);
        System.out.println("大写字母：" + capital);
        System.out.println("小写字母：" + lower);
    }
}

案例：字符串拼接

public class YongHuDengLu {
    public static void main(String[] args){
        /*
        需求：定义一个方法，把int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。例如，数组为 int[] arr ={1,2,3};
        执行方法后的输出结果为：[1,2,3]
        思路：
        ① 定义一个int 类型的数组，用静态初始化完成数组元素的初始化
        ②定义一个方法，用于把 int数组中的数据按照指定格式拼接成一个字符串返回。返回值类型 String,参数列表 int[] arr
        ③ 在方法中遍历数组，按照要求进行拼接
        ④ 调用方法，用一个变量接收结果
        ⑤ 输出结果

         */
        int[] arr = {1,2,3};
        String string = arrayToString(arr);
        //输出结果
        System.out.println("string:" + string);


    }
    public static String arrayToString(int[] arr){
        String string = "";        //初定义 string
        string += "[";

        for(int i=0; i<arr.length; i++){
            if(i != arr.length-1){
                string += arr[i];
                string += ", ";
            }
            else{
                string += arr[i];
            }
        }

        string += "]";
        return string;
    }

}

案例：字符串反转

import java.util.Scanner;
public class ziFuChuanFanZhuan {
    public static void main(String[] args){
        /*
        需求：定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果
        例如，键盘录入abc，输出结果 cba
        思路：
        ①键盘录入一个字符串，用Scanner实现
        ②定义一个方法，实现字符串反转。返回值类型 String，参数String s
        ③在方法中把字符串倒看遍历，然后把每一个得到的字符拼接成一个字符串并返回
        ④调用方法，用一个变量接收结果
        ⑤输出结果
         */
        //①键盘录入一个字符串，用Scanner实现
        //创建Scanner对象
        Scanner input = new Scanner(System.in);
        System.out.print("请输入字符串：");
        String line = input.nextLine();
        // ④调用方法，用一个变量接收结果
        String s = reverse(line);
        //⑤输出结果
        System.out.println("s : " + s);
    }
    //②定义一个方法，实现字符串反转。返回值类型 String，参数String s (在方法中把字符串倒着遍历，然后把每一个得到的字符拼成一个字符串并返回）
    public static String reverse(String s){
        String ss = "";
        for(int i=s.length() - 1; i >= 0 ;i--){
            ss += s.charAt(i);
        }
        return ss;
    }


}

3. StringBuilder（字符串拼接）

（1）StringBuiler 和 String的比较

String :内容不可变

StringBuilder 对象中的内容是可变的

（2）StringBuiler构造方法

（3）字符串的添加和反转

/*
字符串的添加：
public StringBuilder append(任意类型)        //添加类型，并返回对象本身
*/
//创建StringBuilder的对象sb
StringBuiler sb = new StringBuiler();
//链式编程
sb.append("hello").append("World").append("Java");





/*
字符串的反转
public StringBuilder reverse()            //返回相反的字符序列
*/
sb.reverse();

（4）StringBuiler 和 String 相互转换


/*  StringBuiler 转换为 String :

//创建StringBuiler的对象sb
StringBuiler sb = new StringBuiler();

//创建s 接收转换后的 sb
String s = sb.toString();

*/



/*  String 转换为 StringBuiler：


String s = "hello";
StringBuiler sb = new StringBuiler(s);
System.out.println(sb);

*/

案例：字符串拼接

//字符串拼接（升级版）
package myself_02;
import java.util.Scanner;
public class ziFuChuanFanZhuan {
    public static void main(String[] args) {
        /*
        需求：定义一个方法，把int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。例如，数组为 int[] arr ={1,2,3};
        执行方法后的输出结果为：[1,2,3]
        思路：
        ① 定义一个int 类型的数组，用静态初始化完成数组元素的初始化
        ②定义一个方法，用于把 int数组中的数据按照指定格式拼接成一个字符串返回。返回值类型 String,参数列表 int[] arr
        ③ 在方法中遍历数组，按照要求进行拼接
        ④ 调用方法，用一个变量接收结果
        ⑤ 输出结果

         */
        int[] arr = {1,2,3};
        //定义一个变量接收方法
        String s = arrayToString(arr);
        //输出结果
        System.out.println("s : " + s);


    }
    public static String arrayToString(int[] arr){
        //创建StringBuilder对象sb
        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("]");
        //定义s ,接收sb 的 StringBuilder 转化为 String
        String s = sb.toString();
        return s;
    }

}

案例：字符串反转

import java.util.Scanner;
public class ziFuChuanFanZhuan {
    public static void main(String[] args) {
        /*
        需求：定义一个方法，实现字符串反转。键盘录入一个字符串，调用该方法后，在控制台输出结果
        例如，键盘录入abc，输出结果 cba
        思路：
        ①键盘录入一个字符串，用Scanner实现
        ②定义一个方法，实现字符串反转。返回值类型 String，参数String s
        ③在方法中用StringBuilder实现字符串的反转，并把结果转成String返回
        ④调用方法，用一个变量接收结果
        ⑤输出结果
         */
        //键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入一个字符串 ： ");
        String line = sc.nextLine();
        //④调用方法，用一个变量接收结果
        String s = myReverse(line);
        System.out.println("s: " + s);
    }
    /*
        ②定义一个方法，实现字符串反转。返回值类型 String，参数String s
        返回值类型: String
        参数：String s
        反转：String（不可变） --- StringBuilder（可变） --- reverse() --- String
     */
    public static String myReverse(String s){
        /*
        //创建StringBuilder对象 s --- s1 ,String（不可变） --- StringBuilder（可变）
        StringBuilder s1 = new StringBuilder(s);
        //s1反转：StringBuilder（可变） --- reverse()
        s1.reverse();
        //reverse() --- String
        String ss = s1.toString();
        return ss;
         */
        return new StringBuilder(s).reverse().toString();
    }

}