Come rimuovere gli zeri principali dal testo alfanumerico?

Question

Ho visto domande su come prefiggere gli zeri qui. Ma non dall'altra parte!

Ragazzi, potete suggerirmi come rimuovere gli zeri principali nel testo alfanumerico? Ci sono API integrate o devo scrivere un metodo per tagliare gli zeri principali?

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

Answer 1

Regex è lo strumento migliore per il lavoro; Ciò che dovrebbe essere dipende dalle specifiche del problema. Quanto segue rimuove lo zero che porta, ma se necessario (cioè non girare solo "0" a una stringa vuota).

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

Il ^ l'ancora si assicurerà che il 0+ Essere abbinato è all'inizio dell'input. Il (?!$) Lookahead negativo garantisce che non l'intera stringa sarà abbinata.

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

• espressioni regolari.info
  • ripetizioni, Lookarounds, e ancore
• String.replaceFirst(String regex)

Answer 2

Puoi usare il Stringutils classe da Apache Commons Lang come questo:

StringUtils.stripStart(yourString,"0");

Answer 3

Che ne dici di Regex Way:

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

Il ^ Anchor all'inizio della stringa (presumo dal contesto le tue stringhe non sono multi-line qui, altrimenti potresti dover esaminare \A per l'inizio dell'input anziché l'inizio della linea). Il 0* significa zero o più 0 personaggi (tu Potevo uso 0+ anche). Il replaceFirst Sostituisce solo tutti quelli 0 personaggi all'inizio con niente.

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

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

Answer 4

Un modo chiaro senza alcuna necessità di regexp e 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";
}

Answer 5

Per andare con Apache Commons di Thelost Risposta: Utilizzo Libribri guava (La biblioteca di utilità Java per scopi generali di Google che direi dovrebbe ora essere sul percorso di classe di qualsiasi progetto Java non banale), questo si userebbe Charmatcher:

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

Answer 6

Usa Apache Commons StringUtils classe:

StringUtils.strip(String str, String stripChars);

Answer 7

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

Answer 8

Utilizzo di regexp con 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;

Answer 9

Usa questo:

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

Answer 10

L'uso di Regex come suggeriscono 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); 
}

Answer 11

Penso che sia così facile farlo. Puoi semplicemente eseguire il tiro sopra la stringa dall'inizio e rimuovere gli zeri fino a quando non hai trovato un chart non 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());

Answer 12

Se (come me) devi rimuovere tutti gli zeri principali 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

Answer 13

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

yourString.trimStart('0')

Answer 14

Potresti sostituire "^0*(.*)" a "$1" con regex

Answer 15

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

Answer 16

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

Answer 17

Ho fatto alcuni test di riferimento 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;
    }

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

Answer 18

Senza usare Regex o substring() funzione su String che 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
    }

Answer 19

E che dire solo di cercare il primo personaggio diverso da zero?

[1-9]\d+

Questo regex trova la prima cifra tra 1 e 9 seguita da qualsiasi numero di cifre, così per "00012345" ritorna "12345". Può essere facilmente adattato per le corde alfanumeriche.