关于java:String类以及练习案例

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

字符串不可变，它们的值在创立后不能被更改
尽管 String 的值是不可变的，然而它们能够被共享
字符串成果上相当于字符数组(char[] )，然而底层原理是字节数组(byte[] )

罕用的构造方法

办法名	阐明
public String()	创立一个空白字符串对象，不含有任何内容
public String(char[] chs)	依据字符数组的内容，来创立字符串对象
public String(byte[] bys)	依据字节数组的内容，来创立字符串对象
String s =“abc”;	间接赋值的形式创立字符串对象，内容就是 abc

示例代码

public class StringDemo01 {public static void main(String[] args) {//public String()：创立一个空白字符串对象，不含有任何内容
        String s1 = new String();
        System.out.println("s1:" + s1);

        //public String(char[] chs)：依据字符数组的内容，来创立字符串对象
        char[] chs = {'a', 'b', 'c'};
        String s2 = new String(chs);
        System.out.println("s2:" + s2);

        //public String(byte[] bys)：依据字节数组的内容，来创立字符串对象
        byte[] bys = {97, 98, 99};
        String s3 = new String(bys);
        System.out.println("s3:" + s3);

        //String s =“abc”;    间接赋值的形式创立字符串对象，内容就是 abc
        String s4 = "abc";
        System.out.println("s4:" + s4);
    }
}

通过构造方法创立

通过 new 创立的字符串对象，每一次 new 都会申请一个内存空间，尽管内容雷同，然而地址值不同
间接赋值形式创立

以“”形式给出的字符串，只有字符序列雷同(程序和大小写)，无论在程序代码中呈现几次，JVM 都只会建设一个 String 对象，并在字符串池中保护

比拟根本数据类型：比拟的是具体的值
比拟援用数据类型：比拟的是对象地址值

办法介绍

public boolean equals(String s)     比拟两个字符串内容是否雷同、辨别大小写

示例代码

public class StringDemo02 {public static void main(String[] args) {
        // 构造方法的形式失去对象
        char[] chs = {'a', 'b', 'c'};
        String s1 = new String(chs);
        String s2 = new String(chs);

        // 间接赋值的形式失去对象
        String s3 = "abc";
        String s4 = "abc";

        // 比拟字符串对象地址是否雷同
        System.out.println(s1 == s2);
        System.out.println(s1 == s3);
        System.out.println(s3 == s4);
        System.out.println("--------");

        // 比拟字符串内容是否雷同
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s3));
        System.out.println(s3.equals(s4));
    }
}

已知用户名和明码，请用程序实现模仿用户登录。总共给三次机会，登录之后，给出相应的提醒

public class Test1 登录案例 {public static void main(String[] args) {
        //1. 定义两个变量用来记录正确的用户名和明码
        String rightUsername = "itheima";
        String rightPassword = "1234qwer";

        //2. 键盘录入用户名和明码
        //ctrl + alt + T 抉择包裹形式

        for (int i = 0; i < 3; i++) {//0 1 2
            Scanner sc = new Scanner(System.in);
            System.out.println("请输出用户名");
            String username = sc.next();
            System.out.println("请输出明码");
            String password = sc.next();

            //3. 判断比拟
            if (username.equals(rightUsername) && password.equals(rightPassword)) {System.out.println("登录胜利");
                // 如果正确，循环完结
                break;
            } else {
                // 最初一次机会
                if(i == 2){System.out.println("账户" + username + "被锁定，请分割黑马程序员官网小姐姐：XXXXXXX");
                }else{
                    // 不是最初一次机会
                    System.out.println("用户名或明码谬误，登录失败, 还剩下" + (2 - i) + "次机会");//2 1 0
                }
            }
        }

    }
}

键盘录入一个字符串，应用程序实现在控制台遍历该字符串

public class Test2 字符串间接遍历 {public static void main(String[] args) {
        // 两个办法：//charAt()：会依据索引获取对应的字符
        //length(): 会返回字符串的长度


        //1. 键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输出字符串");
        String str = sc.next();
        System.out.println(str);

