Bagaimana cara menghapus angka nol dari teks alfanumerik?

Saya telah melihat pertanyaan tentang bagaimana cara mengawali angka nol di sini di SO. Tapi tidak sebaliknya!

Bisakah kalian menyarankan saya cara menghapus nol terkemuka dalam teks alfanumerik? Apakah ada API bawaan atau apakah saya perlu menulis metode untuk memangkas nol terkemuka?

Contoh:

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 adalah alat terbaik untuk pekerjaan itu; apa yang seharusnya tergantung pada spesifikasi masalah. Berikut ini menghapus nol di depan, tetapi meninggalkannya jika perlu (artinya tidak hanya berubah "0"menjadi string kosong).

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

The ^jangkar akan memastikan bahwa 0+yang cocok adalah pada awal input. The (?!$)Memastikan lookahead negatif yang tidak seluruh string akan dicocokkan.

Uji harness:

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

Lihat juga

• regular-expressions.info
  • pengulangan , lookarounds , dan jangkar
• String.replaceFirst(String regex)

Anda dapat menggunakan kelas StringUtils dari Apache Commons Lang seperti ini:

StringUtils.stripStart(yourString,"0");

Bagaimana dengan cara regex:

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

The ^jangkar ke awal dari string (aku mengasumsikan dari konteks string Anda tidak multi-line di sini, jika Anda mungkin perlu untuk melihat ke dalam \Auntuk memulai input daripada awal baris). The 0*berarti nol atau lebih 0karakter (Anda bisa menggunakan 0+juga). The replaceFirsthanya menggantikan semua 0karakter di awal dengan apa-apa.

Dan jika, seperti Vadzim, definisi Anda tentang angka nol di depan tidak termasuk mengubah "0"(atau "000"string serupa) menjadi string kosong (harapan yang cukup rasional), cukup masukkan kembali jika perlu:

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

Cara yang jelas tanpa perlu regExp dan perpustakaan eksternal.

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

Agar sesuai dengan jawaban Apache Commons pertama: menggunakan jambu-libraries ( pustaka utilitas Java untuk tujuan umum Google yang menurut saya sekarang harus berada di classpath dari setiap proyek Java non-sepele), ini akan menggunakan CharMatcher :

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

Jika Anda menggunakan Kotlin Ini adalah satu-satunya kode yang Anda butuhkan:

yourString.trimStart('0')

Anda bisa melakukannya: String s = Integer.valueOf("0001007").toString();

Gunakan StringUtilskelas Apache Commons :

StringUtils.strip(String str, String stripChars);

Gunakan ini:

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

Menggunakan Regexp dengan grup:

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;

Menggunakan regex sebagai beberapa jawaban menyarankan adalah cara yang baik untuk melakukan itu. Jika Anda tidak ingin menggunakan regex maka Anda dapat menggunakan kode ini:

String s = "00a0a121";

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

Saya pikir itu sangat mudah untuk dilakukan. Anda hanya dapat mengulangi string dari awal dan menghapus nol sampai Anda menemukan char tidak nol.

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

Jika Anda (seperti saya) perlu menghapus semua nol terkemuka dari setiap "kata" dalam sebuah string, Anda dapat memodifikasi jawaban @polygenelubricants sebagai berikut:

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

yang mengakibatkan:

3 d0g ss 0 0 0

Tanpa menggunakan Regexatau substring()fungsi Stringyang tidak efisien -

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
    }

Anda bisa mengganti "^0*(.*)"ke "$1"dengan 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,""));

Jika Anda tidak ingin menggunakan regex atau perpustakaan eksternal. Anda dapat melakukannya dengan "untuk":

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

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

Saya membuat beberapa tes benchmark dan menemukan, bahwa cara tercepat (sejauh ini) adalah solusi ini:

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

Terutama ekspresi reguler sangat lambat dalam iterasi yang panjang. (Saya perlu mencari tahu cara tercepat untuk melakukan batchjob.)

Dan bagaimana dengan hanya mencari karakter non-nol pertama?

[1-9]\d+

Regex ini menemukan digit pertama antara 1 dan 9 diikuti oleh sejumlah digit, jadi untuk "00012345" ia mengembalikan "12345" . Itu dapat dengan mudah diadaptasi untuk string alfanumerik.