数字与字符串系列教材（六）- Java中的字符串String详解

工具版本兼容问题

本视频是解读性视频，所以希望您已经看过了本知识点的内容，并且编写了相应的代码之后，带着疑问来观看，这样收获才多。不建议一开始就观看视频

7分33秒
本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

示例 1 : 创建字符串
示例 2 : final
示例 3 : immutable
示例 4 : 字符串格式化
示例 5 : 字符串长度
示例 6 : 练习-随机字符串
示例 7 : 答案-随机字符串
示例 8 : 练习-字符串数组排序
示例 9 : 答案-字符串数组排序
示例 10 : 练习-穷举法破解密码
示例 11 : 答案-穷举法破解密码

示例 1 :

创建字符串

edit 顶折

纠问

字符串即字符的组合，在Java中，字符串是一个类，所以我们见到的字符串都是对象
常见创建字符串手段：
1. 每当有一个字面值出现的时候，虚拟机就会创建一个字符串
2. 调用String的构造方法创建一个字符串对象
3. 通过+加号进行字符串拼接也会创建新的字符串对象

package character;
 
public class TestString {
 
    public static void main(String[] args) {
        String garen ="盖伦"; //字面值,虚拟机碰到字面值就会创建一个字符串对象
         
        String teemo = new String("提莫"); //创建了两个字符串对象
         
        char[] cs = new char[]{'崔','斯','特'};
         
        String hero = new String(cs);//  通过字符数组创建一个字符串对象
         
        String hero3 = garen + teemo;//  通过+加号进行字符串拼接
    }
}

示例 2 :

final

edit 顶折

纠问

String 被修饰为final,所以是不能被继承的

package character;
 
public class TestString {
 
    public static void main(String[] args) {
        MyString str = new MyString();
         
    }
     
        /*这里会报错，因为String不能被继承*/
    static class MyString extends String{
         
    }
     
}

示例 3 :

immutable

edit 顶折

纠问

immutable 是指不可改变的
比如创建了一个字符串对象
String garen ="盖伦";
不可改变的具体含义是指：
不能增加长度
不能减少长度
不能插入字符
不能删除字符
不能修改字符
一旦创建好这个字符串，里面的内容永远不能改变

String 的表现就像是一个常量

package character;
  
public  class TestString {
  
    public static void main(String[] args) {
        String garen ="盖伦"; 
         
    }
}

示例 4 :

字符串格式化

edit 顶折

纠问

如果不使用字符串格式化，就需要进行字符串连接，如果变量比较多，拼接就会显得繁琐
使用字符串格式化，就可以简洁明了
更多的格式化规则，参考格式化输出

代码行数较多，请点击查看

示例 5 :

字符串长度

edit 顶折

纠问

length方法返回当前字符串的长度
可以有长度为0的字符串,即空字符串

package character;
   
public class TestString {
   
    public static void main(String[] args) {
  
        String name ="盖伦";
         
        System.out.println(name.length());
         
        String unknowHero = "";
         
        //可以有长度为0的字符串,即空字符串
        System.out.println(unknowHero.length());
          
    }
}

示例 6 :

练习-随机字符串

edit 顶折

纠问

姿势不对,事倍功半! 点击查看做练习的正确姿势

创建一个长度是5的随机字符串，随机字符有可能是数字，大写字母或者小写字母

给点提示: 数字和字符之间可以通过互相转换

char c = 'A';

short s = (short) c;

通过这个手段就能够知道字符 a-z A-Z 0-9 所对应的数字的区间了

需要用到ASCII码对照表

示例 7 :

答案-随机字符串

edit 顶折

纠问

在查看答案前，尽量先自己完成，碰到问题再来查看答案，收获会更多

查看本答案会花费4个积分，您目前总共有点积分。查看相同答案不会花费额外积分。积分增加办法或者一次性购买JAVA 基础总计0个答案 (总共需要0积分)

账号未激活账号未激活，功能受限。请点击激活

本视频是解读性视频，所以希望您已经看过了本答案的内容，带着疑问来观看，这样收获才多。不建议一开始就观看视频

13分49秒本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

代码行数较多，请点击查看

示例 8 :

练习-字符串数组排序

edit 顶折

纠问

姿势不对,事倍功半! 点击查看做练习的正确姿势

创建一个长度是8的字符串数组
使用8个长度是5的随机字符串初始化这个数组
对这个数组进行排序，按照每个字符串的首字母排序(无视大小写)

注1：不能使用Arrays.sort() 要自己写
注2：无视大小写，即 Axxxx 和 axxxxx 没有先后顺序

示例 9 :

答案-字符串数组排序

edit 顶折

纠问

在查看答案前，尽量先自己完成，碰到问题再来查看答案，收获会更多