        //2. 遍历
        for (int i = 0; i < str.length(); i++) {
            //i 顺次示意字符串的每一个索引
            // 索引的范畴：0 ~  长度 -1

            // 依据索引获取字符串外面的每一个字符
            //ctrl + alt + V 主动生成右边的承受变量
            char c = str.charAt(i);
            System.out.println(c);
        }
    }
}

键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符呈现的次数(不思考其余字符)

public class Test4 统计个数 {public static void main(String[] args) {
        // 键盘录入一个字符串，统计大写，小写，数字呈现的次数


        //1. 键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输出一个字符串");
        String str = sc.next();


        //2. 统计 --- 计数器 count
        // 此时我要统计的有 3 样货色，所以要定义 3 个计数器别离进行统计
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        // 失去这个字符串外面每一个字符
        for (int i = 0; i < str.length(); i++) {
            //i 示意字符串中的索引
            //c 示意字符串中的每一个字符
            char c = str.charAt(i);

            // 对 c 进行判断
            if (c >= 'a' && c <= 'z') {smallCount++;}else if(c >= 'A' && c <= 'Z'){bigCount++;}else if(c >= '0' && c <= '9'){numberCount++;}
        }

        //3. 当循环完结之后，三个变量记录的就是对应的个数
        System.out.println("大写字符有:" + bigCount + "个");
        System.out.println("小写字符有:" + smallCount + "个");
        System.out.println("数字字符有:" + numberCount + "个");
    }
}

定义一个办法，把 int 数组中的数据依照指定的格局拼接成一个字符串返回，调用该办法，

并在控制台输入后果。例如，数组为 int[] arr = {1,2,3};，执行办法后的输入后果为：[1, 2, 3]

public class Test5 数组拼接成字符串 {public static void main(String[] args) {
        // 定义一个办法，把 int 数组中的数据依照指定的格局拼接成一个字符串返回，调用该办法，// 并在控制台输入后果。例如，数组为 int[] arr = {1,2,3};
        // 执行办法后的输入后果为：[1, 2, 3]


        int[] arr = {1, 2, 3, 4, 5};

        String str = arrToString(arr);
        System.out.println(str);

    }


    // 作用：把一个数组变成字符串
    public static String arrToString(int[] arr) {
        String s = "";
        // 拼接左括号
        s = s + "["; // 此时是拿着长度为 0 的字符串，跟[进行拼接，产生一个新的字符串。// 把新的字符串再赋值给 s，此时变量 s 记录的就是新的字符串 "[" 的地址值

        // 上面我想得到数组外面的每一个元素并进行拼接
        // 那么就须要遍历数组，失去每一个元素才行
        for (int i = 0; i < arr.length; i++) {
            // 假如第一次循环:i = 0 获取的就是 0 索引上的元素
            // 在拼接的时候："[" + 1 + "," 拼接结束之后产生一个新的字符串 "[1,"
            // 第二次循环：i = 1 获取的就是 1 索引上的元素
            // 在拼接的时候：此时 s 就是第一次循环完结后拼接结束的后果："[1,"
            // 在拼接的时候："[1," + 2 + "," 拼接结束之后产生一个新的字符串 "[1, 2,"
            //...
           if(i == arr.length - 1){
               // 如果是最初一个元素，那么不须要拼接逗号空格
               s = s + arr[i];
           }else{
               // 如果不是最初一个元素，须要拼接元素和逗号空格
               s = s + arr[i] + ",";
           }
        }

        // 等循环完结之后，再拼接最初一个右括号
        s = s + "]";

        return s;

    }


    // 用来遍历数组
    public static void printArr(int[] arr) {System.out.print("[");
        for (int i = 0; i < arr.length; i++) {if (i == arr.length - 1) {System.out.print(arr[i]);
            } else {System.out.print(arr[i] + ",");
            }
        }
        System.out.println("]");

        //[1, 2, 3, 4, 5]
        // 咱们当初要晓得，这个最终后果是怎么来的？// 从到右顺次打印得来的。}
}

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

例如，键盘录入 abc，输入后果 cba

public class Test6 反转字符串 {public static void main(String[] args) {
        /* 定义一个办法，实现字符串反转。键盘录入一个字符串，调用该办法后，在控制台输入后果
        例如，键盘录入 abc，输入后果 cba*/



