अल्फ़ान्यूमेरिक पाठ से अग्रणी शून्य कैसे निकालें?

Question

मैंने एसओ में यहां शून्य को उपसर्ग करने के बारे में प्रश्न देखे हैं। लेकिन दूसरा तरीका नहीं!

क्या आप लोग मुझे सुझाव दे सकते हैं कि अल्फ़ान्यूमेरिक पाठ में अग्रणी शून्य को कैसे हटाया जाए? क्या कोई अंतर्निहित API हैं या क्या मुझे अग्रणी शून्य को ट्रिम करने के लिए एक विधि लिखने की आवश्यकता है?

उदाहरण:

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

रेगेक्स नौकरी के लिए सबसे अच्छा उपकरण है; यह क्या होना चाहिए समस्या विनिर्देश पर निर्भर करता है। निम्नलिखित प्रमुख शून्य को हटाता है, लेकिन यदि आवश्यक हो तो एक को छोड़ देता है (यानी यह सिर्फ "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
  • repetitions , लुकअप और लंगर
• String.replaceFirst(String regex)

Comments

धन्यवाद। और तुमने बेरहमी से परीक्षा दी है;) महान !! परीक्षणों के लिए +1।

— जय

@Greg: यह सवाल जावा के बारे में है, जावास्क्रिप्ट के बारे में नहीं। संस्करण 1.4 के बाद से Java SE में String.replaceFirst () विधि है ।

— जोनीक

ट्रिम () को s.replaceFirst ("^ 0 + (?! $)", "") (यानि s। srim () से बदलकर। को जोड़ने के लिए .First ("^ 0 + (($))", "") मदद करेंगे गद्देदार स्थानों को हटाने में!

— AVA

इस तरह के एक सरल कार्य के लिए थोड़ा महंगा नहीं है?

— डेमॉन्गोलम

यह .replaceFirst("^0+(?!$)".toRegex(), "")

— कोटलिन

Answer 2

आप Apache Commons Lang से StringUtils वर्ग का उपयोग इस तरह कर सकते हैं:

StringUtils.stripStart(yourString,"0");

Comments

क्या अकेले "0" के साथ यह समस्या है? @ हैमिल्टन रोड्रिग्स

— फुओने

यदि अकेले "0" पर इसका उपयोग किया जाता है, तो यह वापस "" देता है। तो देखभाल अगर यह वांछित प्रभाव की आवश्यकता नहीं है।

— dARKpRINCE

उपार्जित कारण यह पूछे गए प्रश्न में उपयोग के मामलों के लिए काम करता है। त्वरित समाधान के लिए यहां भी मेरी मदद की। धन्यवाद!

— गेब्रियल अमेज़ॅन मेसक्विटा

Answer 3

कैसे के बारे में regex तरीका:

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

^स्ट्रिंग के शुरू करने के एंकर (मैं संदर्भ से संभालने कर रहा हूँ अपने तार बहु लाइन यहाँ नहीं हैं, अन्यथा आप इस पर गौर करना पड़ सकता है \Aलाइन की शुरुआत के बजाय इनपुट की शुरुआत के लिए)। 0*शून्य या अधिक 0वर्णों का मतलब है (आप भी उपयोग कर सकते हैं 0+)। replaceFirstसिर्फ उन सभी की जगह 0कुछ भी नहीं के साथ शुरू में अक्षर।

और अगर वडज़िम की तरह, अग्रणी शून्य की आपकी परिभाषा में रिक्त स्ट्रिंग (एक तर्कसंगत पर्याप्त अपेक्षा) में मोड़ "0"(या "000"समान तार) शामिल नहीं है, तो यदि आवश्यक हो तो इसे वापस रखें:

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

Comments

यह अकेले "0" के साथ समस्या है।

— वडज़िम

Answer 4

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

Comments

यद्यपि अंतरिक्ष के लिए आपका चेक प्रश्न के अनुसार नहीं है, फिर भी मुझे लगता है कि आपका उत्तर सबसे तेज निष्पादित करेगा।

— जॉन फाउलर

@ जॉनहॉवलर ने 10x कैच के लिए, 2 साल के बाद तय किया

— जादुई समय

और विधि को अंत में एक वापसी की आवश्यकता होती है यदि लूप केवल शून्य पाता है। वापसी ""; या वापसी "0"; यदि आप कम से कम एक शून्य चाहते हैं

— फिसलन

@slipperyseal मैंने इसे खुला छोड़ दिया ताकि आप इसे अपनी आवश्यकताओं के आधार पर बदल सकें लेकिन जब से लोग कॉपी / पेस्ट करते हैं, यह हमेशा एक बुरा व्यवहार नहीं है। टिप्पणी के लिए धन्यवाद

— Magiccrafter

Answer 5

के साथ जाने के लिए thelost है Apache कॉमन्स जवाब: का उपयोग कर अमरूद-पुस्तकालयों (Google के सामान्य-उद्देश्य जावा उपयोगिता पुस्तकालय का उपयोग करते हुए जो मैं तर्क देता हूं कि अब किसी गैर-तुच्छ जावा परियोजना के क्लासपाथ पर होना चाहिए), यह चार्चचर का उपयोग करेगा :

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

Comments

+1, अमरूद के उपयोग से किसी भी परियोजना के लिए सही उत्तर। (और अब 2012 में इसका मतलब है कि किसी भी जावा परियोजना को बहुत अधिक होना चाहिए ।)

— जोनीक

@Cowan क्या अकेले "0" के साथ यह समस्या है? विल CharMatcher.is ('0')। trimLeadingFrom ("0"); "0" या खाली स्ट्रिंग लौटें?

— फूनऑन

@PhoonOne: मैंने अभी यह परीक्षण किया है; यह खाली स्ट्रिंग लौटाता है।

— Stephan202

Answer 6

यदि आप कोटलिन का उपयोग कर रहे हैं तो यह एकमात्र कोड है जिसकी आपको आवश्यकता है:

yourString.trimStart('0')

Answer 7

आप बस कर सकते हैं: String s = Integer.valueOf("0001007").toString();

Comments

अल्फ़ान्यूमेरिक नहीं संभालेंगे।

— स्लैमन

Answer 8

Apache Commons StringUtilsवर्ग का उपयोग करें :

StringUtils.strip(String str, String stripChars);

Comments

चेतावनी! यह जीरो को लीड करना और समाप्त करना बंद कर देगा, जो कि आप जो चाहते हैं वह नहीं हो सकता है।

— जेन्स बैनमैन

आप StringUtils.stripStart () का उपयोग करके केवल प्रमुख शून्य को पट्टी कर सकते हैं।

— जोश रोसेन

Answer 9

इसे इस्तेमाल करो:

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

Answer 10

समूहों के साथ 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;

Answer 11

कुछ सवालों के जवाब के रूप में रेगेक्स का उपयोग करना एक अच्छा तरीका है। यदि आप regex का उपयोग नहीं करना चाहते हैं तो आप इस कोड का उपयोग कर सकते हैं:

String s = "00a0a121";

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

Comments

यह बहुत कुछ बना सकता है String... इसके बजाय मैजिकक्रैच एप्रोच का उपयोग करें ।

— एक्सलह

Answer 12

मुझे लगता है कि ऐसा करना इतना आसान है। आप बस शुरू से स्ट्रिंग पर लूप कर सकते हैं और शून्य हटा सकते हैं जब तक कि आपको शून्य चार्ट नहीं मिला।

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 13

यदि आपको (मेरे जैसे) एक स्ट्रिंग में प्रत्येक "शब्द" से सभी अग्रणी शून्य को निकालने की आवश्यकता है, तो आप निम्न में @polygenel स्नेहक के उत्तर को संशोधित कर सकते हैं:

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

जिसके परिणामस्वरूप:

3 d0g ss 0 0 0

Answer 14

उपयोग 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
    }

