दिलचस्प पोस्ट
मैं मूल प्रक्रिया की कार्यशील निर्देशिका कैसे सेट करूं? तेज 3 से परिवर्तित होने के बाद अजीब जेनेरिक फ़ंक्शन दृश्य नियंत्रक में दिखाई देता है गतिविधि से टुकड़ा के पाठ का व्यू का टेक्स्ट कैसे बदला जाए एक्सएमएल से एक DialogPreference बनाने iPhone NSURL कनेक्शन के साथ पोस्ट भेज रहा है बाइट जावा में फाइल करने के लिए सीएसवी को PHP सरणी वेब संदर्भ और सेवा संदर्भ में अंतर? क्या एसटीएल कंटेनर से कार्यान्वयन करने के बजाय प्रतिनिधि देना है? सी ++ 11 में आप अपना स्वयं का पाठक / लेखक लॉक कैसे लागू करेंगे? एचटीटीपी अनुरोध बॉडी के अंत का पता लगाएं AngularJS में एक इनपुट फ़ील्ड में पहले अक्षर को ऑटोकैपिटलाइज़ कैसे करें? एक बड़े शब्द अनुक्रम में शीर्ष कश्मीर के सबसे अधिक शब्द खोजने के लिए सबसे अधिक कुशल तरीका BouncyCastle बिना जावा में एक X509 प्रमाणपत्र बनाना? `नई ऑब्जेक्ट () 'और ऑब्जेक्ट आर्टिकल नोटेशन के बीच अंतर क्या है?

जावा रेगेक्स कैप्चरिंग समूह

मैं इस कोड ब्लॉक को समझने की कोशिश कर रहा हूं। पहले एक में, हम अभिव्यक्ति में क्या चाहते हैं?

मेरी समझ यह है कि यह 0 और 9 (एक या अधिक बार +) के बीच किसी भी संख्या के बाद किसी भी चरित्र (0 या अधिक बार *) के बाद किसी भी वर्ण (0 या अधिक बार *) के बाद होता है

जब यह निष्पादित होता है तो परिणाम है:

Found value: This order was placed for QT3000! OK? Found value: This order was placed for QT300 Found value: 0 

क्या कोई मेरे साथ इस माध्यम से जा सकता है?

कैप्चरिंग समूह का उपयोग करने का क्या फायदा है?

 import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexTut3 { public static void main(String args[]) { String line = "This order was placed for QT3000! OK?"; String pattern = "(.*)(\\d+)(.*)"; // Create a Pattern object Pattern r = Pattern.compile(pattern); // Now create matcher object. Matcher m = r.matcher(line); if (m.find()) { System.out.println("Found value: " + m.group(0)); System.out.println("Found value: " + m.group(1)); System.out.println("Found value: " + m.group(2)); } else { System.out.println("NO MATCH"); } } } 

वेब के समाधान से एकत्रित समाधान "जावा रेगेक्स कैप्चरिंग समूह"

आपके पास जो समस्या है वह मात्रा के प्रकार के साथ है आप अपने पहले समूह में एक लालची क्वाण्टिफायर का उपयोग कर रहे हैं (इंडेक्स 1 – इंडेक्स 0 पूरे Pattern प्रतिनिधित्व करता है), जिसका मतलब है कि यह जितना भी उतना ही मैच होगा (और यह किसी भी कैरेक्टर के बाद से, इसमें जितने अक्षर होंगे उतने अक्षर होंगे अगले समूहों के लिए स्थिति को पूरा करने के लिए हैं)।

संक्षेप में, आपका पहला समूह .* अगले समूह के रूप में कुछ भी मेल खाता है \\d+ कुछ से मेल खा सकता है (इस मामले में, पिछले अंक)।

तीसरे समूह के अनुसार, यह पिछले अंक के बाद कुछ भी मैच होगा।

यदि आप इसे अपने पहले समूह में एक अनिच्छुक क्वाण्टिफायर में बदलते हैं, तो आपको परिणाम मिलेगा मुझे लगता है कि आप उम्मीद कर रहे हैं, अर्थात 3000 भाग।

प्रथम समूह में प्रश्न चिह्न नोट करें

 String line = "This order was placed for QT3000! OK?"; Pattern pattern = Pattern.compile("(.*?)(\\d+)(.*)"); Matcher matcher = pattern.matcher(line); while (matcher.find()) { System.out.println("group 1: " + matcher.group(1)); System.out.println("group 2: " + matcher.group(2)); System.out.println("group 3: " + matcher.group(3)); } 

आउटपुट:

 group 1: This order was placed for QT group 2: 3000 group 3: ! OK? 

यहां जावा Pattern अधिक जानकारी

अंत में, कैप्चरिंग ग्रुप को गोल ब्रैकेट्स से सीमांकित किया जाता है, और बैक-रेफरेन्स (अन्य चीजों के बीच) का उपयोग करने के लिए एक बहुत ही उपयोगी तरीका प्रदान करता है, एक बार जब आपके Pattern इनपुट से मेल खाए जाते हैं

जावा 6 समूहों में केवल उनके आदेश (नेस्टेड समूहों और ऑर्डर देने की सूक्ष्मता से सावधान रहना) द्वारा संदर्भित किया जा सकता है।

जावा 7 में यह बहुत आसान है, क्योंकि आप नामित समूहों का उपयोग कर सकते हैं।

यह पूरी तरह ठीक है

  1. पहला समूह ( m.group(0) ) हमेशा पूरे क्षेत्र को कैप्चर करता है जो आपके नियमित अभिव्यक्ति से आच्छादित है । इस स्थिति में, यह पूरी स्ट्रिंग है।
  2. रेगुलर एक्सप्रेशंस डिफ़ॉल्ट रूप से लालची हैं, जिसका अर्थ है कि पहले समूह रीगेक्स का उल्लंघन किए बिना जितना संभव हो सके। (.*)(\\d+) (आपके regex का पहला भाग) कवर ...QT300 int पहले समूह और दूसरे में 0
  3. आप पहले समूह को गैर-लालची बनाकर इसे ठीक कर सकते हैं: परिवर्तन (.*) से (.*?)

लालची बनाम आलसी के बारे में अधिक जानकारी के लिए, इस साइट को देखें।

आपकी समझ सही है हालांकि, यदि हम इनके माध्यम से चलते हैं:

  • (.*) पूरे स्ट्रिंग को निगल जाएगा;
  • इसे वापस वर्ण देने की आवश्यकता होगी ताकि (\\d+) satistifed हो (यही कारण है कि 0 को पकड़ा गया है, और 3000 नहीं);
  • आखिरी (.*) तब बाकी को पकड़ लेगा

मुझे यकीन नहीं है कि लेखक का मूल उद्देश्य क्या था, हालांकि।

डॉक्टर से:

 Capturing groups</a> are indexed from left * to right, starting at one. Group zero denotes the entire pattern, so * the expression m.group(0) is equivalent to m.group(). 

तो कब्जा समूह 0 पूरी लाइन भेजें