Java车牌号生成器

Java车牌号生成器提供了以下核心功能：

主要特性‌：

    支持生成普通车牌、新能源车牌、警车车牌等多种类型
    内置车牌号格式验证功能，确保生成的车牌符合国家标准
    提供唯一性保证，避免生成重复车牌号
    支持批量生成和序列号生成模式

技术实现‌：

    使用枚举类型管理不同的车牌类型
    实现线程安全的计数器，支持并发环境使用
    提供地区过滤和自定义规则生成功能

使用示例‌：
可以直接运行主类查看各种车牌类型的生成演示，包括格式校验和统计信息显示

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>license-plate-generator</artifactId>
    <version>1.0.0</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
    </plugin>
        </plugins>
    </build>
</project>

package com.example;

import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 车牌号生成器工具类
 * 支持普通车牌、新能源车牌、警车车牌等多种类型生成
 */
public class LicensePlateGenerator {
    
    // 省份简称
    private static final String[] PROVINCES = {
        "京", "津", "沪", "渝", "冀", "豫", "云", "辽", "黑",
        "湘", "皖", "鲁", "新", "苏", "浙", "赣", "鄂",
        "桂", "甘", "晋", "蒙", "陕", "吉", "闽", "贵",
        "粤", "青", "藏", "川", "宁", "琼"
    };
    
    // 城市字母代码（排除I和O）
    private static final char[] CITY_CODES = {
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
        'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R',
        'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
    };
    
    // 数字和字母字符集（排除I和O）
    private static final char[] ALPHANUMERIC = {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
        'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
        'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R',
        'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'
    };
    
    // 特殊车牌后缀
    private static final String[] SPECIAL_SUFFIXES = {"挂", "学", "警", "港", "澳"};
    
    private static final Random random = new Random();
    private static final AtomicInteger sequenceCounter = new AtomicInteger(1);
    
    private LicensePlateGenerator() {
        // 私有构造函数，工具类
    }
    
    /**
     * 生成普通车牌号（7位格式）
     */
    public static String generateNormalPlate() {
        StringBuilder plate = new StringBuilder();
        
        // 省份简称
        plate.append(PROVINCES[random.nextInt(PROVINCES.length)]);
        
        // 城市代码
        plate.append(CITY_CODES[random.nextInt(CITY_CODES.length)]);
        
        // 5位字母数字组合
        for (int i = 0; i < 5; i++) {
            plate.append(ALPHANUMERIC[random.nextInt(ALPHANUMERIC.length)]);
        }
        
        return plate.toString();
    }
    
    /**
     * 生成带特殊后缀的车牌号
     */
    public static String generateSpecialPlate() {
        StringBuilder plate = new StringBuilder();
        
        // 省份简称
        plate.append(PROVINCES[random.nextInt(PROVINCES.length)]);
        
        // 城市代码
        plate.append(CITY_CODES[random.nextInt(CITY_CODES.length)]);
        
        // 4位字母数字组合
        for (int i = 0; i < 4; i++) {
            plate.append(ALPHANUMERIC[random.nextInt(ALPHANUMERIC.length)]);
        }
        
        // 特殊后缀
        plate.append(SPECIAL_SUFFIXES[random.nextInt(SPECIAL_SUFFIXES.length)]);
        
        return plate.toString();
    }
    
    /**
     * 生成新能源车牌号
     */
    public static String generateNewEnergyPlate() {
        StringBuilder plate = new StringBuilder();
        
        // 省份简称
        plate.append(PROVINCES[random.nextInt(PROVINCES.length)]);
        
        // 新能源标识
        plate.append(random.nextBoolean() ? 'D' : 'F');
        
        // 6位字母数字组合
        for (int i = 0; i < 6; i++) {
            plate.append(ALPHANUMERIC[random.nextInt(ALPHANUMERIC.length)]);
        }
        
        return plate.toString();
    }
    
    /**
     * 生成警车车牌号
     */
    public static String generatePolicePlate() {
        StringBuilder plate = new StringBuilder();
        
        // 省份简称
        plate.append(PROVINCES[random.nextInt(PROVINCES.length)]);
        
        // 警车标识
        plate.append(CITY_CODES[random.nextInt(CITY_CODES.length)]);
        
        // 4位数字
        for (int i = 0; i < 4; i++) {
            plate.append(random.nextInt(10));
        }
        
        // 警字后缀
        plate.append("警");
        
        return plate.toString();
    }
    
    /**
     * 生成序列号车牌（基于递增计数器）
     */
    public static String generateSequentialPlate(String prefix) {
        int sequence = sequenceCounter.getAndIncrement();
        return String.format("%s%05d", prefix, sequence);
    }
    
    /**
     * 批量生成车牌号
     */
    public static List<String> generateBatchPlates(int count, PlateType type) {
        List<String> plates = new ArrayList<>();
        Set<String> generated = new HashSet<>();
        
        while (plates.size() < count) {
            String plate = generatePlateByType(type);
            if (generated.add(plate)) {
                plates.add(plate);
            }
        }
        
        return plates;
    }
    
    /**
     * 根据类型生成车牌
     */
    private static String generatePlateByType(PlateType type) {
        switch (type) {
            case NORMAL:
                return generateNormalPlate();
            case SPECIAL:
                return generateSpecialPlate();
            case NEW_ENERGY:
                return generateNewEnergyPlate();
            case POLICE:
                return generatePolicePlate();
            default:
                return generateNormalPlate();
        }
    }
    
