Füllen eines bestimmten String-Formats mit Nullen, wenn es kürzer ist als die erforderliche Länge

Question

Ich versuche ein Programm zu erstellen, das überprüft, ob die Seriennummern des Benutzers gültig sind oder nicht. Es sollte einem bestimmten Format entsprechen. Das Format sollte zwei Zahlen sein, gefolgt von einem Bindestrich, vier Zahlen, einem Punkt, dann vier Zahlen und zwei Zeichen (Hinweis: Zeichen akzeptiert sind nur a, b und c).

Example valid format: 

31-0001.2341ac 
00-9999.0001cb 

Wenn der Seriencode ungültig ist, weil es nicht die erforderliche Länge der Zeichenkette erfüllt hat, soll das Programm am Anfang mit Nullen füllen und der neue Code wird gedruckt.

Ich habe es geschafft, mit dem seriellen Code-Checker mit regulären Ausdrücken zu arbeiten, es überprüft nun korrekt, ob der Code gültig ist oder nicht. Ich finde es jedoch schwierig, wenn ein neuer Code für einen ungültigen Seriencode generiert werden muss. Es ist so, als müsste ich für alle möglichen Kombinationen hart codieren.

Ich habe versucht, diese How to format a Java string with leading zero?, aber ich habe eine harte Zeit, weil mein String-Format hat Strich & Punkt in der Mitte der Zeichenfolge.

Ich bin immer noch ziemlich neu, ich bin noch nicht vertraut mit utils oder Bibliotheken für solche Funktionen. Ich hoffe, dass jemand mir helfen kann, meinen Code zu reparieren, um es einfacher und effizienter zu machen.

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"); 
      } 
     } 
    } 
} 

Answer 1

Grundsätzlich ist Ihre Strategie der Bestimmung, was fehlte ist inkorrekt. Ein anderer Ansatz wäre es, nur so viele Nullen zu füllen, bis die richtige Länge erreicht ist, und dann jedes Zeichen nach Bedarf zu ersetzen, wenn es zu kurz ist oder wenn das Format unterbrochen ist. Beachten Sie auch, dass die ursprüngliche Frage nicht berücksichtigt wurde, wenn die Zeichenfolge zu lang ist. Daher nahm ich an, dass Sie sie der Einfachheit halber nur als Nullen behandeln können. Siehe Codebeispiel mit Beispieleingaben unter JDoodle. Siehe Codebeispiel unten:

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); 
     } 
    } 
    } 
} 

Answer 2

Ihr Problem hat eigentlich zwei Teile hier.

Der erste Teil analysiert den - möglicherweise ungültigen - Eingang.

Der zweite Teil formatiert es mit führenden Nullen.

Der zweite Teil ist ziemlich einfach. Sie erstellen einfach ein Zeichen-Array der Länge 12, füllen es mit Nullen, füllen es mit Ihren Daten (beginnend am Ende), erstellen drei Strings daraus und einfach s0 + "-" + s1 + "." + s0.

Der erste Teil kann so einfach oder so schwierig sein, wie Sie möchten. Sind - und . signifikante Trennzeichen?

Wenn nicht, entfernen Sie sie einfach aus der Zeichenfolge und Sie haben Ihr Ergebnis (gut, in Char-Array noch konvertiert werden).

Wenn ja, was passiert, wenn diese Begrenzer fehlen? Was passiert, wenn das abgegrenzte Teil länger ist als beabsichtigt? Mein Punkt ist, müssen Sie zuerst Regeln für das Parsen definieren. Sobald Sie dies tun, haben Sie eine gute Idee, wie das Parsen implementiert werden sollte.