Wie entferne ich führende Nullen aus alphanumerischem Text?

Ich habe Fragen zum Präfixieren von Nullen hier in SO gesehen. Aber nicht umgekehrt!

Könnt ihr mir vorschlagen, wie man die führenden Nullen im alphanumerischen Text entfernt? Gibt es integrierte APIs oder muss ich eine Methode schreiben, um die führenden Nullen zu trimmen?

Beispiel:

01234 converts to 1234
0001234a converts to 1234a
001234-a converts to 1234-a
101234 remains as 101234
2509398 remains as 2509398
123z remains as 123z
000002829839 converts to 2829839

Regex ist das beste Werkzeug für diesen Job. Was es sein sollte, hängt von der Problemspezifikation ab. Im Folgenden werden führende Nullen entfernt, aber bei Bedarf eine belassen (dh es wird nicht einfach "0"eine leere Zeichenfolge verwendet).

s.replaceFirst("^0+(?!$)", "")

Der ^Anker stellt sicher, dass sich die 0+Übereinstimmung am Anfang der Eingabe befindet. Der (?!$)negative Lookahead stellt sicher, dass nicht die gesamte Zeichenfolge übereinstimmt.

Prüfkabel:

String[] in = {
    "01234",         // "[1234]"
    "0001234a",      // "[1234a]"
    "101234",        // "[101234]"
    "000002829839",  // "[2829839]"
    "0",             // "[0]"
    "0000000",       // "[0]"
    "0000009",       // "[9]"
    "000000z",       // "[z]"
    "000000.z",      // "[.z]"
};
for (String s : in) {
    System.out.println("[" + s.replaceFirst("^0+(?!$)", "") + "]");
}

Siehe auch

• reguläre-Ausdrücke.info
  • Wiederholungen , Lookarounds und Anker
• String.replaceFirst(String regex)

Sie können die StringUtils- Klasse von Apache Commons Lang folgendermaßen verwenden :

StringUtils.stripStart(yourString,"0");

Wie wäre es mit dem Regex-Weg:

String s = "001234-a";
s = s.replaceFirst ("^0*", "");

Die ^Anker am Anfang der Zeichenfolge (ich gehe aus dem Kontext davon aus, dass Ihre Zeichenfolgen hier nicht mehrzeilig sind, andernfalls müssen Sie möglicherweise \Aeher nach dem Beginn der Eingabe als nach dem Beginn der Zeile suchen ). Das 0*bedeutet null oder mehr 0Zeichen (Sie können auch verwenden 0+). Das replaceFirstersetzt einfach alle diese 0Zeichen am Anfang durch nichts.

Und wenn Ihre Definition von führenden Nullen wie bei Vadzim nicht darin besteht, "0"(oder "000"ähnliche Zeichenfolgen) in eine leere Zeichenfolge umzuwandeln (eine ausreichend vernünftige Erwartung), setzen Sie sie bei Bedarf einfach zurück:

String s = "00000000";
s = s.replaceFirst ("^0*", "");
if (s.isEmpty()) s = "0";

Ein klarer Weg ohne die Notwendigkeit von regExp und externen Bibliotheken.

public static String trimLeadingZeros(String source) {
    for (int i = 0; i < source.length(); ++i) {
        char c = source.charAt(i);
        if (c != '0') {
            return source.substring(i);
        }
    }
    return ""; // or return "0";
}

Passend zum thelost Apache Commons Antwort: mit Guave-Bibliotheken (Google-Allzweck-Java - Utility - Bibliothek , die ich argumentieren würde jetzt auf dem Classpath eines nicht-triviale Java - Projekt sein sollte), würde dies verwenden CharMatcher :

CharMatcher.is('0').trimLeadingFrom(inputString);

Wenn Sie Kotlin verwenden Dies ist der einzige Code, den Sie benötigen:

yourString.trimStart('0')

Sie könnten einfach tun: String s = Integer.valueOf("0001007").toString();

Verwenden Sie die Apache Commons- StringUtilsKlasse:

StringUtils.strip(String str, String stripChars);

Benutze das:

String x = "00123".replaceAll("^0*", ""); // -> 123

Verwenden von Regexp mit Gruppen:

Pattern pattern = Pattern.compile("(0*)(.*)");
String result = "";
Matcher matcher = pattern.matcher(content);
if (matcher.matches())
{
      // first group contains 0, second group the remaining characters
      // 000abcd - > 000, abcd
      result = matcher.group(2);
}

return result;

Die Verwendung von Regex, wie einige der Antworten vermuten lassen, ist ein guter Weg, dies zu tun. Wenn Sie Regex nicht verwenden möchten, können Sie diesen Code verwenden:

String s = "00a0a121";

while(s.length()>0 && s.charAt(0)=='0')
{
   s = s.substring(1); 
}

Ich denke, dass es so einfach ist, das zu tun. Sie können die Zeichenfolge einfach von Anfang an durchlaufen und Nullen entfernen, bis Sie ein Zeichen ungleich Null gefunden haben.

int lastLeadZeroIndex = 0;
for (int i = 0; i < str.length(); i++) {
  char c = str.charAt(i);
  if (c == '0') {
    lastLeadZeroIndex = i;
  } else {
    break;
  }
}

str = str.subString(lastLeadZeroIndex+1, str.length());

Wenn Sie (wie ich) alle führenden Nullen aus jedem "Wort" in einer Zeichenfolge entfernen müssen, können Sie die Antwort von @polygenelubricants wie folgt ändern:

String s = "003 d0g 00ss 00 0 00";
s.replaceAll("\\b0+(?!\\b)", "");

was in ... endet:

3 d0g ss 0 0 0

Ohne Verwendung Regexoder substring()Funktion, Stringdie ineffizient sein wird -

public static String removeZero(String str){
        StringBuffer sb = new StringBuffer(str);
        while (sb.length()>1 && sb.charAt(0) == '0')
            sb.deleteCharAt(0);
        return sb.toString();  // return in String
    }

Sie könnten ersetzen , "^0*(.*)"um "$1"mit regex

       String s="0000000000046457657772752256266542=56256010000085100000";      
    String removeString="";

    for(int i =0;i<s.length();i++){
      if(s.charAt(i)=='0')
        removeString=removeString+"0";
      else 
        break;
    }

    System.out.println("original string - "+s);

    System.out.println("after removing 0's -"+s.replaceFirst(removeString,""));

Wenn Sie keinen regulären Ausdruck oder keine externe Bibliothek verwenden möchten. Sie können mit "für" tun:

String input="0000008008451"
String output = input.trim();
for( ;output.length() > 1 && output.charAt(0) == '0'; output = output.substring(1));

System.out.println(output);//8008451

Ich habe einige Benchmark-Tests durchgeführt und festgestellt, dass der schnellste Weg (bei weitem) diese Lösung ist:

    private static String removeLeadingZeros(String s) {
      try {
          Integer intVal = Integer.parseInt(s);
          s = intVal.toString();
      } catch (Exception ex) {
          // whatever
      }
      return s;
    }

Besonders reguläre Ausdrücke sind in einer langen Iteration sehr langsam. (Ich musste den schnellsten Weg für einen Batchjob herausfinden.)

Und was ist mit der Suche nach dem ersten Zeichen ungleich Null?

[1-9]\d+

Diese Regex findet die erste Ziffer zwischen 1 und 9, gefolgt von einer beliebigen Anzahl von Ziffern. Für "00012345" wird also "12345" zurückgegeben . Es kann leicht für alphanumerische Zeichenfolgen angepasst werden.