Làm thế nào để loại bỏ các số không hàng đầu khỏi văn bản chữ và số?

Tôi đã thấy các câu hỏi về cách tạo tiền tố số 0 ở đây trong SO. Nhưng không phải là cách khác!

Các bạn có thể gợi ý cho tôi cách loại bỏ các số 0 đứng đầu trong văn bản chữ và số không? Có bất kỳ API tích hợp nào không hoặc tôi có cần viết một phương thức để cắt các số 0 đứng đầu không?

Thí dụ:

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 là công cụ tốt nhất cho công việc; những gì nó nên được phụ thuộc vào đặc điểm kỹ thuật vấn đề. Sau đây sẽ loại bỏ các số 0 đứng đầu, nhưng để lại một số không cần thiết (nghĩa là nó sẽ không chuyển "0"sang một chuỗi trống).

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

Các ^neo sẽ đảm bảo rằng các 0+bị phù hợp là vào lúc bắt đầu của đầu vào. Giao diện (?!$)phủ định đảm bảo rằng không phải toàn bộ chuỗi sẽ được khớp.

Khai thác thử nghiệm:

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

Xem thêm

• chính quy
  • lặp đi lặp lại , lookarounds , và neo
• String.replaceFirst(String regex)

Bạn có thể sử dụng lớp StringUtils từ Apache Commons Lang như thế này:

StringUtils.stripStart(yourString,"0");

Làm thế nào về cách regex:

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

Các ^điểm neo ở đầu chuỗi (Tôi giả sử từ ngữ cảnh chuỗi của bạn không phải là nhiều dòng ở đây, nếu không bạn có thể cần xem xét \Ađể bắt đầu nhập thay vì bắt đầu dòng). Có 0*nghĩa là không hoặc nhiều 0ký tự (bạn cũng có thể sử dụng 0+). Việc replaceFirstthay thế tất cả những 0nhân vật lúc đầu không có gì.

Và nếu, giống như Vadzim, định nghĩa về các số 0 đứng đầu của bạn không bao gồm biến "0"(hoặc "000"hoặc các chuỗi tương tự) thành một chuỗi trống (một kỳ vọng đủ hợp lý), chỉ cần đặt lại nếu cần:

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

Một cách rõ ràng mà không cần regExp và bất kỳ thư viện bên ngoài.

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

Để đi với câu trả lời Apache Commons của thelost: sử dụng các thư viện ổi (thư viện tiện ích Java đa năng của Google mà tôi cho rằng bây giờ nên có trên đường dẫn của bất kỳ dự án Java không tầm thường nào), điều này sẽ sử dụng CharMatcher :

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

Nếu bạn đang sử dụng Kotlin Đây là mã duy nhất mà bạn cần:

yourString.trimStart('0')

Bạn chỉ có thể làm: String s = Integer.valueOf("0001007").toString();

Sử dụng StringUtilslớp Apache Commons :

StringUtils.strip(String str, String stripChars);

Dùng cái này:

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

Sử dụng Regapi với các nhóm:

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;

Sử dụng regex như một số câu trả lời gợi ý là một cách tốt để làm điều đó. Nếu bạn không muốn sử dụng regex thì bạn có thể sử dụng mã này:

String s = "00a0a121";

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

Tôi nghĩ rằng nó rất dễ dàng để làm điều đó. Bạn chỉ có thể lặp qua chuỗi từ đầu và loại bỏ các số không cho đến khi bạn tìm thấy một char không bằng không.

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

Nếu bạn (như tôi) cần xóa tất cả các số 0 đứng đầu khỏi mỗi "từ" trong một chuỗi, bạn có thể sửa đổi câu trả lời của @polygenelubricants thành như sau:

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

kết quả là:

3 d0g ss 0 0 0

Không sử dụng Regexhoặc substring()chức năng Stringmà sẽ không hiệu quả -

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
    }

Bạn có thể thay thế "^0*(.*)"để "$1"có 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,""));

Nếu bạn không muốn sử dụng regex hoặc thư viện bên ngoài. Bạn có thể làm với "cho":

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

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

Tôi đã thực hiện một số bài kiểm tra điểm chuẩn và thấy rằng cách nhanh nhất (cho đến nay) là giải pháp này:

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

Đặc biệt là các biểu thức chính quy rất chậm trong một lần lặp dài. (Tôi cần tìm ra cách nhanh nhất cho một đợt.)

Và những gì về việc chỉ tìm kiếm các ký tự khác không đầu tiên?

[1-9]\d+

Regex này tìm thấy chữ số đầu tiên trong khoảng từ 1 đến 9, theo sau là bất kỳ số chữ số nào, vì vậy với "00012345", nó trả về "12345" . Nó có thể dễ dàng điều chỉnh cho các chuỗi chữ và số.