Answer 15

आप रेगेक्स "^0*(.*)"से बदल सकते हैं"$1"

Comments

एकमात्र मुद्दा जो मैं यहां देख रहा हूं, वह एक शून्य शून्य '0' को रिक्त स्थान पर बदल सकता है।

— दिलीपकुमार J

Answer 16

       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 17

यदि आप रेगेक्स या बाहरी पुस्तकालय का उपयोग नहीं करना चाहते हैं। आप "के लिए" के साथ कर सकते हैं:

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

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

Comments

Stringइस लूप के दौरान बहुत सारे उत्पन्न होते हैं ... अगर 1000 है 0...

— AxelH

Answer 18

मैंने कुछ बेंचमार्क परीक्षण किए और पाया कि यह सबसे तेज़ तरीका है (अब तक)

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

विशेष रूप से नियमित अभिव्यक्ति एक लंबी पुनरावृत्ति में बहुत धीमी है। (मुझे एक बैचबॉज के लिए सबसे तेज़ तरीका खोजने की ज़रूरत थी।)

Answer 19

और पहले गैर-शून्य चरित्र की खोज करने के बारे में क्या?

[1-9]\d+

इस regex इतना के लिए, 1 और 9 अंक के किसी भी संख्या के द्वारा पीछा के बीच पहला अंक पाता है "00012345" यह रिटर्न "12345" । इसे अल्फ़ान्यूमेरिक स्ट्रिंग्स के लिए आसानी से अनुकूलित किया जा सकता है।

Comments

यह शून्य को बाद में भी अनुमति नहीं देगा।

— निशांत डोंगरे