查看本答案会花费4个积分，您目前总共有点积分。查看相同答案不会花费额外积分。积分增加办法或者一次性购买JAVA 基础总计0个答案 (总共需要0积分)

账号未激活账号未激活，功能受限。请点击激活

本视频是解读性视频，所以希望您已经看过了本答案的内容，带着疑问来观看，这样收获才多。不建议一开始就观看视频

5分11秒本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

排序的时候，借助冒泡法的思路

比较逻辑是每个字符串的第一个字符，并且都转换为小写，从而达到无视大小写的效果

代码行数较多，请点击查看

package character;
 
import java.util.Arrays;
 
public class TestString {
 
    public static void main(String[] args) {
 
        String[] ss = new String[8];
        for (int i = 0; i < ss.length; i++) {
            String randomString = randomString(5);
            ss[i] = randomString;
        }
        System.out.println("未排序前的字符串数组:");
        System.out.println(Arrays.toString(ss));
 
        for (int j = 0; j < ss.length; j++) {
            for (int i = 0; i < ss.length - j - 1; i++) {
                char firstChar1 = ss[i].charAt(0);
                char firstChar2 = ss[i + 1].charAt(0);
                firstChar1 = Character.toLowerCase(firstChar1);
                firstChar2 = Character.toLowerCase(firstChar2);
 
                if (firstChar1 > firstChar2) {
                    String temp = ss[i];
                    ss[i] = ss[i + 1];
                    ss[i + 1] = temp;
                }
            }
        }
 
        System.out.println("排序后的字符串数组:");
        System.out.println(Arrays.toString(ss));
 
    }
 
    private static String randomString(int length) {
        String pool = "";
        for (short i = '0'; i <= '9'; i++) {
            pool += (char) i;
        }
        for (short i = 'a'; i <= 'z'; i++) {
            pool += (char) i;
        }
        for (short i = 'A'; i <= 'Z'; i++) {
            pool += (char) i;
        }
        char cs[] = new char[length];
        for (int i = 0; i < cs.length; i++) {
            int index = (int) (Math.random() * pool.length());
            cs[i] = pool.charAt(index);
        }
        String result = new String(cs);
        return result;
    }
}

示例 10 :

练习-穷举法破解密码

edit 顶折

纠问

姿势不对,事倍功半! 点击查看做练习的正确姿势

1. 生成一个长度是3的随机字符串，把这个字符串作为当做密码

2. 使用穷举法生成长度是3个字符串，匹配上述生成的密码

要求：分别使用多层for循环和递归解决上述问题

示例 11 :

答案-穷举法破解密码

edit 顶折

纠问

在查看答案前，尽量先自己完成，碰到问题再来查看答案，收获会更多

查看本答案会花费5个积分，您目前总共有点积分。查看相同答案不会花费额外积分。积分增加办法或者一次性购买JAVA 基础总计0个答案 (总共需要0积分)

账号未激活账号未激活，功能受限。请点击激活

本视频是解读性视频，所以希望您已经看过了本答案的内容，带着疑问来观看，这样收获才多。不建议一开始就观看视频

9分54秒本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

多层循环方式
递归方式

代码行数较多，请点击查看

package character;
 
public class TestString {
 
    public static void main(String[] args) {
 
        String password = randomString(3);
        System.out.println("密码是:" + password);
 
        char[] guessPassword = new char[3];
        outloop:
        for (short i = '0'; i <= 'z'; i++) {
            for (short j = '0'; j <= 'z'; j++) {
                for (short k = '0'; k <= 'z'; k++) {
                    if (!isLetterOrDigit(i,j,k))
                        continue;
                    guessPassword[0] = (char) i;
                    guessPassword[1] = (char) j;
                    guessPassword[2] = (char) k;
                    String guess = new String(guessPassword);
//                  System.out.println("穷举出来的密码是：" + guess);
                     
                    if(guess.equals(password)){
                        System.out.println("找到了，密码是" + guess);
                        break outloop;
                    }
                     
                }
            }
        }
    }
     
    private static boolean isLetterOrDigit(short i, short j, short k) {
        return Character.isLetterOrDigit(i) &&
                Character.isLetterOrDigit(j) &&
                Character.isLetterOrDigit(k) ;
    }
 
    private static String randomString(int length) {
        String pool = "";
        for (short i = '0'; i <= '9'; i++) {
            pool += (char) i;
        }
        for (short i = 'a'; i <= 'z'; i++) {
            pool += (char) i;
        }
        for (short i = 'A'; i <= 'Z'; i++) {
            pool += (char) i;
        }
        char cs[] = new char[length];
        for (int i = 0; i < cs.length; i++) {
            int index = (int) (Math.random() * pool.length());
            cs[i] = pool.charAt(index);
        }
        String result = new String(cs);
        return result;
    }
}

