Java 生成验证码的五种方式、源码、过程、结果

南极

已于 2025-04-14 19:46:25 修改

阅读量4.7k

点赞数 23

分类专栏： Java 文章标签： java

于 2024-08-09 09:37:41 首次发布

南极

本文链接：https://blog.csdn.net/ouhexie/article/details/141051984

版权

Java 专栏收录该内容

3 篇文章

订阅专栏

简介

使用Java基本的逻辑和方法生成所需要的验证码，且生成的验证码包含大小写字母和数字，当然啦，也有纯数字的验证码。每一个方式都有详细的注释解析😆😆😆

第一种方式 Random 随机数类生成验证码

/**
 * @version 1.0
 * @ClassName LetterAndNumberRandom
 * @Description 随机生成一个大写字母和小写字母，以及一个0到9之间的数字。
 * @Author 南极
 * @Date 2024/3/21 8:45
 */
public class LetterAndNumberRandom {

    public static void main(String[] args) {
        //控制验证码的长度
        int lengthRandom = 5;

        //定义一个StringBuffer减少字符串拼接的次数
        StringBuilder randomCode = new StringBuilder();

        //验证码多长循环多长
        for (int i = 0; i < lengthRandom; i++) {
            //大写字母范围的ASCII码
            int upperLetter = (int) (Math.random() * (90 - 65 + 1) + 65);
            //小写字母范围的ASCII码
            int lowerLetter = (int) (Math.random() * (122 - 97 + 1) + 97);
            //生成0到9之间的ASCII码
            int number = (int) (Math.random() * (57 - 48 + 1) + 48);
            //定义验证码的判断规则
            int rand = (int) (Math.random() * 3);
            //switch结构实现验证码的追加
            switch (rand) {
                case 0:
                    randomCode.append((char) upperLetter);
                    break;
                case 1:
                    randomCode.append((char) lowerLetter);
                    break;
                case 2:
                    randomCode.append((char) number);
                    break;
            }
        }
        //将StringBuffer转换成String类型使用分割方法，获取5位验证码
        String[] splitCode = randomCode.toString().split("");

        //这种方式：Arrays.toString(splitCode)  或者for循环
        System.out.print("获取五位随机数作为验证码(包括数字和字母大小写)：");
        //for循环或者上述方式
        for (String s : splitCode) {
            System.out.print(s + "   ");
        }

        System.out.println();
        for (int i = 0; i < splitCode.length; i++) {
            //将字符串类型的数字下标i一个一个转换成char类型
            char charCode = splitCode[i].charAt(0);
            String str = "";
            //判断验证码的类型
            if (charCode >= 'A' && charCode <= 'Z') {
                str = "字母大写";
            } else if (charCode >= 'a' && charCode <= 'z') {
                str = "字母小写";
            } else {
                str = "数字";
            }
            System.out.print("验证码第" + (i + 1) + "位是" + str + "     ");
        }
    }
}

第一种方式，是在main方法中生成的验证码，想要获取最终结果的小伙伴，可以把最后的for循环删除，然后把里面的代码提取成一个方法哦😊😊😊

运行结果

第二种方式洗牌算法实现验证码

import java.util.Random;

/**
 * @version 1.0
 * @ClassName VerificationCode验证码类
 * @Description 随机5位数的验证码
 * @Author 南极
 * @Date 2024 - 04 - 19 - 8:28
 */
public class VerificationCode {
    public static void main(String[] args) {
        // 调用静态的5位数验证码的方法，获取一个5位数的验证码
        String verifyCode = verificationCode(5);
        // 打印验证码
        System.out.println("您获取的验证码是：" + verifyCode);
        // 判断每一个字符是否为数字或字母
        printCaseOrNumber(verifyCode);
    }

    /**
     * 随机生成包含大小写字母和数字的验证码
     *
     * @param length 验证码的长度
     * @return 返回最后生成的验证码
     */
    public static String verificationCode(int length) {
        // 创建一个StringBuffer类用于保存验证码
        StringBuilder strCode = new StringBuilder();
        // 循环添加字母，26个小写字母，26个大写字母，10个数字
        for (int i = 0; i < 62; i++) {
            // 判断是否为小写字母
            if (i < 26) {
                strCode.append(((char) ('a' + i)));
            } else if (i < 52) {
                strCode.append(((char) ('A' + i - 26)));
            } else {
                strCode.append((i - 52));
            }
        }
        // 获取字符串长度
        int strLength = strCode.length();

        //确保验证码的长度在62位之内
        if (length > strLength) {
            throw new RuntimeException("验证码的长度不能超过62位");
        }

        // 创建随机类对象
        Random r = new Random();
        // 使用洗牌算法的逻辑，打乱StringBuilder对象
        for (int i = 0; i < strLength; i++) {
            // 获取随机索引
            int tempIndex = r.nextInt(strCode.length());
            // 交换的中间变量
            char temp = strCode.charAt(tempIndex);
            // 设置随机变量值为下标 i 的值
            strCode.setCharAt(tempIndex, strCode.charAt(i));
            // 那么下标 i 的值就等于随机下标的值
            strCode.setCharAt(i, temp);
        }
        return strCode.substring(0, length);
    }

