Wie können führende Nullen aus alphanumerischem Text entfernt werden?

Ich gesehen habe, Fragen, wie Präfix Nullen hier ALSO aus. Aber nicht in die andere Richtung!

Könnt Ihr mir empfehlen, wie Sie die führende null in alphanumerischen text? Gibt es irgendwelche eingebaute APIs oder brauche ich zu schreiben, eine Methode zum kürzen von führenden Nullen?

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

InformationsquelleAutor der Frage HanuAthena | 2010-05-10

458

Regex ist das beste Werkzeug für den job, was es sein sollte, hängt von der problem-Spezifikation. Die folgenden entfernt führende Nullen, aber Blätter ein, falls erforderlich (d.h., es würde nicht einfach nur drehen "0" zu einem leeren string).
```
s.replaceFirst("^0+(?!$)", "")
```
Den ^ Anker stellen Sie sicher, dass die 0+ verglichen wird befindet sich am Anfang der Eingabe. Die (?!$) negative lookahead-Funktion sorgt dafür, dass nicht die gesamte Zeichenfolge angepasst werden.

Testumgebung:
```
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
- regular-expressions.info
  - Wiederholungen lookaroundsund Anker
- - String.replaceFirst(String regex)
InformationsquelleAutor der Antwort polygenelubricants
64

Können Sie die StringUtils Klasse aus Apache Commons Lang wie diese:
```
StringUtils.stripStart(yourString,"0");
```
InformationsquelleAutor der Antwort Hamilton Rodrigues
26

Wie etwa die regex-Weg:
```
String s = "001234-a";
s = s.replaceFirst ("^0*", "");
```
Den ^ Anker an den Anfang der Zeichenfolge (ich gehe davon aus Kontext Ihre Saiten sind nicht multi-line hier, sonst können Sie brauchen, um sich in \A für start-Eingang eher als Beginn der Zeile). Die 0* bedeutet null oder mehr 0 Zeichen (Sie könnte Verwendung 0+). Die replaceFirst nur ersetzt alle diejenigen 0 Zeichen am Anfang vor dem nichts.

Und wenn, wie Vadzim, Ihre definition von führenden Nullen nicht auch drehen "0" (oder "000" oder ähnliche Zeichenfolgen) in eine leere Zeichenfolge (ein rational genug, Erwartung), einfach setzen Sie es zurück, wenn notwendig:
```
String s = "00000000";
s = s.replaceFirst ("^0*", "");
if (s.isEmpty()) s = "0";
```
InformationsquelleAutor der Antwort paxdiablo

Einer klaren Art und Weise ohne die Notwendigkeit von regExp und alle 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";
}

InformationsquelleAutor der Antwort magiccrafter

11

Gehen mit thelost Apache Commons Antwort: mit guava-libraries (Googles Allzweck-Java-utility-Bibliothek, die würde ich argumentieren sollte nun auf dem classpath jeden nicht-triviale Java-Projekt), dies würde die Verwendung CharMatcher:
```
CharMatcher.is('0').trimLeadingFrom(inputString);
```
InformationsquelleAutor der Antwort Cowan
4

Apache Commons StringUtils Klasse:
```
StringUtils.strip(String str, String stripChars);
```
InformationsquelleAutor der Antwort thelost

Verwendung 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;

InformationsquelleAutor der Antwort brj

1

Verwenden:
```
String x = "00123".replaceAll("^0*", ""); //-> 123
```
InformationsquelleAutor der Antwort Eduardo Cuomo

Ich denke, dass es so einfach zu tun. Sie können nur Loop-Schleife über den string von den start-und entfernen von Nullen aufgefüllt, bis Sie gefunden, ein nicht-null-char.

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

InformationsquelleAutor der Antwort vodkhang

1

Mithilfe von regex, wie einige der Antworten vorschlagen, ist ein guter Weg, das zu tun. Wenn Sie nicht möchten, zu verwenden regex dann können Sie diesen code verwenden:
```
String s = "00a0a121";

while(s.length()>0 && s.charAt(0)=='0')
{
   s = s.substring(1); 
}
```
InformationsquelleAutor der Antwort Hüseyin Burhan ÖZKAN
0

Ersetzen "^0*(.*)" zu "$1" mit regex

InformationsquelleAutor der Antwort YOU

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

InformationsquelleAutor der Antwort Ajit Kumar Sahu

Wenn Sie nicht möchten, verwenden Sie regex oder externe Bibliothek.
Sie können tun, mit "für":

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

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

InformationsquelleAutor der Antwort kfatih

Ich habe einige benchmark-tests und gefunden, dass die Schnellste Weise, (weit) ist diese Lösung:

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

Insbesondere reguläre Ausdrücke sind sehr langsam, in einer langen iteration. (Ich brauchte, um herauszufinden, der Schnellste Weg für einen batchjob.)

InformationsquelleAutor der Antwort Robert Fornesdale

0

Und was gerade auf der Suche nach der ersten nicht-null-Zeichen?
```
[1-9]\d+
```
Dieser regex findet die erste Ziffer zwischen 1 und 9 gefolgt von einer beliebigen Anzahl von Ziffern, so dass für "00012345" es gibt "12345".
Es kann leicht angepasst werden für alphanumerische Zeichenfolgen.

InformationsquelleAutor der Antwort Sol Garlic
0

Wenn du (wie ich) benötigen, so entfernen Sie alle führenden Nullen von jedem "Wort" in einem string, können Sie ändern @polygenelubricants' Antwort auf die folgenden:
```
String s = "003 d0g 00ss 00 0 00";
s.replaceAll("\\b0+(?!\\b)", "");
```
sind die Ergebnisse in:
```
3 d0g ss 0 0 0
```
InformationsquelleAutor der Antwort xdhmoore

Ohne Verwendung Regex oder substring() Funktion auf String was ineffizient sein -

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
    }

InformationsquelleAutor der Antwort Sachin Aggarwal

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Siehe auch