数字与字符串系列教材（五）- Java中的字符详解

数字与字符串系列教材（七）- Java常见字符串方法

HOW2J公众号，关注后实时获知最新的教程和优惠活动，谢谢。

问答区域

2024-07-03 抽象为单独的方法，对字符串随机创建数组、排序、打印

虚心求学

关于 JAVA 基础-数字与字符串-字符串的提问

1.利用Math.Random()的方法创建随机字符； 2.根据字母（char）的ASCII值（int）大小进行排序；排序结果：排序前排序后 1 udboN 1 CRSKK 2 CRSKK 2 GlWgS 3 MyHnb 3 kVkjy 4 SmaNm 4 MyHnb 5 GlWgS 5 rVJge 6 TdLqp 6 SmaNm 7 kVkjy 7 TdLqp 8 rVJge 8 udboN

public static void main(String[] args){
    String[]strs = createRandStrArr(8, 5);  //创建指定数量并随机填充指定长度的字符串数组
    printStrArr(strs);                      //打印字符串数组
     
    strArrSort(strs);                       //按字符串首字母顺序排序（无视大小写）
     
    System.out.println("排序后");
    printStrArr(strs);
}
 
//创建指定大小（arrLength）的字符串数组，并用指定长度（strLength）字符串填充数组
public static String[] createRandStrArr(int arrLength,int strLength)
{
    String[] strs = new String[arrLength];      
    for (int i = 0; i < strs.length; i++) {
        strs[i] = getRandomStr(strLength);      //填充随机字符串
    }
    return strs;
}
///生成指定长度的随机字符串
    public static String getRandomStr(int length)
    {
        char[] cs = new char[length];
        for (int i = 0; i < cs.length; i++) {
            int rcase = (int)(Math.random()*10);//用于随机判断大小写
            if(rcase>=5)//各占一半的概率
            {
     
                cs[i] = (char)('A'+Math.random()*25);//Z与A相差25
            }
            else
            {
                cs[i] = (char)('a'+Math.random()*25);//Z与a相差25
            }
                 
        }
        return new String(cs);
    }
     
//打印数组
public static void printStrArr(String[]strs)
{
    int i = 1;
    for (String str : strs) {
        String res = String.format("%d  %s", i++,str);
        System.out.println(res);
    }
}
//基于冒泡排序的方法，按照字符串首字母（无视大小写）对数组进行排序。
public static void strArrSort(String[] strs)
{
    for (int i = 0; i < strs.length-1; i++) {
        for (int j = 0; j < strs.length-1-i; j++) {
             
            int char1 = Character.toLowerCase(strs[j].toCharArray()[0]);            //统一转为小写，目的是无视大小写排序         
            int char2 = Character.toLowerCase(strs[j+1].toCharArray()[0]);          //根据char对应的ASCII值（int）大小来排序
             
            if(char1>char2)                                                          //将较大的值，向后冒泡
            {
                String temp = strs[j+1];
                strs[j+1] = strs[j];
                strs[j] = temp;
            }
        }
    }
}

6 个答案

Lzzlove789
答案时间：2025-04-08

第一第二题

代码超过 5行，点击查看

package digit;
 
public class RandomString {
    private static final String CHAR_SET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
    private static final int DEFAULT_LENGTH = 5;
 
    public static void main(String[] args) {
        String[] stringArray = new String[8];
        for(int i=0;i<8;i++){
            String randomString = generateRandomString(DEFAULT_LENGTH);
            System.out.println("随机生成的字符串为："+ randomString);
            stringArray[i] = randomString;
        }
        System.out.println("字符串数组的内容为：");
        for (int i = 0; i < stringArray.length; i++) {
            System.out.println(stringArray[i]);
        }
 
        // 冒泡排序
        for (int j = 0; j < stringArray.length; j++) {
            for (int i = 0; i < stringArray.length-j-1; i++) {
                if(stringArray[i].charAt(0)>stringArray[i+1].charAt(0)){  
                    String temp = stringArray[i];
                    stringArray[i] = stringArray[i+1];
                    stringArray[i+1] = temp;
                }
            }
        }
 
        System.out.println("排序后字符串数组的内容为：");
        for (int i = 0; i < stringArray.length; i++) {
            System.out.println(stringArray[i]);
        }
    }
 
    public static String generateRandomString(int length) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < length; i++) {
            int index = (int) (Math.random() * CHAR_SET.length());
            sb.append(CHAR_SET.charAt(index));
             
        }
        return sb.toString();
    }
}

Lzzlove789
答案时间：2025-04-08

第一第二题

代码超过 5行，点击查看

