首页 > 软件编程 > java > Java银行卡卡号格式校验

Java基于Luhn算法实现银行卡卡号格式校验详解

2026-01-05 08:24:11 作者：牛肉胡辣汤

在金融行业,特别是涉及到银行卡处理的场景中,确保银行卡号的有效性是至关重要的,本文将详细介绍如何使用Java实现基于Luhn算法的银行卡卡号格式校验,有需要的可以了解下

引言

在金融行业，特别是涉及到银行卡处理的场景中，确保银行卡号的有效性是至关重要的。Luhn算法（也称为“模10算法”）是一种简单的校验和算法，用于验证各种识别码，如信用卡号、IMSI号等。本文将详细介绍如何使用Java实现基于Luhn算法的银行卡卡号格式校验。

Luhn算法原理

Luhn算法的基本步骤如下：

从右向左对卡号进行编号，最右边的数字是第1位。

双倍处理所有奇数位置的数字（即第1位、第3位、第5位等），如果结果大于9，则减去9。

求和所有数字。

检查和：如果总和能够被10整除，则卡号有效；否则无效。

Java实现

1. 定义方法

首先，我们需要定义一个方法来实现Luhn算法的校验逻辑。

public class LuhnValidator {

    /**
     * 校验银行卡号是否有效
     *
     * @param cardNumber 银行卡号
     * @return 卡号是否有效
     */
    public static boolean isValidCardNumber(String cardNumber) {
        if (cardNumber == null || !cardNumber.matches("\\d+")) {
            return false;
        }

        int sum = 0;
        boolean isSecond = false;

        for (int i = cardNumber.length() - 1; i >= 0; i--) {
            int digit = cardNumber.charAt(i) - '0';

            if (isSecond) {
                digit *= 2;
            }

            sum += digit > 9 ? digit - 9 : digit;
            isSecond = !isSecond;
        }

        return sum % 10 == 0;
    }
}

2. 测试方法

为了确保我们的实现是正确的，我们可以编写一些测试用例来验证方法的正确性。

public class LuhnValidatorTest {

    public static void main(String[] args) {
        String[] testNumbers = {
            "4111111111111111", // Visa, valid
            "4111111111111112", // Visa, invalid
            "5500000000000004", // MasterCard, valid
            "5500000000000000", // MasterCard, invalid
            "6011000000000004", // Discover, valid
            "6011000000000000", // Discover, invalid
            "378282246310005",  // American Express, valid
            "378282246310006"   // American Express, invalid
        };

        for (String number : testNumbers) {
            System.out.println("Card Number: " + number + " is " + (LuhnValidator.isValidCardNumber(number) ? "valid" : "invalid"));
        }
    }
}

3. 运行测试

运行上述测试代码，输出结果如下：

Card Number: 4111111111111111 is valid
Card Number: 4111111111111112 is invalid
Card Number: 5500000000000004 is valid
Card Number: 5500000000000000 is invalid
Card Number: 6011000000000004 is valid
Card Number: 6011000000000000 is invalid
Card Number: 378282246310005 is valid
Card Number: 378282246310006 is invalid

方法补充

Luhn算法（也称为模10算法）是一种简单的校验和算法，常用于验证各种识别号码，如信用卡号。以下是一个Java示例代码，展示了如何使用Luhn算法来校验银行卡号的格式。

Java 示例代码

public class LuhnAlgorithm {

    /**
     * 检查给定的卡号是否通过Luhn算法校验。
     *
     * @param cardNumber 卡号字符串
     * @return 如果卡号通过校验则返回true，否则返回false
     */
    public static boolean isValidCardNumber(String cardNumber) {
        if (cardNumber == null || !cardNumber.matches("\\d+")) {
            return false;
        }

        int sum = 0;
        boolean isSecond = false;

        for (int i = cardNumber.length() - 1; i >= 0; i--) {
            int digit = cardNumber.charAt(i) - '0';

            if (isSecond) {
                digit *= 2;
            }

            sum += digit / 10;
            sum += digit % 10;

            isSecond = !isSecond;
        }

        return (sum % 10 == 0);
    }