        //1. 定义一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输出一个字符串");
        String str = sc.next();
        //2. 定义一个办法，反转字符串
        //abc  --->  cba
        // 能够把字符串倒着遍历，再拼接
        String result = reverse(str);
        System.out.println(result);


    }

    // 正文：办法的作用就是反转字符串
    // 把传递进来的字符串进行反转
    public static String reverse(String str){//abc
        // 核心思想：倒着遍历并进行拼接就能够了
        //fori : 正着遍历  forr：倒着遍历
        String s = "";
        for (int i = str.length() - 1; i >= 0; i--) {
            //i 顺次示意字符串外面的每一个索引（倒着的）// 咱们就能够拿到外面的每一个字符并拼接
            s = s + str.charAt(i);
        }

        // 把倒着拼接之后的后果返回即可
        return s;

    }
}

把 2135 变成：零佰零拾零万贰仟壹佰叁拾伍元

把 789 变成：零佰零拾零万零仟柒佰捌拾玖元

package com.itheima.stringdemo;

import java.util.Scanner;

public class StringDemo9 {public static void main(String[] args) {
        //1. 键盘录入一个金额
        Scanner sc = new Scanner(System.in);
        int money;
        while (true) {System.out.println("请录入一个金额");
            money = sc.nextInt();
            if (money >= 0 && money <= 9999999) {break;} else {System.out.println("金额有效");
            }
        }

        // 定义一个变量用来示意钱的大写
        String moneyStr = "";

        //2. 失去 money 外面的每一位数字, 再转成中文
        while (true) {//2135
            // 从右往左获取数据，因为右侧是数据的个位
            int ge = money % 10;
            String capitalNumber = getCapitalNumber(ge);
            // 把转换之后的大写拼接到 moneyStr 当中
            moneyStr = capitalNumber + moneyStr;
            // 第一次循环："伍" + ""=" 伍 "// 第二次循环：" 叁 "+" 伍 "=" 叁伍 "
            // 去掉刚刚获取的数据
            money = money / 10;

            // 如果数字上的每一位全副获取到了，那么 money 记录的就是 0，此时循环完结
            if (money == 0) {break;}
        }

        //3. 在后面补 0，补齐 7 位
        int count = 7 - moneyStr.length();
        for (int i = 0; i < count; i++) {moneyStr = "零" + moneyStr;}
        System.out.println(moneyStr);// 零零零贰壹叁伍

        //4. 插入单位
        // 定义一个数组示意单位
        String[] arr = {"佰","拾","万","仟","佰","拾","元"};
        //               零    零   零   贰   壹   叁   伍

        // 遍历 moneyStr，顺次失去 零    零   零   贰   壹   叁   伍
        // 而后把 arr 的单位插入进去

        String result = "";
        for (int i = 0; i < moneyStr.length(); i++) {char c = moneyStr.charAt(i);
            // 把大写数字和单位拼接到 result 当中
            result = result + c + arr[i];
        }

        //5. 打印最终后果
        System.out.println(result);

    }


    // 定义一个办法把数字变成大写的中文
    //1 -- 壹
    public static String getCapitalNumber(int number) {
        // 定义数组，让数字跟大写的中文产生一个对应关系
        String[] arr = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
        // 返回后果
        return arr[number];
    }

}

需要：以字符串的模式从键盘承受一个手机号，将两头四位号码屏蔽

最终成果为：131****9468

代码实现：

public class Test8 手机号屏蔽 {public static void main(String[] args) {
        /* 以字符串的模式从键盘承受一个手机号，将两头四位号码屏蔽
        最终成果为：131****9468*/

        //1. 键盘录入一个手机号码
        Scanner sc = new Scanner(System.in);
        System.out.println("请输出手机号码");
        String phoneNumber = sc.next();//13112349408

        //2. 截取手机号码中的前三位
        String star = phoneNumber.substring(0, 3);

        //3. 截取手机号码中的最初四位
        // 此时我用 substring 办法，是用 1 个参数的，还是两个参数的？1 个参数的会更好
        // 因为当初我要截取到最初，所以倡议应用 1 个参数的。String end = phoneNumber.substring(7);

