String 有趣简单的编程题

每博一文案

师父说: 世上没有真正的感同身受，也没有谁能完全做到将心比心，我们一路走来。
慢慢的学会了收敛情绪，越成熟越沉默，有些人，背负沉重的压力，却从来不敢说累，
有些话吗，不是不想对人说，而是说了压根没人懂，事情没发生在自己身上，别人永远不懂
你有多痛，越是在乎别人的看法，越容易忽略自己的感受，于是越来越沉默，越来越不想说。
所有苦都自己杠，所有的泪都自己咽，能自己杠的，就别声张，能自己做的，就别求人，
谁都靠不住，除非你有用，等风来，不如追风去，靠别人，不如靠自己。
没有谁会无条件对你好，也没有谁能保证待你如初，把希望寄托在别人身上，
到头来受伤的还是自己，有时尽心尽力做事，最后却为了他人做了嫁衣，有时掏心掏肺对人好
，最后却换来惨痛的结局。生活中多的是等着看你笑话的人，而真正关心你的人没几个，被
伤的次数多了，便知道要将心藏好，无心便无痛，无痛便无敌。
人总要学会自己长大，你若不坚强，懦弱给谁看，宁可让人觉得没心没肺，也不要让人觉得可怜卑微。
人生如逆旅，你我皆行人，人生不如意十之八九，可与人言，却无二三，快乐分享错了人，就成了显摆。
悲伤倾诉错了人，就成了矫情，每个人都有别人不懂的苦与乐，再幸福的人，内心也有无奈难处，
再风光的人，背后也有寒凉苦楚，不要再寂寞的时候谈感情，不要在孤独的时候找安慰，越成熟的人就越沉默。
因为他忙着独自奋力前行，快乐不难，只要内心简单，幸福容易，只要学会珍惜，无奈前路是顺是逆，
无论生活是风是雨，坚持到底，才算不辜负自己，冷暖自知，就是最好的活法。
                                         ——————   一禅心灵庙语

文章目录

String 有趣简单的编程题

1. 题目一：字符串的反转

将一个字符串进行反转。将字符串中指定部分进行反转。比如“abcdefg”反转为”gfedcba”

方式一:

思路:

首先使用toCharArray 对象方法将字符串转换为字符数组，

再将字符数组中的字符，循环遍历，前后字符反转。

最后将字符数组作为参数，转换为 String 字符串对象

public class StringExam {
    public static void main(String[] args) {
        String str = "abcdefg";

        System.out.println("反转前: " + str);
        // 1.将 String 转换为字符数组
        char[] chars = str.toCharArray();

        // 2. 循环前后反转
        int start = 0;
        int end = chars.length - 1;

        while (start <= end) {
            char temp = chars[end];
            chars[end] = chars[start];
            chars[start] = temp;
            end--;
            start++;
        }

        // 3. 转换好的字符数组，作为参数创建 String 对象
        String strCopy = new String(chars);
        System.out.println("反转后: " + strCopy);
        
    }
}

方式二:

思路:

拼接字符串：因为涉及到对字符串频繁的拼接操作，所以使用 StringBuffer / StringBuilder

将字符串 “abcdefg” 依次从最后一个字符串取单个字符，使用 Cha() 方法，再使用 apped()方法拼接上就反转了

public class StringExam {
    public static void main(String[] args) {
        String str = "abcdefg";
        System.out.println("反转前: " + str);

        // 1. 创建一个空字符串的 StringBuilder 用于拼接,设置容量为 str.length()的长度的大小。
        // 减少扩容次数，提高效率
        StringBuilder stringBuilder = new StringBuilder(str.length());
        int index = str.length() - 1;
        while (index >= 0) {
            // 2. 从最后面依次取出 str 字符串的字符，拼接上
            stringBuilder.append(str.charAt(index));
            index--;
        }
        System.out.println("反转后: " + stringBuilder);
        
    }
}

2. 题目二: 获取subStr 子串在 mainStr 主串中出现的次数

判断子串 “abc” 在中主串 “abcabcabchelloabcworldabc” 出现了多少次。

方式一:

思路：

当主串的字符串长度 >= 子串的字符串长度，才需要寻找，因为但主串的长度都 < 子串的长度，那么必然没有子串了，0 个子串不用找了。使用 indexOf() 的对象方法，每在主串中找到一个返回子串所在的索引下标，再限定范围跳过该子串，继续在主串在中找，

每找到一个计数。

public class StringExam {
    public static void main(String[] args) {
        String mainStr = "abcabcabchelloabcworldabc";
        String subStr = "abc";

        int count = 0;
        int index = 0;

        // 1. 首先判断，主串的长度是否 >= 子串，小于的话就是，主串中不存在子串的内容，0个
        if (mainStr.length() >= subStr.length()) {
            // 2. 循环遍历: ，indexOf()找子串所在的下标位置，返回 -1表示不存在
            while ((index = mainStr.indexOf(subStr, index)) != -1) {
                count++;

                // 3. 跳过该子串的位置，向后继续找，直到子串不存在了
                index = index + subStr.length();

            }
        }

        // 循环结束，找完了
        System.out.println(count);
    }
}

