Alfasayısal metinden baştaki sıfırlar nasıl kaldırılır?

Burada SO sıfırlar önek nasıl soruları gördüm. Ama başka türlü değil!

Alfasayısal metindeki baştaki sıfırları nasıl kaldıracağımı önerebilir misiniz? Yerleşik API'ler var mı veya önde gelen sıfırları düzeltmek için bir yöntem yazmam gerekiyor mu?

Misal:

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 iş için en iyi araçtır; bunun ne olması sorun spesifikasyonuna bağlıdır. Aşağıdakiler baştaki sıfırları kaldırır, ancak gerekirse bir tane bırakır (yani yalnızca "0"boş bir dizeye dönüşmez ).

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

^Çapa emin olacaktır 0+eşleştirilen girdi başında bulunmaktadır. (?!$)Tamamını değil dize eşleştirileceğini Negatif ilerleme olmasını sağlar.

Test kemeri:

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

Ayrıca bakınız

• regular-expressions.info
  • tekrarlar , aramalar ve çapalar
• String.replaceFirst(String regex)

Apache Commons Lang'dan StringUtils sınıfını şu şekilde kullanabilirsiniz :

StringUtils.stripStart(yourString,"0");

Normal yol hakkında:

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

^Dizesinin başlamasından çapalar (Ben senin dizeleri burada çok hatlı olmayan bağlamdan farz ediyorum, aksi takdirde içine bakmak gerekebilir \AGirdi başlangıcında ziyade hattının başlangıç için). 0*Aracı sıfır veya daha fazla 0karakter (siz olabilir kullanmak 0+kuyu gibi). replaceFirstSadece tüm bu değiştirir0 hiçbir şey başlangıcında karakterleri.

Ve Vadzim gibi, baştaki sıfırlar tanımınız boş bir dizeye (veya yeterince rasyonel bir beklenti) dönüşü "0"(veya "000"yeterince rasyonel bir beklenti) içermiyorsa , gerekirse geri koyun:

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

Herhangi bir regExp ve harici kütüphaneye ihtiyaç duymadan net bir yol.

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

Lolo'nun Apache Commons cevabı ile gitmek için: guava-kütüphanelerini (Google'ın artık önemsiz herhangi bir Java projesinin sınıf yolunda olması gerektiğini iddia ettiğim genel amaçlı Java yardımcı programı kütüphanesini) kullanarak, bu CharMatcher'ı kullanır :

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

Kotlin kullanıyorsanız İhtiyacınız olan tek kod budur:

yourString.trimStart('0')

Sadece şunları yapabilirsiniz: String s = Integer.valueOf("0001007").toString();

Apache Commons StringUtilssınıfını kullanın :

StringUtils.strip(String str, String stripChars);

Bunu kullan:

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

Regexp'i gruplarla kullanma:

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;

Regex'i bazı cevapların önerdiği gibi kullanmak bunu yapmanın iyi bir yoludur. Normal ifade kullanmak istemiyorsanız, bu kodu kullanabilirsiniz:

String s = "00a0a121";

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

Bunu yapmanın çok kolay olduğunu düşünüyorum. Sıfırdan bir karakter bulana kadar dize üzerinde başlangıç ​​ve sıfırlar arasında döngü yapabilirsiniz.

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

(Benim gibi) bir dizgideki her "kelimeden" tüm önde gelen sıfırları kaldırmanız gerekiyorsa, @polygenelubricants'ın aşağıdakilere verdiği yanıtı değiştirebilirsiniz:

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

sonuç:

3 d0g ss 0 0 0

Verimsiz olacak şekilde Regexveya substring()fonksiyon kullanmadan String-

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
    }

Sen yerini alabilecek "^0*(.*)"kadar "$1"regex ile

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

Normal ifade veya harici kitaplık kullanmak istemiyorsanız. "For" ile yapabilirsiniz:

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

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

Bazı kıyaslama testleri yaptım ve en hızlı yolun (açık bir şekilde) bu çözüm olduğunu gördüm:

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

Özellikle düzenli ifadeler uzun bir yinelemede çok yavaştır. (Bir toplu iş için en hızlı yolu bulmam gerekiyordu.)

Peki ya sıfır olmayan ilk karakteri aramaya ne dersiniz?

[1-9]\d+

Bu normal ifade, 1 ile 9 arasındaki ilk rakamı ve ardından herhangi bir sayı basamağını bulur, bu nedenle "00012345" için "12345" değerini döndürür . Alfasayısal dizgiler için kolayca uyarlanabilir.