package digit;
 
public class RandomString {
    private static final String CHAR_SET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
    private static final int DEFAULT_LENGTH = 5;
 
    public static void main(String[] args) {
        String[] stringArray = new String[8];
        for(int i=0;i<8;i++){
            String randomString = generateRandomString(DEFAULT_LENGTH);
            System.out.println("随机生成的字符串为："+ randomString);
            stringArray[i] = randomString;
        }
        System.out.println("字符串数组的内容为：");
        for (int i = 0; i < stringArray.length; i++) {
            System.out.println(stringArray[i]);
        }
 
        // 冒泡排序
        for (int j = 0; j < stringArray.length; j++) {
            for (int i = 0; i < stringArray.length-j-1; i++) {
                if(stringArray[i].charAt(0)>stringArray[i+1].charAt(0)){  
                    String temp = stringArray[i];
                    stringArray[i] = stringArray[i+1];
                    stringArray[i+1] = temp;
                }
            }
        }
 
        System.out.println("排序后字符串数组的内容为：");
        for (int i = 0; i < stringArray.length; i++) {
            System.out.println(stringArray[i]);
        }
    }
 
    public static String generateRandomString(int length) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < length; i++) {
            int index = (int) (Math.random() * CHAR_SET.length());
            sb.append(CHAR_SET.charAt(index));
             
        }
        return sb.toString();
    }
}

Zzz112138
答案时间：2024-08-30

生成的密码是: nS5 (For)找到密码: nS5 (递归)找到密码: nS5

代码超过 5行，点击查看

public static String getRandomStr(int length) {
        char[] cs = new char[length];
        int random = 0;
        for (int i = 0; i < length; i++) {
            random = (int) (Math.random() * 3);
            if (random == 0) {
                cs[i] = (char) ('A' + (int) (Math.random() * 26));
            } else if (random == 1) {
                cs[i] = (char) ('a' + (int) (Math.random() * 26));
            } else {
                cs[i] = (char) ('0' + (int) (Math.random() * 10));
            }
        }
        return new String(cs);
    }
 
    public static void strArrSort(String[] strs) {
        for (int i = 0; i < strs.length - 1; i++) {
            for (int j = 0; j < strs.length - i - 1; j++) {
                int char1 = Character.toLowerCase(strs[j].toCharArray()[0]);
                int char2 = Character.toLowerCase(strs[j + 1].toCharArray()[0]);
                if (char1 > char2) {
                    String temp = strs[j + 1];
                    strs[j + 1] = strs[j];
                    strs[j] = temp;
                }
            }
        }
    }
 
    public static void printArr(String[] strs) {
        for (int i = 0; i < strs.length; i++) {
            System.out.format("%02d\t%s%n", i + 1, strs[i]);
        }
    }
 
    public static boolean bruteForce(String targetPassword) {
        if (targetPassword.length() != 3) {
            return false; // 如果目标密码长度不是3，则直接返回false
        }
 
        // 定义字符集
        char[] chars = new char[62]; // 26大写 + 26小写 + 10数字
        int index = 0;
        for (char c = 'A'; c <= 'Z'; c++) {
            chars[index++] = c;
        }
        for (char c = 'a'; c <= 'z'; c++) {
            chars[index++] = c;
        }
        for (char c = '0'; c <= '9'; c++) {
            chars[index++] = c;
        }
 
        // 遍历所有可能的字符组合
        for (int i = 0; i < 62; i++) {
            for (int j = 0; j < 62; j++) {
                for (int k = 0; k < 62; k++) {
                    // 生成长度为3的候选密码
                    String candidate = "" + chars[i] + chars[j] + chars[k];
                    // 检查候选密码是否与目标密码匹配
                    if (candidate.equals(targetPassword)) {
                        System.out.println("(For)找到密码: " + candidate);
                        return true; // 找到后返回true
                    }
                }
            }
        }
 
        // 如果遍历完所有可能的密码后仍未找到，则返回false
        return false;
    }
 
    public static void recursiveBruteForce(String current, int remaining, String password) {
        if (remaining == 0) {
            if (current.equals(password)) {
                System.out.println("(递归)找到密码: " + current);
            }
            return;
        }
 
        for (char c = 'A'; c <= 'Z'; c++) {
            recursiveBruteForce(current + c, remaining - 1, password);
        }
        for (char c = 'a'; c <= 'z'; c++) {
            recursiveBruteForce(current + c, remaining - 1, password);
        }
        for (char c = '0'; c <= '9'; c++) {
            recursiveBruteForce(current + c, remaining - 1, password);
        }
 
    }
 
    public static void main(String[] args) {
        String password = getRandomStr(3);
        System.out.format("生成的密码是: %s%n", password);
        bruteForce(password);
        recursiveBruteForce("", 3, password); // 从空字符串开始，剩余长度为3
    }