方式二:

思路:

思路和方式一是一样的，不同的是，这里我们将使用substring(截断)方法，找到一个子串，就截断主串，再从截断的字符串中找

public class StringExam {
    public static void main(String[] args) {
        String mainStr = "abcabcabchelloabcworldabc";
        String subStr = "abc";

        int count = 0;
        int index = 0;

        // 1. 当 主串的长度 >= 子串才有，子串的存在
        if (mainStr.length() >= subStr.length()) {
            // 2. indexOf()返回子串在主串的所在索引下标位置
            while ((index = mainStr.indexOf(subStr, index)) != -1) {
                count++;
                // 3. 找下个一个，通过截断找到的一个长度，向后找: index(找到的子串下标位置) + 子串的长度
                mainStr = mainStr.substring(subStr.length(), mainStr.length());
            }
        }

        // 4. 循环结束
        System.out.println(count);
    }
}

3. 题目三：获取两个字符串中最大的子串

str1 = “abcwerthelloyuiodef“;str2 = “cvhellobnm” 提示：将短的那个串进行长度依次递减的子串与较长的串比较。public boolean contains(CharSequence s)当且仅当此字符串包含指定的 char 值序列时，返回 true。

前提是，两个字符串中只有一个最大相同的子串

思路:

首先确定好，哪个是主串，哪个是子串，长的为主串，短的为子串
逆向思维：通过不断变化子串，使用 contains()对象方法判断子串是否在主串中存在，存在返回 true，不存在返回 false
通过不断变化子串：一旦contains()返回 true,该子串就是最长的子串。变化规律如下图：

public class StringExam {
    public static void main(String[] args) {
        String str1 = "abcwerthelloyuiodeff";
        String str2 = "cvhellobnm";

        // 1. 找到主串，子串,长的为主串，短的为子串
        String maxStr = str1.length() > str2.length() ? str1 : str2;
        String minStr = str1.length() < str2.length() ? str1 : str2;

        int length = minStr.length();   // for遍历次数是子串的长度，因为子串的长度在一点一点的减少
        // 2.将子串的长度，一点一点的减小，与主串比较判断是否存在
        for (int i = 0; i < length; i++) {
            int x = 0;
            int y = 0;
            // case: 1.完整的子串比较判断，2.去开头子串一个字符比较，3.去结尾子串一个字符比较，4.去开头和结尾一个字符比较
            for (x = 0, y = length - i; y <= length; y++, x++) {
                String subStr = minStr.substring(x, y);
                if (maxStr.contains(subStr)) {
                    System.out.println(subStr);  // 找到了最长的子串
                    return;
                }
            }
        }
    }
}

如果存在多个相同最大长度的子串：

处理方式，找到子串以后，不要 return 返回，而是存储起来就可以了。

public class StringExam {
    public static void main(String[] args) {
        String str1 = "abcwerthelloyuiodeffhellohellohello";
        String str2 = "cvhellobnm";
        // 存储多个相同的子串
        StringBuilder stringBuilder = new StringBuilder();

        String maxStr = str1.length() >= str2.length() ? str1 : str2;
        String minStr = str1.length() < str2.length() ? str1 : str2;

        // 从短子串比较
        int length = minStr.length();

        boolean sign = false;
        for (int i = 0; i < length; i++) {
            int x = 0;
            int y = 0;
            for (x = 0, y = length - i; y <= length; x++, y++) {
                // case：1.完整子串，2.去子串开头，3.去子串结尾，4.去子串开头，结尾
                String subString = minStr.substring(x, y);

                if (maxStr.contains(subString)) {
                    stringBuilder.append(subString + ",");
                }
            }

            // 当存储最长子串的长度不为 0，停止。因为最长相同的子串都存储完了
            if (stringBuilder.length() != 0) {
                break;
            }

        }

        System.out.println(stringBuilder);
    }
}

4. 题目四 : 金额格式（将阿拉伯数字，转换为汉字的大写数值）

思路:

得到输入的金额： money 中的每个数值，方便转换为对应的中文大写数值
通过取模 % 运算获取到 money 的最后一个数值。以及 / 除法去掉已经获取到的最后一个数值，向前取值
定义一个String 字符数组: 存储汉字中的数字的大写。再通过从 money获取到的单个数值访问存储汉字数字大写数组的下标，获取到对应汉字数字大写，如下图示：