    public static void main(String[] args) {
        String cardNumber1 = "4111111111111111"; // 测试有效的Visa卡号
        String cardNumber2 = "6011000990139424"; // 测试有效的Discover卡号
        String cardNumber3 = "1234567890123456"; // 测试无效的卡号

        System.out.println("Card Number: " + cardNumber1 + " is valid: " + isValidCardNumber(cardNumber1));
        System.out.println("Card Number: " + cardNumber2 + " is valid: " + isValidCardNumber(cardNumber2));
        System.out.println("Card Number: " + cardNumber3 + " is valid: " + isValidCardNumber(cardNumber3));
    }
}

代码解释

输入验证：首先检查输入的卡号是否为非空且只包含数字。如果不是，则直接返回false。

Luhn算法实现：

从卡号的最后一个数字开始，向前遍历每个数字。
对于每第二个数字（从右向左数），将其乘以2。
如果乘以2后的结果大于9，则将其拆分为两个数字并相加（例如，8 * 2 = 16，1 + 6 = 7）。
将所有处理后的数字相加，得到总和。

校验：如果总和能被10整除，则卡号通过Luhn算法校验，返回true；否则返回false。

测试

在main方法中，我们测试了三个不同的卡号：

4111111111111111：一个有效的Visa卡号。
6011000990139424：一个有效的Discover卡号。
1234567890123456：一个无效的卡号。

运行程序后，输出结果将显示每个卡号是否通过Luhn算法校验。

Luhn算法（也称为模10算法）是一种简单的校验和算法，用于验证各种识别号码，如信用卡号码。该算法通过一个特定的公式来计算校验位，以确保号码的有效性。

下面是一个使用Java实现的Luhn算法示例，用于验证银行卡卡号是否有效：

Java代码实现

public class LuhnAlgorithm {

    /**
     * 验证卡号是否有效
     *
     * @param cardNumber 卡号字符串
     * @return 如果卡号有效返回true，否则返回false
     */
    public static boolean isValid(String cardNumber) {
        if (cardNumber == null || !cardNumber.matches("\\d+")) {
            return false;
        }

        int sum = 0;
        boolean isSecond = false;

        for (int i = cardNumber.length() - 1; i >= 0; i--) {
            int digit = cardNumber.charAt(i) - '0';

            if (isSecond) {
                digit *= 2;
            }

            sum += digit > 9 ? digit - 9 : digit;
            isSecond = !isSecond;
        }

        return sum % 10 == 0;
    }

    public static void main(String[] args) {
        String cardNumber = "4111111111111111"; // 测试卡号
        boolean isValid = isValid(cardNumber);
        System.out.println("Card number " + cardNumber + " is " + (isValid ? "valid" : "invalid"));
    }
}

代码解释

1.输入验证：if (cardNumber == null || !cardNumber.matches("\\d+"))：首先检查输入的卡号是否为非空且只包含数字。

2.初始化变量：

int sum = 0：用于存储所有数字的总和。
boolean isSecond = false：用于标记当前处理的数字是否是偶数位置的数字（从右向左计数）。

3.遍历卡号：

for (int i = cardNumber.length() - 1; i >= 0; i--)：从卡号的最后一个字符开始向前遍历。
int digit = cardNumber.charAt(i) - '0'：将当前字符转换为整数。
if (isSecond)：如果当前数字是偶数位置的数字，则将其乘以2。
sum += digit > 9 ? digit - 9 : digit：如果乘以2后的数字大于9，则减去9后再加到总和中，否则直接加到总和中。
isSecond = !isSecond：切换isSecond标志，以便下一次处理奇数位置的数字。

4.校验结果：return sum % 10 == 0：如果总和能被10整除，则卡号有效，否则无效。

5.测试：

String cardNumber = "4111111111111111"：测试卡号。
boolean isValid = isValid(cardNumber)：调用isValid方法验证卡号。
System.out.println("Card number " + cardNumber + " is " + (isValid ? "valid" : "invalid"))：输出验证结果。

这个实现简单明了，适用于大多数需要验证银行卡号有效性的场景。

到此这篇关于Java基于Luhn算法实现银行卡卡号格式校验详解的文章就介绍到这了,更多相关Java银行卡卡号格式校验内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！