Java 如果特定字符串格式短于所需长度，则用零填充该格式

我正在尝试创建一个程序来检查用户的串行代码是否有效。它应该符合特定的格式。格式应为两个数字，后跟破折号、四个数字、一个点，然后是四个数字和两个字符（注意：接受的字符仅为a、b和c）

如果串行代码无效，因为它不符合所需的字符串长度，则程序应在开始处将其填充为零，并打印新代码

我设法使用正则表达式与串行代码检查器一起工作，它现在可以正确地验证代码是否有效。但是，当它需要为无效的串行代码生成新代码时，我发现它很有挑战性。就像我需要对所有可能的组合进行硬编码一样

我试过这个，但是我很难，因为我的字符串格式在字符串的中间有点和点。< /P> 我还是个新手，我还不熟悉这些函数的UTIL或库。我希望有人能帮助我修复代码，使其更简单、更高效

import java.util.Scanner;

public class SerialCheck {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("How many serial numbers would you like to check: ");
        int length = sc.nextInt();
        int valid = 0;

        String[] sSerials = new String[length];

        for (int nCtr = 0; nCtr < length; nCtr++) {
            System.out.print("Enter Serial " + (nCtr + 1) + ": ");
            sSerials[nCtr] = sc.next();
        }

        System.out.println();
        System.out.println("The following were added: ");
        for (int nCtr = 0; nCtr < length; nCtr++) {
            System.out.println(sSerials[nCtr]);
        }

        System.out.println();
        System.out.println("Comments\t" + "New Code");
        for (int nCtr = 0; nCtr < length; nCtr++) {
            boolean isValid = sSerials[nCtr].matches("[0-9]{2}-[0-9]{4}\\.[0-9]{4}[abc0-9]{2}");
            boolean isMissing = sSerials[nCtr].matches("[0-9]{2}-[0-9]{4}\\.[0-9]{1}[abc0-9]{2}") ||
                sSerials[nCtr].matches("[0-9]{2}-[0-9]{4}\\.[0-9]{2}[abc0-9]{2}") ||
                sSerials[nCtr].matches("[0-9]{2}-[0-9]{4}\\.[0-9]{3}[abc0-9]{2}");
            boolean isMissing1 = sSerials[nCtr].matches("[0-9]{2}-[0-9]{1}\\.[0-9]{4}[abc0-9]{2}") ||
                sSerials[nCtr].matches("[0-9]{2}-[0-9]{2}\\.[0-9]{4}[abc0-9]{2}") ||
                sSerials[nCtr].matches("[0-9]{2}-[0-9]{3}\\.[0-9]{4}[abc0-9]{2}");
            boolean isMissing2 = sSerials[nCtr].matches("[0-9]{0}-[0-9]{4}\\.[0-9]{4}[abc0-9]{2}") ||
                sSerials[nCtr].matches("[0-9]{1}-[0-9]{4}\\.[0-9]{4}[abc0-9]{2}");

            if (isValid) {
                System.out.println("Valid\t\t" + sSerials[nCtr]);
            } else if (isMissing) {
                System.out.println("Invalid\t\t" + sSerials[nCtr].substring(0, 8) + "0000".substring(0, 14 - sSerials[nCtr].length()) + sSerials[nCtr].substring(8));
            } else if (isMissing1) {
                System.out.println("Invalid\t\t" + sSerials[nCtr].substring(0, 3) + "0000".substring(0, 14 - sSerials[nCtr].length()) + sSerials[nCtr].substring(3));
            } else if (isMissing2) {
                System.out.println("Invalid\t\t" + sSerials[nCtr].substring(0, 0) + "00".substring(0, 14 - sSerials[nCtr].length()) + sSerials[nCtr].substring(0));
            } else {
                System.out.println("Invalid\t");
            }
        }
    }
}

