Come rimuovere gli zeri iniziali dal testo alfanumerico?

Ho visto domande su come aggiungere gli zeri qui in SO. Ma non viceversa!

Potete suggerirmi come rimuovere gli zeri iniziali nel testo alfanumerico? Esistono API integrate o devo scrivere un metodo per tagliare gli zeri iniziali?

Esempio:

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 è lo strumento migliore per il lavoro; quale dovrebbe essere dipende dalle specifiche del problema. Quanto segue rimuove gli zeri iniziali, ma ne lascia uno se necessario (cioè non si trasformerebbe semplicemente "0"in una stringa vuota).

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

L' ^ancoraggio farà in modo che l' 0+accoppiamento sia all'inizio dell'ingresso. Il (?!$)lookahead negativo assicura che non verrà abbinata l'intera stringa.

Collaudare l'imbragatura:

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+(?!$)", "") + "]");
}

Guarda anche

• regular-expressions.info
  • ripetizioni , lookaround e ancore
• String.replaceFirst(String regex)

Puoi usare la classe StringUtils di Apache Commons Lang in questo modo:

StringUtils.stripStart(yourString,"0");

Che ne dici del modo regex:

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

Le ^ancore all'inizio della stringa (suppongo dal contesto che le tue stringhe non siano multilinea qui, altrimenti potresti dover cercare l' \Ainizio dell'input piuttosto che l'inizio della riga). I 0*mezzi zero o più 0caratteri (si potrebbe usare 0+pure). Il replaceFirstsolo sostituisce tutti quelli0 personaggi all'inizio con niente.

E se, come Vadzim, la tua definizione di zeri iniziali non include la trasformazione "0"(o "000"stringhe simili) in una stringa vuota (un'aspettativa abbastanza razionale), rimettila semplicemente se necessario:

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

Un modo chiaro senza la necessità di regExp e di eventuali librerie esterne.

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

Per andare con la risposta di Apache Commons in assoluto: usando le librerie guava (la libreria di utilità Java per scopi generali di Google, che direi ora dovrebbe essere sul percorso di classe di qualsiasi progetto Java non banale), questo userebbe CharMatcher :

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

Se stai usando Kotlin Questo è l'unico codice di cui hai bisogno:

yourString.trimStart('0')

Potresti semplicemente fare: String s = Integer.valueOf("0001007").toString();

Usa la StringUtilsclasse Apache Commons :

StringUtils.strip(String str, String stripChars);

Usa questo:

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

Utilizzo di Regexp con i gruppi:

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;

Usare regex come suggerito da alcune delle risposte è un buon modo per farlo. Se non vuoi usare regex, puoi usare questo codice:

String s = "00a0a121";

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

Penso che sia così facile farlo. Puoi semplicemente passare sopra la stringa dall'inizio e rimuovere gli zeri fino a quando non trovi un carattere diverso da zero.

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

Se (come me) devi rimuovere tutti gli zeri iniziali da ogni "parola" in una stringa, puoi modificare la risposta di @polygenelubricants a quanto segue:

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

che si traduce in:

3 d0g ss 0 0 0

Senza utilizzare Regexo la substring()funzione su Stringcui sarà inefficiente -

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
    }

È possibile sostituire "^0*(.*)"a "$1"con 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,""));

Se non si desidera utilizzare regex o libreria esterna. Puoi fare con "per":

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

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

Ho fatto alcuni test di benchmark e ho scoperto che il modo più veloce (di gran lunga) è questa soluzione:

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

Le espressioni particolarmente regolari sono molto lente in una lunga iterazione. (Avevo bisogno di scoprire il modo più veloce per un batchjob.)

E che dire della ricerca del primo carattere diverso da zero?

[1-9]\d+

Questa regex trova la prima cifra tra 1 e 9 seguita da un numero qualsiasi di cifre, quindi per "00012345" restituisce "12345" . Può essere facilmente adattato per stringhe alfanumeriche.