        //4. 拼接
        String result = star + "****" + end;

        System.out.println(result);

    }
}

需要 1：键盘录入一个字符串，如果字符串中蕴含（TMD），则应用 * 替换

public class Test9 敏感词替换 {public static void main(String[] args) {
        //1. 定义一个变量示意骂人的话
        String talk = "后嗣你玩什么啊，TMD";


        //2. 把这句话中的敏感词进行替换
        String result = talk.replace("TMD", "***");

        //3. 打印
        System.out.println(talk);
        System.out.println(result);
    }
}

需要 2：如果要替换的敏感词比拟多怎么办？

public class Test10 多个敏感词替换 {public static void main(String[] args) {
        // 理论开发中，敏感词会有很多很多

        //1. 先键盘录入要说的话
        Scanner sc = new Scanner(System.in);
        System.out.println("请输出要说的话");
        String talk = sc.next();// 后嗣你玩什么啊，TMD,GDX,ctmd,ZZ

        //2. 定义一个数组用来存多个敏感词
        String[] arr = {"TMD","GDX","ctmd","ZZ","lj","FW","nt"};

        //3. 把说的话中所有的敏感词都替换为 ***

        for (int i = 0; i < arr.length; i++) {
            //i 索引
            //arr[i] 元素 --- 敏感词
            talk = talk.replace(arr[i],"***");
        }

        //4. 打印后果
        System.out.println(talk);// 后嗣你玩什么啊，***,***,***,***

    }
}

身份证的每一位都是有固定的含意：

1、2 位：省份
3、4 位：城市
5、6 位：区县
7-14 位：出世年、月、日
15、16 位：所在地派出所
17 位：性别（奇数男性，偶数女性）
18 位：个人信息码（随机产生）

要求打印内容形式如下：

人物信息为：

出生年月日：XXXX 年 X 月 X 日

性别为：男 / 女

package com.itheima.stringdemo;

public class StringDemo11 {public static void main(String[] args) {
        //1. 定义一个字符串记录身份证号码
        String id = "321281202001011234";

        //2. 获取出生年月日
        String year = id.substring(6, 10);
        String month = id.substring(10, 12);
        String day = id.substring(12, 14);


        System.out.println("人物信息为：");
        System.out.println("出生年月日:" + year + "年" + month + "月" + day + "日");

        //3. 获取性别
        char gender = id.charAt(16);//'3'  ---> 3
        // 利用 ASCII 码表进行转换
        //'0' --->  48
        //'1' --->  49
        //'2' --->  50
        //'3' --->  51
        //'4' --->  52
        //'5' --->  53
        //'6' --->  54
        //'7' --->  55
        //'8' --->  56
        //'9' --->  57

       int num = gender - 48;
        if(num % 2 == 0){System.out.println("性别为: 女");
        }else{System.out.println("性别为: 男");
        }
    }
}

StringBuilder 能够看成是一个容器，创立之后外面的内容是可变的。

当咱们在拼接字符串和反转字符串的时候会应用到

public class StringBuilderDemo3 {public static void main(String[] args) {
        //1. 创建对象
        StringBuilder sb = new StringBuilder("abc");

        //2. 增加元素
        /*sb.append(1);
        sb.append(2.3);
        sb.append(true);*/

        // 反转
        sb.reverse();

        // 获取长度
        int len = sb.length();
        System.out.println(len);


        // 打印
        // 遍及：// 因为 StringBuilder 是 Java 曾经写好的类
        //java 在底层对他做了一些非凡解决。// 打印对象不是地址值而是属性值。System.out.println(sb);
    }
}

public class StringBuilderDemo4 {public static void main(String[] args) {
        //1. 创建对象
        StringBuilder sb = new StringBuilder();

        //2. 增加字符串
        sb.append("aaa").append("bbb").append("ccc").append("ddd");

        System.out.println(sb);//aaabbbcccddd

        //3. 再把 StringBuilder 变回字符串
        String str = sb.toString();
        System.out.println(str);//aaabbbcccddd

    }
}

需要：

键盘承受一个字符串，程序判断出该字符串是否是对称字符串，并在控制台打印是或不是

