영숫자 텍스트에서 선행 0을 제거하는 방법?

SO에서 0을 접두사로 사용하는 방법에 대한 질문을 보았습니다. 그러나 다른 방법은 아닙니다!

영숫자 텍스트에서 선행 0을 제거하는 방법을 제안 할 수 있습니까? 내장 API가 있습니까? 또는 선행 0을 자르는 방법을 작성해야합니까?

예:

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

정규식은이 작업에 가장 적합한 도구입니다. 문제 사양에 따라 달라집니다. 다음은 선행 0을 제거하지만 필요한 경우 1을 남겨 둡니다 (즉 "0", 빈 문자열로 바뀌지 않습니다 ).

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

^앵커 확인 있는지 확인합니다 0+일치되는 입력의 시작 부분입니다. (?!$)전체가 아닌 문자열이 일치하게 될 부정적 예측을 보장합니다.

테스트 하네스 :

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

또한보십시오

• regular-expressions.info
  • 반복 , 둘러보기 및 앵커
• String.replaceFirst(String regex)

Apache Commons Lang 의 StringUtils 클래스를 다음과 같이 사용할 수 있습니다 .

StringUtils.stripStart(yourString,"0");

정규식은 어떻습니까?

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

^문자열의 시작에 앵커 (나는 당신의 문자열이 여기에 여러 줄 수없는 상황에서 믿고있어, 그렇지 않으면 당신은 조사해야 할 수 있습니다 \A입력의 시작이 아니라 라인의 시작을위한). 0*수단은 0 개 이상의 0문자를 (당신은 할 수 사용 0+뿐만 아니라). 은 replaceFirst단지 모든 대체 0아무것도 시작 부분에 문자를.

바드처럼, 앞에 0의 당신의 정의가 돌려 포함되지 않습니다, 경우 "0"(또는 "000"빈 문자열 (합리적인 충분히 예상)로 또는 유사한 문자열) 필요한 경우, 단순히 다시 넣어 :

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

regExp 및 외부 라이브러리가 필요없는 명확한 방법.

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

thelost의 Apache Commons 답변과 함께 가기 위해 guava 라이브러리를 사용하십시오 (Google의 범용 Java 유틸리티 라이브러리는 사소한 Java 프로젝트의 클래스 경로에 있어야 함), CharMatcher를 사용 합니다 .

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

Kotlin을 사용하는 경우 필요한 유일한 코드입니다.

yourString.trimStart('0')

당신은 할 수 있습니다 : String s = Integer.valueOf("0001007").toString();

Apache Commons StringUtils클래스를 사용하십시오 .

StringUtils.strip(String str, String stripChars);

이것을 사용하십시오 :

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

그룹과 함께 Regexp 사용하기 :

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;

대답 중 일부가 제안하는대로 정규 표현식을 사용하는 것이 좋은 방법입니다. 정규식을 사용하지 않으려면 다음 코드를 사용할 수 있습니다.

String s = "00a0a121";

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

그렇게하는 것이 너무 쉽다고 생각합니다. 처음부터 문자열을 반복하고 0이 아닌 문자를 찾을 때까지 0을 제거 할 수 있습니다.

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

(나와 같이) 문자열의 각 "단어"에서 모든 선행 0을 제거해야하는 경우 다음에 대한 @polygenelubricants의 답변을 수정할 수 있습니다.

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

결과 :

3 d0g ss 0 0 0

비효율적 Regex이거나 사용하지 않는 substring()기능 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
    }

정규식으로 바꿀 "^0*(.*)"수 "$1"있습니다.

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

정규식 또는 외부 라이브러리를 사용하지 않으려는 경우 "for"로 할 수 있습니다 :

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

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

나는 몇 가지 벤치 마크 테스트를했고 가장 빠른 방법은이 솔루션이라는 것을 알았습니다.

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

특히 정규 표현식은 긴 반복에서 매우 느립니다. (일괄 처리를위한 가장 빠른 방법을 찾아야했습니다.)

그리고 0이 아닌 첫 번째 문자 만 검색하는 것은 어떻습니까?

[1-9]\d+

이 정규식은 1에서 9 사이의 첫 번째 숫자와 임의의 숫자를 찾으 므로 "00012345"의 경우 "12345"를 반환합니다 . 영숫자 문자열에 쉽게 적용 할 수 있습니다.