Zzz112138
答案时间：2024-08-30

排序前 01 j112z 02 qezqI 03 49rh7 04 6x2Xf 05 xMy9a 06 0jawX 07 GeKLk 08 KA8FH 排序后 01 0jawX 02 49rh7 03 6x2Xf 04 GeKLk 05 j112z 06 KA8FH 07 qezqI 08 xMy9a

代码超过 5行，点击查看

public static void main(String[] args) {
        int length = 8;
        String[] strs = new String[length];
        for (int i = 0; i < length; i++) {
            strs[i] = getRandomStr(5);
        }
        System.out.println("排序前");
        printArr(strs);
        System.out.println("排序后");
        strArrSort(strs);
        printArr(strs);
    }
 
    public static String getRandomStr(int length) {
        char[] cs = new char[length];
        int random = 0;
        for (int i = 0; i < length; i++) {
            random = (int) (Math.random() * 3);
            if (random == 0) {
                cs[i] = (char) ('A' + (int) (Math.random() * 26));
            } else if (random == 1) {
                cs[i] = (char) ('a' + (int) (Math.random() * 26));
            } else {
                cs[i] = (char) ('0' + (int) (Math.random() * 10));
            }
        }
        return new String(cs);
    }
 
    public static void strArrSort(String[] strs) {
        for (int i = 0; i < strs.length - 1; i++) {
            for (int j = 0; j < strs.length - i - 1; j++) {
                int char1 = Character.toLowerCase(strs[j].toCharArray()[0]);
                int char2 = Character.toLowerCase(strs[j + 1].toCharArray()[0]);
                if (char1 > char2) {
                    String temp = strs[j + 1];
                    strs[j + 1] = strs[j];
                    strs[j] = temp;
                }
            }
        }
    }
 
    public static void printArr(String[] strs) {
        for (int i = 0; i < strs.length; i++) {
            System.out.format("%02d\t%s%n", i + 1, strs[i]);
        }
    }

虚心求学
答案时间：2024-07-03

解密程序运行结果： is decoding 56155 解出的答案为：Unv，原密码为Unv 共进行了56156步

虚心求学
答案时间：2024-07-03

破解密码试题的答案。以上、以下均为个人理解，恳请各位批评指正。

代码超过 5行，点击查看