  对称字符串：123321、111
  
  非对称字符串：123123

代码示例：

public class StringBuilderDemo6 {
    // 应用 StringBuilder 的场景：//1. 字符串的拼接
    //2. 字符串的反转

    public static void main(String[] args) {
        //1. 键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输出一个字符串");
        String str = sc.next();

        //2. 反转键盘录入的字符串
        String result = new StringBuilder().append(str).reverse().toString();

        //3. 比拟
        if(str.equals(result)){System.out.println("以后字符串是对称字符串");
        }else{System.out.println("以后字符串不是对称字符串");
        }

    }
}

需要：定义一个办法，把 int 数组中的数据依照指定的格局拼接成一个字符串返回。

调用该办法，并在控制台输入后果。

例如：数组为 int[] arr = {1,2,3};

执行办法后的输入后果为：[1, 2, 3]

代码示例:

package com.itheima.stringbuilderdemo;

public class StringBuilderDemo7 {public static void main(String[] args) {
        //1. 定义数组
        int[] arr = {1,2,3};

        //2. 调用办法把数组变成字符串
        String str = arrToString(arr);

        System.out.println(str);

    }


    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("]");

        return sb.toString();}
}

StringJoiner 跟 StringBuilder 一样，也能够看成是一个容器，创立之后外面的内容是可变的。
作用：进步字符串的操作效率，而且代码编写特地简洁，然而目前市场上很少有人用。
JDK8 呈现的

根本应用：

//1. 创立一个对象，并指定两头的距离符号
StringJoiner sj = new StringJoiner("---");
//2. 增加元素
sj.add("aaa").add("bbb").add("ccc");
//3. 打印后果
System.out.println(sj);//aaa---bbb---ccc

//1. 创建对象
StringJoiner sj = new StringJoiner(",","[","]");
//2. 增加元素
sj.add("aaa").add("bbb").add("ccc");
int len = sj.length();
System.out.println(len);//15
//3. 打印
System.out.println(sj);//[aaa, bbb, ccc]
String str = sj.toString();
System.out.println(str);//[aaa, bbb, ccc]

字符串存储的内存原理

String s =“abc”；间接赋值

特点：

此时字符串 abc 是存在字符串常量池中的。

先查看字符串常量池中有没有字符串 abc，如果有，不会创立新的，而是间接复用。如果没有 abc，才会创立一个新的。

所以，间接赋值的形式，代码简略，而且节约内存。
new 进去的字符串

看到 new 关键字，肯定是在堆外面开拓了一个小空间。

String s1 = new String（“abc”）；

String s2 =“abc”；

s1 记录的是 new 进去的，在堆外面的地址值。

s2 是间接赋值的，所以记录的是字符串常量池中的地址值。
== 号比拟的到底是什么？

如果比拟的是根本数据类型：比的是具体的数值是否相等。

如果比拟的是援用数据类型：比的是地址值是否相等。

论断：== 只能用于比拟根本数据类型。不能比拟援用数据类型。

关于java:String类以及练习案例

1.1String 类概述

1.2String 类的特点

1.3String 类的构造方法

1.4 创立字符串对象两种形式的区别

1.5 字符串的比拟

1.5.1== 号的作用

1.5.2equals 办法的作用

1.6 用户登录案例

1.6.1 案例需要

1.6.2 代码实现

1.7 遍历字符串案例

1.7.1 案例需要

1.7.2 间接遍历字符串

1.8 统计字符次数案例

1.8.1 案例需要

1.8.2 代码实现

1.9 字符串拼接案例

1.9.1 案例需要

1.9.2 代码实现

1.10 字符串反转案例

1.10.1 案例需要

1.10.2 代码实现

1.11 金额转换

1.11.1 案例需要

1.11.2 代码实现

1.12 手机号屏蔽

1.13 敏感词替换

1.14 身份证信息查看

2.StringBuilder

2.1 根本应用

2.2 链式编程

2.3 练习 1：对称字符串

2.4 练习 2：拼接字符串

3. StringJoiner

对于字符串的小扩大：