    /**
     * 车牌号校验
     */
    public static boolean validatePlate(String plate) {
        if (plate == null || plate.isEmpty()) {
            return false;
        }
        
        // 普通车牌正则表达式
        String normalRegex = "京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼港澳使领警学][A-Z][A-HJ-NP-Z0-9]{5}$";
        
        // 特殊车牌正则表达式
        String specialRegex = "京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}[A-Z0-9]{4}[A-Z0-9挂学警港澳]{1}$";
        
        // 新能源车牌正则表达式
        String newEnergyRegex = "京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼][DF][A-HJ-NP-Z0-9]{6}$";
        
        // 警车车牌正则表达式
        String policeRegex = "京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼][A-Z][0-9]{4}警$";
        
        return plate.matches(normalRegex) ||
               plate.matches(specialRegex) ||
               plate.matches(newEnergyRegex) ||
               plate.matches(policeRegex);
    }
    
    /**
     * 车牌类型枚举
     */
    public enum PlateType {
        NORMAL,      // 普通车牌
        SPECIAL,     // 特殊车牌
        NEW_ENERGY, // 新能源车牌
        POLICE       // 警车车牌
    }
    
    /**
     * 主方法 - 演示使用
     */
    public static void main(String[] args) {
        System.out.println("=== 车牌号生成器演示 ===");
        
        // 生成不同类型的车牌
        System.out.println("\n普通车牌:");
        for (int i = 0; i < 5; i++) {
            String plate = generateNormalPlate();
            System.out.println(plate + " - 校验: " + validatePlate(plate));
        }
        
        System.out.println("\n新能源车牌:");
        for (int i = 0; i < 3; i++) {
            String plate = generateNewEnergyPlate();
            System.out.println(plate + " - 校验: " + validatePlate(plate));
        }
        
        System.out.println("\n警车车牌:");
        for (int i = 0; i < 2; i++) {
            String plate = generatePolicePlate();
            System.out.println(plate + " - 校验: " + validatePlate(plate));
        }
        
        System.out.println("\n批量生成:");
        List<String> batch = generateBatchPlates(10, PlateType.NORMAL);
        for (String plate : batch) {
            System.out.println(plate + " - 校验: " + validatePlate(plate));
        }
    }
}

package com.example;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 高级车牌号生成器
 * 支持自定义规则、唯一性保证、地区过滤等功能
 */
public class AdvancedLicensePlateGenerator {
    
    private static final Map<String, AtomicLong> regionCounters = new ConcurrentHashMap<>();
    private static final Set<String> generatedPlates = Collections.synchronizedSet(new HashSet<>());
    
    /**
     * 生成唯一车牌号（确保不重复）
     */
    public static String generateUniquePlate(PlateType type) {
        String plate;
        int attempts = 0;
        
        do {
            plate = generatePlateByType(type);
            attempts++;
            if (attempts > 1000) {
                throw new IllegalStateException("无法生成唯一车牌号，请检查生成规则");
            }
        } while (!generatedPlates.add(plate));
        
        return plate;
    }
    
    /**
     * 生成特定地区的车牌号
     */
    public static String generateRegionalPlate(String province, PlateType type) {
        StringBuilder plate = new StringBuilder();
        
        // 验证省份简称
        if (!isValidProvince(province)) {
            throw new IllegalArgumentException("无效的省份简称: " + province);
        }
        
        plate.append(province);
        
        switch (type) {
            case NORMAL:
                plate.append(CITY_CODES[random.nextInt(CITY_CODES.length)]);
                for (int i = 0; i < 5; i++) {
                    plate.append(ALPHANUMERIC[random.nextInt(ALPHANUMERIC.length)]);
                break;
                
            case NEW_ENERGY:
                plate.append(random.nextBoolean() ? 'D' : 'F');
                for (int i = 0; i < 6; i++) {
                    plate.append(ALPHANUMERIC[random.nextInt(ALPHANUMERIC.length)]);
                break;
                
            default:
                plate.append(generatePlateByType(type));
        }
        
        return plate.toString();
    }
    
    /**
     * 生成带校验码的车牌号
     */
    public static String generatePlateWithChecksum(String province, char cityCode) {
        StringBuilder plate = new StringBuilder();
        plate.append(province).append(cityCode);
        
        // 生成4位主体
        for (int i = 0; i < 4; i++) {
            plate.append(ALPHANUMERIC[random.nextInt(ALPHANUMERIC.length)]);
        }
        
        // 计算校验码（最后一位）
        String partialPlate = plate.toString();
        char checksum = calculateChecksum(partialPlate);
        plate.append(checksum);
        
        return plate.toString();
    }
    
    /**
     * 计算车牌校验码
     */
    private static char calculateChecksum(String partialPlate) {
        int sum = 0;
        for (char c : partialPlate.toCharArray()) {
            sum += Character.getNumericValue(c);
        }
        return ALPHANUMERIC[sum % ALPHANUMERIC.length];
    }
    
    /**
     * 验证省份简称是否有效
     */
    private static boolean isValidProvince(String province) {
        for (String p : LicensePlateGenerator.PROVINCES) {
            if (p.equals(province)) {
                return true;
            }
        }
        return false;
    }
    
    /**
     * 获取车牌号统计信息
     */
    public static void printStatistics() {
        System.out.println("\n=== 车牌生成统计 ===");
        System.out.println("已生成车牌总数: " + generatedPlates.size());
        
        Map<String, Integer> provinceStats = new HashMap<>();
        for (String plate : generatedPlates) {
            String province = plate.substring(0, 1);
            provinceStats.put(province, provinceStats.getOrDefault(province, 0) + 1);
        }
        
        System.out.println("各省份分布:");
        provinceStats.entrySet().stream()
            .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
            .forEach(entry -> System.out.println("  " + entry.getKey() + ": " + entry.getValue() + "个");
    }
    
    private static String generatePlateByType(LicensePlateGenerator.PlateType type) {
        // 委托给主生成器
        return LicensePlateGenerator.generatePlateByType(type);
    }
    
    private static final Random random = new Random();
}