public static void main(String[] args){
        String code = getRandomStr(3);      //随机生成一个3位的密码
        deCode(code);                       //解密
    }
    //解密，提供正确答案，程序穷举所有可能的字母组合，直到与答案吻合为止。
    public static void deCode(String code)
    {
        int[]id = new int[code.length()];
        Arrays.fill(id, 65);
        int step = 1;
        while(!checkCorrect(code,id))
        {
            System.out.println("is decoding "+step);
            step++;
            addCode(id,id.length-1);
        }
        String res = "";
        for (int i : id) {
            res+=(char)i;
        }
        res = String.format("解出的答案为：%s，原密码为%s%n共进行了%d步", res,code,step);
        System.out.println(res);
    }
    //检查解密的结果每一位的ASCII值是否与答案相同
    public static boolean checkCorrect(String code,int[]id)
    {
        char[]cs = code.toCharArray();
        for (int i = 0; i < id.length; i++) {
            if((int)cs[i]!=id[i])return false;
        }
        return true;
    }
    //采用ASCII码进位的方式，'Z'跳跃'a'，'z'进位的原理来实现穷举所有字母组合的过程。
    //'A'的ASCII值最小为65，'Z'的值为90，'a'的值为97，'z'的值最大为122；
    //其中'Z'到'a'之间的ASCII值不是字母，也就是90-122之间的数无效;因此进位时，当前位数值为'Z'时，增加数值时需要跳转到'a'
    //当当前位数值为最大值，也就是'z' = 90 时，需要进一位，也就是前一位需要增一；当前位“归零”，也就是归为最小值'A'。
    public static void addCode(int[]id,int addIndex)
    {
        if(addIndex<0)return;                //当进位到最高位时结束递归
        if(addIndex>id.length-1)return;      //当进位索引溢出时结束递归
         
        int last = id[addIndex];            //取进位数（递归前为个位数，递归为上一次递归进位索引的前一位）
 
        if(last<'z')id[addIndex] = last+1;   //当进位数小于最大值'z'时，当前位数的值加一
         
        if(last == 'Z'){                    //当进位数为'Z'，该位跳跃到'a'；a的ASCII值大于Z
            id[addIndex] = 'a';
        }
        else if(last=='z')                  //当进位数到达最大值
        {
            id[addIndex] = 'A';
            addCode(id,addIndex-1);
        }
         
    }
    ///生成指定长度的随机字符串
            public static String getRandomStr(int length)
            {
                char[] cs = new char[length];
                for (int i = 0; i < cs.length; i++) {
                    int rcase = (int)(Math.random()*10);//用于随机判断大小写
                    if(rcase>=5)//各占一半的概率
                    {
             
                        cs[i] = (char)('A'+Math.random()*25);//Z与A相差25
                    }
                    else
                    {
                        cs[i] = (char)('a'+Math.random()*25);//Z与a相差25
                    }
                         
                }
                return new String(cs);
            }

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2024-06-03 好像感觉就我生成随机字符串最麻烦(笑哭）

13457882007

关于 JAVA 基础-数字与字符串-字符串的提问

懒了，第一第二题都直接放在一起弄了

public class TestChar {
    public static void main(String[] args) {
        //第一第二题直接整一块了
        Random random=new Random();
        char[] chars=new char[5];
        String str[]=new String[8];
        //添加随机字符
        for (int i = 0; i < str.length; i++) {
            //中间变量接收单个随机char，
            //可变字符StringBuilder，高效但没有线程安全考量
            // StringBuffder反之
            StringBuilder s=new StringBuilder();
            for (int j = 0; j < chars.length; j++) {
                chars[j]=(char)(33+random.nextInt(94));//33到126，!到}
                // String s="";s+=chars[j];不要像这样用+号链接String，
                // 因为每个+都会创建对象
                s.append(chars[j]);
            }
            str[i]=s.toString();//给String数组赋值
        }
        //排序
        for (int i = 0; i < str.length; i++) {
            for (int j = 0; j < str.length; j++) {
                if((short)str[i].charAt(0)<(short)str[j].charAt(0)){
                    String s0=str[i];
                    str[i]=str[j];
                    str[j]=s0;
                }
            }
        }
        System.out.println(Arrays.toString(str));//打印
         
        char 单个字符密码数组[]=new char[3];
        String 提前生成的密码字符串;
        //中间StringBuilder变量
        StringBuilder stringBuilder=new StringBuilder();
        for (int i = 0; i < 单个字符密码数组.length; i++) {
            单个字符密码数组[i]=(char)(33+random.nextInt(94));
            stringBuilder.append(单个字符密码数组[i]);
        }
        //赋值给密码
        提前生成的密码字符串=stringBuilder.toString();
        System.out.println("正确密码是："+提前生成的密码字符串);
        //创建用来接受方法返回的单个正确密码字符
        char[] c=new char[3];
        TestChar testChar=new TestChar();
        //调用名为：密码() 的方法
        //传入三个数值，第一个正确密码，
        // 第二个是整数，递归次数，
        // 第三个char数组用于存放匹配到的正确密码字符
        testChar.密码(提前生成的密码字符串,0,c);
        //把数组c中的密码串起来
        String 得到的密码=""+c[0]+c[1]+c[2];
        //打印
        System.out.println(得到的密码);
    }
    public void 密码(String 正确密码,int lv,char[] c){
        //取正确密码的第lv个字符
        char m1=正确密码.charAt(lv);
        //一个一个字符进行比较，成功匹配后lv+1
        for (int i = 33; i < 127; i++) {
            char s1=(char) i;
            if(s1==m1){
                c[lv]=s1;//如果相等，就把取到的值放到数组c中
                if (lv++==2){break;}//递归三次结束循环
                this.密码(正确密码,lv,c);//递归
            }
        }
    }
 
}

1 个答案

Lzzlove789
答案时间：2025-04-08

第三题

代码超过 5行，点击查看

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2023-05-07 三个不同的答案

起个名

关于 JAVA 基础-数字与字符串-字符串的提问

1.随机字符串 //创建一个长度是5的随机字符串，随机字符有可能是数字，大写字母或者小写字母给点提示: 数字和字符之间可以通过互相转换 2.练习-字符串数组排序 //创建一个长度是8的字符串数组使用8个长度是5的随机字符串初始化这个数组对这个数组进行排序，按照每个字符串的首字母排序(无视大小写) 注1：不能使用Arrays.sort() 要自己写注2：无视大小写，即 Axxxx 和 axxxxx 没有先后顺序 3.穷举法破解密码 //1. 生成一个长度是3的随机字符串，把这个字符串作为当做密码 //2. 使用穷举法生成长度是3个字符串，匹配上述生成的密码要求：分别使用多层for循环和递归解决上述问题

1.//创建一个长度是5的随机字符串
char[] cs = new char[5];
for(int j = 0; j < 5; j++) {
    int i = (int)(Math.random()*3);
    switch(i) {
        case 0: 
            cs[j] = (char)(Math.random()*('9' - '0' + 1) + '0');
            break;
        case 1: 
            cs[j] = (char)(Math.random()*('z' - 'a' + 1) + 'a');
            break;
        case 2: 
            cs[j] = (char)(Math.random()*('Z' - 'A' + 1) + 'A');
            break;
    }       
}
String s = new String(cs);
System.out.println(cs);
 
2.//练习-字符串数组排序
//创建一个长度是8的随机字符串数组
String[] ss = new String[8];
// 使用8个长度是5的随机字符串初始化这个数组
for(int m = 0; m < 8; m++) {
    ss[m] = getString(5);
}
     
for(String s : ss) 
    System.out.print(s + "\t");
System.out.println();
     
System.out.println("-----------------------------------------------------------");
     
//字符串首字母比较后进行排序
for(int j = 0; j < ss.length - 1; j++)
    for(int i = j + 1; i < ss.length; i++) {
        char c1 = change(Upletter(ss[j]));
        char c2 = change(Upletter(ss[i]));
        if(c1 == '0' || c2 == '0')
            break;
        if(c1 < c2){
            String te = ss[j];
            ss[j] = ss[i];
            ss[i] = te;
        }
    }
     
for(String s : ss) 
    System.out.print(s + "\t");
 
//创建一个长度是len的随机字符串
public static String getString(int len) {
    char[] cs = new char[len];
    for(int j = 0; j < 5; j++) {
        int i = (int)(Math.random()*3);
        switch(i) {
            case 0: 
                cs[j] = (char)(Math.random()*('9' - '0' + 1) + '0');
                break;
            case 1: 
                cs[j] = (char)(Math.random()*('z' - 'a' + 1) + 'a');
                break;
            case 2: 
                cs[j] = (char)(Math.random()*('Z' - 'A' + 1) + 'A');
                break;
        }       
    }
    String s = new String(cs);
    return s;
}
 
//字符串字母转换
public static char change(char a) {
    if(Character.isUpperCase(a))
        a = Character.toLowerCase(a);
    return a;
}
 
// 字符串返回首字母
public static char Upletter(String s) {
    char a = s.charAt(0);
    for(int i = 0; i < s.length(); i ++)
        if(Character.isLetter(s.charAt(i))) {
            a = s.charAt(i);
            break;
        }else {
            a = '0';
        }   
    return a;
}
 
3.//穷举法破解密码
// 通过for循环创建一个长度是len的随机字符串
public static String getString(int len) {
    char[] cs = new char[len];
    for(int j = 0; j < len; j++) {
        cs[j] = (char)(Math.random()*('`' - '!' + 1) + '!');        
    }
    String s = new String(cs);
    return s;
}
 
// 通过递归创建一个长度是len的随机字符串
public static char getChar() {
    char c = (char)(Math.random()*('`' - '!' + 1) + '!');
    return c;
}
 
public static String getString(int len,String s) {          
    String c = getChar() + "";
    len --;
    if(len > 0){
        s = getString(len,s);
    }
 
    return c + s;       
}
         
 
//生成一个长度是3的随机字符串pwd1
String pwd1 = getString(3,"");

1 个答案

爱学Java的小林
答案时间：2023-06-08

只说最后一道题的递归做法。

代码超过 5行，点击查看

public class Test3 {
    public static boolean flag=false;
    public static void main(String[] args) {
      String password=randomString(3);
      System.out.println("随机生成的密码是："+password);
      char[] chars=new char[3];
      panDuan(password, chars, 0);
      System.out.println(String.valueOf(chars));
     
    }
    public static void panDuan(String password,char[] chars,int k) {    
        for(int i=48;i<123;i++) {
            if(flag) {
                return;
            }
            char c=(char)i;
            if(Character.isLetterOrDigit(c)) {
                chars[k]=c;
                if(k<chars.length-1) {
                    panDuan(password,chars,k+1);
                }else {
                    String str=String.valueOf(chars);
                    if(str.equals(password)) {
                        System.out.println("破解成功，密码是："+str);
                        flag=true;
                        return;
                    }
                }
            }
        }
    }
    public static String randomString(int l) {
        char [] chars=new char[l];
        for (int i = 0; i <chars.length; i++) {
            while(true) {
                char c=(char)((Math.random()*(123-48))+48);
                if(Character.isLetterOrDigit(c)) {
                    chars[i]=c;
                    break;
                }
            }
        }
        return new String(chars);
    }
}

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2023-01-30 为什么把数组换成StringBuilder就找不到了

Bingod

关于 JAVA 基础-数字与字符串-字符串的提问

为什么把数组换成StringBuilder就找不到了

1 个答案

jhh9527
答案时间：2023-10-09

代码超过 5行，点击查看

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2022-09-08 字符串排序

张_小凡

关于 JAVA 基础-数字与字符串-字符串的提问

字符串排序

package com.stringPractice;
 
import java.util.Random;
 
public class work1 {
    /**
    * @Description 创建一个长度是8的字符串数组
     *             使用8个长度是5的随机字符串初始化这个数组
     *     对这个数组进行排序，按照每个字符串的首字母排序(无视大小写)
     *
     *     注1： 不能使用Arrays.sort() 要自己写
     *     注2： 无视大小写，即 Axxxx 和 axxxxx 没有先后顺序
    **/
 
    //生成长度为5的随机字符串方法
    public static String getStrings(int length){
        if (length<1 || length>Integer.MAX_VALUE) {
            return null;
        }
        Random random = new Random();
        char[] chars = new char[length];
        int charNumber;
        for (int i = 0; i < length; i++) {
            //生成48~122之间的数字
            charNumber = random.nextInt(75) + 48;
            // 48~57是0~9   65~90是A~Z   97~122是a~z 检查一下是否随机到了这些符合标准的字符
            while ((charNumber>57&&charNumber<65) || (charNumber>90&&charNumber<97)){
                charNumber = random.nextInt(75) + 48;
            }
            chars[i] = (char) charNumber;
        }
        String result = new String(chars);
        return result;
    }
 
    public static void main(String[] args) {
        String[] strings = new String[8];
        for (int i = 0; i < strings.length; i++) {
            strings[i] = getStrings(5);
            System.out.print(strings[i]+" ");
        }
        int[] sign = new int[8];
        for (int i = 0; i < strings.length; i++) {
            char first = strings[i].charAt(0);
            if (Character.isLetter(first)){
                sign[i] = Character.toUpperCase(first);
            }else {
                sign[i] = first;
            }
        }
        //对sign排序，等同于对strings排序,数组长度短，这里用选择排序法
        for (int i = 0; i < sign.length; i++) {
            int min = i;
            for (int j = i+1; j < sign.length; j++) {
                if (sign[min]>sign[j]){
                    int temp = sign[min];
                    String temp1 = strings[min];
                    sign[min] = sign[j];
                    strings[min] = strings[j];
                    sign[j] = temp;
                    strings[j] = temp1;
                }
            }
        }
        System.out.println();
        for (String string : strings) {
            System.out.print(string+" ");
        }
    }
 
}

1 个答案

jhh9527
答案时间：2023-10-10

把每个字符串内部也进行了排序。

代码超过 5行，点击查看

public class question4 {
    public static String[]  getString()
    {
        String[] strings = new String[8];
        for (int i = 0; i < 8; i++) {
            strings[i] = "";
            for (int j = 0; j < 5; j++) {
 
                int pos = (int)(Math.random()*3);
                if (pos == 0)
                {
                    strings[i]+=(char)(Math.random()*26 + 65);
                    continue;
                }
                else if (pos == 1)
                {
                    strings[i]+=(char)(Math.random()*26 + 97);
                    continue;
                }
                else if (pos == 2)
                {
                    strings[i]+=(int)(Math.random()*10);
                    continue;
                }
            }
        }
        return strings;
    }
    public static String[] sortHead(String[] string)
    {
        String temp = null;
        for (int i = 0; i < string.length; i++) {
            for (int j = i; j < string.length; j++) {
                char c = Character.toUpperCase(string[i].charAt(0));
                char c1 = Character.toUpperCase(string[j].charAt(0));
                if (c > c1)
                {
                    temp =  string[i];
                    string[i] = string[j];
                    string[j] = temp;
                }
            }
        }
        return string;
    }
    public static String sortCharArray(char[] chars)
    {
        char temp = ' ';
        for (int i = 0; i < chars.length; i++) {
            for (int j = i; j < chars.length; j++) {
                char c = Character.toUpperCase(chars[i]);
                char c1 = Character.toUpperCase(chars[j]);
                if (c > c1)
                {
                    temp = chars[i];
                    chars[i] = chars[j];
                    chars[j] = temp;
                }
            }
        }
        return new String(chars);
    }
    public static void main(String[] args) {
        String[] string = getString();
        System.out.println(Arrays.toString(string));
        System.out.println("===========================================");
        for (int i = 0; i < string.length; i++) {
            char[] chars = string[i].toCharArray();
            string[i] = sortCharArray(chars);
        }
        String[] strings = sortHead(string);
        System.out.println(Arrays.toString(strings));
    }
}

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

提问太多，页面渲染太慢，为了加快渲染速度，本页最多只显示几条提问。还有 185 条以前的提问，请点击查看

提问之前请登陆

提问已经提交成功，正在审核。请于我的提问处查看提问记录，谢谢