import java.util.Scanner；
公共类串行检查{
公共静态void main（字符串[]args）{
扫描仪sc=新的扫描仪（System.in）；
System.out.print（“您希望检查多少序列号：”）；
int length=sc.nextInt（）；
int valid=0；
字符串[]s字符串=新字符串[长度]；
对于（int-nCtr=0；nCtr

您的问题实际上有两部分

第一部分是解析可能无效的输入

第二部分是使用前导零对其进行格式化

第二部分相当简单。您只需创建一个长度为12的字符数组，用零填充它，然后用数据填充它（从末尾开始），用它创建三个字符串，然后只需

s0+“-”+s1+”+s0

第一部分可以是简单的，也可以是困难的。

-

和

是有效的分隔符吗

如果没有，只需从字符串中删除它们，就可以得到结果（好吧，现在还需要转换为char数组）

---

如果是，如果缺少这些分隔符会发生什么情况？如果分隔的部分比预期的长，会发生什么情况？我的观点是，首先需要定义解析规则。一旦你这样做了，你就会对解析应该如何实现有一个很好的想法。

基本上，你确定具体缺少什么的策略是不正确的。另一种不同的方法是，只填充全部零，直到获得正确的长度，然后根据需要替换每个字符（如果太短或格式被破坏）。还要注意，原始问题没有考虑字符串是否太长，因此为了简单起见，我假设可以将其视为全零。另请参见中带有示例输入的代码示例。请参见下面的代码示例：

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.Scanner;

public class SerialCheck {

  private static String leftPadWithX(String shortStr) {
    StringBuilder paddableString = new StringBuilder(shortStr);
    for (int i = 14 - shortStr.length(); i > 0; --i) {
      paddableString.insert(0, 'X');
    }
    assert paddableString.length() == 14;
    return paddableString.toString();
  }

  private static String fix(String broken) {
    assert broken.length() == 14;
    StringBuilder mutableBroken = new StringBuilder(broken);
    for(int i = 0; i < 14; ++i) {
      // not exactly a char, but need a 1 element string for regex matching
      String brokenChar = "" + mutableBroken.charAt(i);
      if (i < 2 && !Pattern.matches("\\d", brokenChar)) {
        mutableBroken.replace(i, i+1, "0");
      } else if (i == 2 && !Pattern.matches("-", brokenChar)) {
        mutableBroken.replace(i, i+1, "-");
      } else if (i > 2 && i < 7 && !Pattern.matches("\\d", brokenChar)) {
        mutableBroken.replace(i, i+1, "0");
      } else if (i == 7 && !Pattern.matches("\\.", brokenChar)) {
        mutableBroken.replace(i, i+1, ".");
      } else if (i > 7 && i < 12 && !Pattern.matches("\\d", brokenChar)) {
        mutableBroken.replace(i, i+1, "0");
      } else if (i >= 12 && i < 14 && !Pattern.matches("[abc\\d]", brokenChar)) {
        mutableBroken.replace(i, i+1, "0");
      }
    }
    return mutableBroken.toString();
  }

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    System.out.print("How many serial numbers would you like to check: ");
    int length = sc.nextInt();
    int valid = 0;

    String[] sSerials = new String[length];

    for (int nCtr = 0; nCtr < length; nCtr++) {
      System.out.print("Enter Serial " + (nCtr + 1) + ": ");
      sSerials[nCtr] = sc.next();
    }

    System.out.println();
    System.out.println("The following were added: ");
    for (int nCtr = 0; nCtr < length; nCtr++) {
      System.out.println(sSerials[nCtr]);
    }

    System.out.println();
    System.out.println("Comments\t" + "New Code");
    for (int nCtr = 0; nCtr < length; nCtr++) {
      boolean isValid = sSerials[nCtr].matches("[0-9]{2}-[0-9]{4}\\.[0-9]{4}[abc0-9]{2}");
    if (isValid) {
      System.out.println("Valid\t\t" + sSerials[nCtr]);
    } else if (sSerials[nCtr].length() > 14) {
      // if too long, create all padded zeros
      System.out.println("Invalid\tToo long\t00-0000.000000");
    } else if (sSerials[nCtr].length() < 14) {
      // too short, pad with 0s unconditionally and fix format
      String xPadded = leftPadWithX(sSerials[nCtr]);
      String fixed = fix(xPadded);
      System.out.println("Invalid\tToo short\t" + fixed);
    } else {
      // right length but bad format
      String fixed = fix(sSerials[nCtr]);
      System.out.println("Invalid\tBad format\t" + fixed);
      }
    }
  }
}

import java.util.regex.Matcher；
导入java.util.regex.Pattern；
导入java.util.Scanner；
公共类串行检查{
私有静态字符串leftPadWithX（字符串shortStr）{
StringBuilder paddableString=新的StringBuilder（shortStr）；
对于（int i=14-shortStr.length（）；i>0；--i）{
插入（0，'X'）；
}
断言paddableString.length（）==14；
返回paddableString.toString（）；
}
私有静态字符串修复（字符串已断开）{
断言已断开。长度（）==14；
StringBuilder MutableBreaked=新StringBuilder（已断开）；
对于（int i=0；i<14；++i）{
//不完全是字符，但需要1个元素的字符串进行正则表达式匹配
String brokenChar=“”+可变断开.charAt（i）；
如果（i<2&！Pattern.matches（“\\d”，brokenChar））{
可变断路。替换（i，i+1，“0”）；
}else if（i==2&&！Pattern.matches（“-”，brokenChar））{
可变断路。替换（i，i+1，“-”；
}否则如果
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.Scanner;

public class SerialCheck {

  private static String leftPadWithX(String shortStr) {
    StringBuilder paddableString = new StringBuilder(shortStr);
    for (int i = 14 - shortStr.length(); i > 0; --i) {
      paddableString.insert(0, 'X');
    }
    assert paddableString.length() == 14;
    return paddableString.toString();
  }

  private static String fix(String broken) {
    assert broken.length() == 14;
    StringBuilder mutableBroken = new StringBuilder(broken);
    for(int i = 0; i < 14; ++i) {
      // not exactly a char, but need a 1 element string for regex matching
      String brokenChar = "" + mutableBroken.charAt(i);
      if (i < 2 && !Pattern.matches("\\d", brokenChar)) {
        mutableBroken.replace(i, i+1, "0");
      } else if (i == 2 && !Pattern.matches("-", brokenChar)) {
        mutableBroken.replace(i, i+1, "-");
      } else if (i > 2 && i < 7 && !Pattern.matches("\\d", brokenChar)) {
        mutableBroken.replace(i, i+1, "0");
      } else if (i == 7 && !Pattern.matches("\\.", brokenChar)) {
        mutableBroken.replace(i, i+1, ".");
      } else if (i > 7 && i < 12 && !Pattern.matches("\\d", brokenChar)) {
        mutableBroken.replace(i, i+1, "0");
      } else if (i >= 12 && i < 14 && !Pattern.matches("[abc\\d]", brokenChar)) {
        mutableBroken.replace(i, i+1, "0");
      }
    }
    return mutableBroken.toString();
  }

  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    System.out.print("How many serial numbers would you like to check: ");
    int length = sc.nextInt();
    int valid = 0;

    String[] sSerials = new String[length];

    for (int nCtr = 0; nCtr < length; nCtr++) {
      System.out.print("Enter Serial " + (nCtr + 1) + ": ");
      sSerials[nCtr] = sc.next();
    }

    System.out.println();
    System.out.println("The following were added: ");
    for (int nCtr = 0; nCtr < length; nCtr++) {
      System.out.println(sSerials[nCtr]);
    }

    System.out.println();
    System.out.println("Comments\t" + "New Code");
    for (int nCtr = 0; nCtr < length; nCtr++) {
      boolean isValid = sSerials[nCtr].matches("[0-9]{2}-[0-9]{4}\\.[0-9]{4}[abc0-9]{2}");
    if (isValid) {
      System.out.println("Valid\t\t" + sSerials[nCtr]);
    } else if (sSerials[nCtr].length() > 14) {
      // if too long, create all padded zeros
      System.out.println("Invalid\tToo long\t00-0000.000000");
    } else if (sSerials[nCtr].length() < 14) {
      // too short, pad with 0s unconditionally and fix format
      String xPadded = leftPadWithX(sSerials[nCtr]);
      String fixed = fix(xPadded);
      System.out.println("Invalid\tToo short\t" + fixed);
    } else {
      // right length but bad format
      String fixed = fix(sSerials[nCtr]);
      System.out.println("Invalid\tBad format\t" + fixed);
      }
    }
  }
}