String[] arr = {"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};

获取到对应汉字数字的大写，将其拼接到对应的字符串中，注意：因为我们的 money 输入的金额的数值是从最后面开始获取的，也就是个位数开始的，所以我们拼接的时候，要将个位数的数值拼接到最后面，依次是十位数的数值。
将不足七位数的补零
同样创建一个存储数值单位的 String 字符串，依次插入到拼接的字符串当中

 String[] arrs = {"佰","拾","万","仟","佰","拾","元"};

import java.util.Scanner;

public class StringExam {
    public static void main(String[] args) {
        // 1.键盘输入一个金额
        Scanner scanner = new Scanner(System.in);
        int money = 0;

        while (true) {
            System.out.print("请输入一个金额: ");  // 123
            money = scanner.nextInt();
            if (money >= 0 && money <= 99999999) {
                break;
            } else {
                System.out.print("金额无效，重新输入: ");
            }
        }

        // 定义一个变量，用来表示大写，并用于拼接大写
        String moneyStr = "";

        // 2. 获取到 money 输入的金额的最后的数值
        while (money > 0) {
            int index = money % 10;  // 获取money 最后一个数值，个位上的数值
            money = money / 10;  // 继续向前取，十位上的数值

            // 3.把转换之后的大写连接上 moneyStr中
            // moneyStr = moneyStr + capitalNumber;
            // 第一次循环是： 叁
            // 第二次循环是:  叁贰
            // 第三次循环是:  叁贰壹
            // 反一下就可以了，将最后取到的数值放到后面
            moneyStr = getCapitalNumber(index) + moneyStr;
            System.out.println(moneyStr);
        }

        // 4. 不足 7 位数值补 0
        int count = 7 - moneyStr.length(); // 补全7位数值,不足补零
        for (int i = 0; i < count; i++) {
            moneyStr = "零" + moneyStr;
        }

        System.out.println(moneyStr);

        // 5. 将各个单位插入到对应的位置当中
        // 定义一个数组表示单位:
        String[] arrs = {"佰","拾","万","仟","佰","拾","元"};
        String result = "";

        for(int i = 0; i < moneyStr.length(); i++) {
            char c = moneyStr.charAt(i);  // 将对应的中文大写数值取出来，放入到对应的单位当中去
            result = result + c + arrs[i];
        }

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

    }

    // 将输入的埃利伯数字转换位中文的大写数字
    // 思路定义一个方法把中文的数字存储起来
    // 阿拉伯的数值 与 中文的大写的数值在下标上相对应上，。
    public static String getCapitalNumber(int number) {
        // 定义中文数字的数组
        String[] arr = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};

        // 返回对应埃莱伯数值的 转换为对应的 中文大写的数值
        return arr[number];
    }
}

5. 题目五：从身份征中读取信息

从身份证： 321281202001011234 获取到其中的出生年月日，以及性别

思路:

明白身份证上的各个区间上数值的意思：

身份证号码是由18位数字组成的，他们分别表示：

前1、2位数字表示：所在省份的代码。

前3、4位数字表示：所在城市的代码。

前5、6位数字表示：所在区县的代码

第7～14位数字表示：出生年、月、日，7、8、9、10位是年，11、12位是月，13、14位是日

其中第17位数字表示性别，奇数表示男性，偶数表示女性

18位数字是校检码，校检码可以是0~9的数字，有时也用x表示，X是罗马数字的10。

知道了身份证的信息后，我们就可以使用 substring() 对象方法截断获取到我们想要的信息

还有一个问题：就是将 字符'3'数值 转换为 int 的数值 我们观察 ASCII 码表如下图所示：

我们可以观察到 :

char ‘0’ 对应 int 十进制 48

char ‘1’ 对应 int 十进制 49 ，

char ‘2’ 对应 int 十进制 50，

char ‘3’ 对应 int 十进制 51 ，

char ‘4’ 对应 int 十进制 52 ，

char ‘5’ 对应 int 十进制 53 ，

**(int)5 + ’0‘(char) = 5 + 48 = 53，5 = 53 – 48 就成了 int 类型的数值了。 **

public class StringExam {
    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

        // 将字符 '3' 转换为 数值 3
        // 利用ASCII码表进行转换
        // '0' -->  48
        // '1' --> 49
        // '2' --> 50
        // '3' --> 51
        // '9' + 0 = 48 + 9 = 57;
        // 9 = 57 -48 就成了int 类型的数值的
        int num = gender - 48;
        if (num % 2 == 0) {
            System.out.println("性别为 女");
        } else {
            System.out.println("性别为: 男");
        }


    }
}

6. 题目六：脏话替换

定义一句 String类型的脏话：“你玩的真好,SB”; 将其中的 SB 替换成 xxx

思路:

创建一个脏话的数据库信息 String 数组。
循环遍历存储脏话的数据库，用于判断所说的脏话，并进行替换。

public class StringExam {
    public static void main(String[] args) {
        String talk = "你玩的真好,SB";

        // 2.定义一个敏感的词库，用于判断是否有脏话，并替换
        String[] arr = {"TMD","CNM","SB","MLGB"};

        // 3. 循环遍历脏话数据库，并进行替换
        for (int i = 0; i < arr.length; i++) {
            talk = talk.replace(arr[i],"xxx");
        }

        // 替换完后
        System.out.println(talk);
    }
}

7. 总结：

灵活使用 String 中方法，实现对应的操作，提高开发效率。
对应String 字符串的频繁拼接，建议使用 StringBuffer / StringBuild 替换了。
理解 ASCII 码表中的数字字符 char 转换为 int 的数值的方式： (int)5 + ‘0’(char) = 5 + 48 = 53, 5 = 53 -48