दिलचस्प पोस्ट
वादे श्रृंखला में कई कैच संभालने कॉलम के उपसमुच्चय पर dplyr म्यूटेट करना बॉक्स लेआउट को साझा किया जा सकता है त्रुटि नहीं फ़ंक्शन परिणाम डिफरेंसिंग के लिए PHP सिंटैक्स जावास्क्रिप्ट चेक बनाम नल बनाम। अपरिभाषित और == और === के बीच का अंतर gapi.auth.signOut (); मैं काम नहीं कर रहा हूँ Angularjs: एक पुनरावर्ती निर्देश समझना PHP filesize एमबी / KB रूपांतरण जावा: लूप init के लिए कई चर को आरंभ करें? डेटा प्रकार में समय क्षेत्र का भंडारण "समय क्षेत्र के साथ टाइमस्टैम्प" अजगर हैश () फ़ंक्शन में निर्मित IIS / ASP.NET के सभी उपयोगकर्ता खाते क्या हैं और वे अलग-अलग कैसे हैं? जावा में CHOLMOD सी ++ में परिपत्र शिफ्ट (घुमाएगी) संचालन के लिए सर्वोत्तम अभ्यास विशिष्ट नामित कनेक्शन या तो कॉन्फ़िगरेशन में नहीं मिला है, जिसका उपयोग एंटिटी क्लाइंट प्रदाता के साथ नहीं किया गया है, या मान्य नहीं है

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

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

मेरी समझ यह है कि यह 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"); } } } 

Solutions Collecting From Web of "जावा रेगेक्स कैप्चरिंग समूह"

आपके पास जो समस्या है वह मात्रा के प्रकार के साथ है आप अपने पहले समूह में एक लालची क्वाण्टिफायर का उपयोग कर रहे हैं (इंडेक्स 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 पूरी लाइन भेजें