    /**
     * 判断验证码是否为数字或字母
     *
     * @param str 传入的字符串
     */
    public static void printCaseOrNumber(String str) {
        // 把传入的字符串每一个都拆分成一个char类型数组的元素
        char[] charArray = str.toCharArray();

        // 判断每一个元素是否为数字或字母
        for (int i = 0; i < charArray.length; i++) {
            char ch = charArray[i];
            if (ch >= 65 && ch <= 91) {
                System.out.print("第" + (i + 1) + "个数字是大写字母");
            } else if (ch >= 97 && ch <= 122) {
                System.out.print("第" + (i + 1) + "个数字是小写字母");
            } else {
                System.out.print("第" + (i + 1) + "个数字是数字");
            }
            System.out.print("\t\t");
        }
    }
}

这种方式实现的验证码很新奇，基本是不常见的验证码，会发现他生成的验证码出奇的乱，很少见😁😁😁

运行结果

第三种方式我称之为简单方式哦

import java.util.Random;

/**
 * @version 1.0
 * @ClassName SimplenessCode
 * @Description 简单方式生成验证码
 * @Author NanJi
 * @Date 2024/8/9 - 8:51
 */
public class Captcha {public static void main(String[] args) {
        // 验证码的长度，后续要获取多长的验证码只需要修改一下这个变量值即可
        int length = 5;
        String code = getCode(length);
        System.out.println(code);
    }

    /**
     * 获取包含大小写字母和数字的验证码，长度无限制
     *
     * @param length 验证码的长度，长度小于 1 返回 null
     * @return 返回验证码
     */
    public static String getCode(int length) {
        if (length < 1) {
            System.out.println("验证码长度小于 1");
            return null;
        }
        // 创建随机数生成器对象
        Random r = new Random();
        // 创建StringBuilder对象高效存储字符串
        StringBuilder sb = new StringBuilder();
        // 定义一个要随机的验证码字符串
        String str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
        // 循环多少次，生成多长的验证码
        for (int i = 0; i < length; i++) {
            // 获取随机数
            int index = r.nextInt(str.length());
            // 获取随机字符
            char c = str.charAt(index);
            // 将随机字符添加到StringBuilder对象中
            sb.append(c);
        }
        // 打印验证码，这里可以直接输出StringBuilder对象是因为他默认调用了toString()方法
        //System.out.println(sb);
        //返回生成的验证码
        return sb.toString();
    }
}

这是非常简单的一个方式啦，其他的方式看不懂的小伙伴，就可以使用这个哈🤗🤗🤗

运行结果

第四种方式纯数字验证码

/**
 * @version 1.0
 * @ClassName NumberCode
 * @Description 生成存数字的验证码
 * @Author NanJi
 * @Date 2024/8/9 - 9:06
 */
public class NumberCode {
    public static void main(String[] args) {
        System.out.println(numberCode(5));
    }

    /**
     * 生成指定长度的数字验证码
     *
     * @param length 验证码的长度
     * @return 返回生成的验证码
     */
    private static String numberCode(int length) {
        // 这里可以看到生成的随机数是什么样子的
        double r = Math.random();
        System.out.println(r);
        // 加上一个""双引号是为了让数字和字符串拼接成新的字符串，这样子就可以截取数字了
        return (r + "").substring(2, 2 + length);
    }
}

这个方式可以生成一个纯数字的验证码，而且效率非常快，美中不足的是，它只能16位，但是也够用了，一般验证码用不到那么长🤔🤔🤔

运行结果

第五种方式纯数字验证码，可以很长

/**
 * @version 1.0
 * @ClassName NumberCode
 * @Description 生成存数字的验证码
 * @Author NanJi
 * @Date 2024/8/9 - 9:06
 */
public class NumberCode {
    public static void main(String[] args) {
        //获取验证码
        String code = getCode(500);
        System.out.println("纯数字验证码：" + code);
    }

    /**
     * 获取纯数字验证码，长度小于 1 位返回 null 值
     *
     * @param length 验证码的长度
     * @return 返回验证码
     */
    public static String getCode(int length) {
        //如果验证码长度小于 1 位返回 null
        if (length <= 1) {
            System.out.println("验证码长度不能小于1位");
            return null;
        }
        //创建StringBuilder高效处理字符串，默认初始化验证码长度的容量
        StringBuilder sCode = new StringBuilder(length);
        //定义Random类生成随机数
        Random r = new Random();
        //循环添加验证码
        for (int i = 1; i <= length; i++) {
            //获取0-9的随机数
            int number = r.nextInt(10);
            sCode.append(number);
        }
        return sCode.toString();
    }
}