एक निश्चित प्रकार के शब्द

Question

से पहले सब कुछ मिलान करने के लिए नियमित अभिव्यक्तियों का उपयोग कैसे करें मैं नियमित अभिव्यक्तियों के लिए नया हूं।

जैसे:

यह संभव एक शब्द है कि एक निश्चित मापदंड की पूर्ति से पहले सब कुछ मैच के लिए है

यह एक परीक्षण है - - +++ यह एक परीक्षण

है मैं इसे एक शब्द है जो एक अपरकेस और अगले चरित्र के साथ शुरू होता लोअर केस है सामना करने के लिए करना चाहते हैं। यह एक उचित शब्द का गठन करता है। मैं उस शब्द से पहले सबकुछ हटाना चाहूंगा।

उपरोक्त उदाहरण प्रस्तुत करना चाहिए: यह एक परीक्षण

मैं केवल इस प्रसंस्करण करना चाहते हैं जब तक यह उचित शब्द पाता है और फिर बंद है।

किसी भी मदद की सराहना की जाएगी।

धन्यवाद

Answer 1

रिक्त स्ट्रिंग के साथ

^.*?(?=[A-Z][a-z]) 

बदलें। यह ASCII इनपुट के लिए काम करता है। गैर-ASCII इनपुट (यूनिकोड, अन्य भाषाओं) के लिए, विभिन्न रणनीतियां लागू होती हैं।

स्पष्टीकरण

.*? Everything, until 
(?= followed by 
[A-Z] one of A .. Z and 
[a-z] one of a .. z 
) 

जावा यूनिकोड-सक्षम संस्करण इस होगा:

^.*?(?=\p{Lu}\p{Ll}) 

Answer 2

तो आप इस

'.*([A-Z][a-z].*)\s*' 

.* matches anything 
([A-Z] #followed by an uper case char 
    [a-z] #followed by a lower case 
    .*) #followed by anything 
    \s* #followed by zeror or more white space 

की तरह कुछ कर सकते हैं कौन सा है आप के लिए क्या देख रहे मुझे लगता है कि

Answer 3

थोड़ा जागने के बाद, आपको कुछ भी हटाने की आवश्यकता नहीं है, या यहां तक ​​कि उप-समूह भी बनाना है - केवल जवाब में कहीं और व्यक्त पैटर्न को ढूंढें।

import java.util.regex.*; 

public class Test 
{ 
    public static void main(String args[]) 
    { 
     Pattern pattern = Pattern.compile("[A-Z][a-z].*"); 

     String original = "THIS IS A TEST - - +++ This is a test"; 
     Matcher match = pattern.matcher(original); 
     if (match.find()) 
     { 
      System.out.println(match.group()); 
     } 
     else 
     { 
      System.out.println("No match"); 
     }   
    } 
} 

संपादित करें: यहां एक संपूर्ण उदाहरण है मूल जवाब

यह लगता है कि यह सही बात कर रहा है:

import java.util.regex.*; 

public class Test 
{ 
    public static void main(String args[]) 
    { 
     Pattern pattern = Pattern.compile("^.*?([A-Z][a-z].*)$"); 

     String original = "THIS IS A TEST - - +++ This is a test"; 
     String replaced = pattern.matcher(original).replaceAll("$1"); 

     System.out.println(replaced); 
    } 
} 

मूल रूप से चाल उचित शब्द से पहले सब कुछ अनदेखी करने के लिए नहीं है - यह है उचित शब्द से सब कुछ समूहबद्ध करने के लिए, और उस समूह के साथ पूरे पाठ को प्रतिस्थापित करें।

उपर्युक्त "*** FOO *** I am fond of peanuts" के साथ विफल हो जाएगा क्योंकि "मैं" को उचित शब्द नहीं माना जाएगा। यदि आप इसे ठीक करना चाहते हैं, तो [a-z] को [a-z \ s] में बदलें जो एक अक्षर के बजाय व्हाइटस्पेस की अनुमति देगा।

Answer 4

([ए-जेड] [ए-जेड]।+)

से मेल होगा:

यह एक पाठ है

Answer 5

मुझे पता है, इस पर मेरी राय वास्तव में है कि लोकप्रिय इसलिए तुम लोग गुमनामी में मुझे नीचे-मतदान कर सकते हैं अगर आप चाहते हैं नहीं है, लेकिन मुझे थोड़ा सा रेंट करना है (और इसमें एक समाधान है, पोस्टर द्वारा पूछे जाने वाले तरीके में नहीं)।

मुझे वास्तव में नहीं मिलता है कि लोग नियमित अभिव्यक्तियों पर इतनी जल्दी क्यों जाते हैं।

मैंने बहुत सी स्ट्रिंग पार्सिंग (स्क्रीन-स्क्रैप vt100 मेनू स्क्रीन के लिए प्रयुक्त) की है और मुझे कभी भी एक ऐसा मामला नहीं मिला है जहां नियमित अभिव्यक्ति कोड लिखने से कहीं अधिक आसान होती। (शायद एक जोड़ा थोड़ा आसान होता, लेकिन ज्यादा नहीं)।

मुझे समझ में आता है कि उन्हें एक बार जब आप उन्हें जानते हैं तो उन्हें आसान माना जाता है - लेकिन आप देखते हैं कि कोई इस तरह के एक प्रश्न पूछता है और महसूस करता है कि प्रत्येक प्रोग्रामर के लिए यह सिर्फ चमकने से आसान नहीं है। यदि यह 10 प्रोग्रामर लाइन के नीचे कहीं भी 1 प्रोग्रामर खर्च करता है, तो इसे केवल कोडिंग करने पर बहुत बड़ा नुकसान होता है, भले ही आपने 5 लाइनें लिखने में 5 मिनट लगें।

तो इसे दस्तावेज़ीकरण की आवश्यकता होगी - और यदि कोई भी उस स्तर पर है, तो उसमें आता है, वह दस्तावेज के साथ भी अपने डोमेन के बाहर ज्ञान के बिना इसे संशोधित करने में सक्षम नहीं होगा।

मेरा मतलब है कि पोस्टर को एक मामूली मामला पूछना है - तो वहां मामूली मामला जैसी चीज नहीं है।

public String getRealText(String scanMe) { 
    for(int i=0 ; i < scanMe.length ; i++) 
     if(isUpper(scanMe[i]) && isLower(scanMe[i+1])) 
      return scanMe.subString(i); 
return null; } 

मेरा मतलब यह 5 लाइनों है, लेकिन यह, सरल पठनीय है, और सबसे (सभी?) आरई पारसर्स सबसे तेज़ है। एक बार जब आप किसी विधि में नियमित अभिव्यक्ति को लपेट लेते हैं और टिप्पणी करते हैं, तो आकार में अंतर मापने योग्य नहीं होता है। समय में अंतर - पोस्टर के लिए यह स्पष्ट रूप से बहुत कम समय होगा - क्योंकि यह अगले कोड के लिए हो सकता है जो उसके कोड में आता है।

और यह स्ट्रिंग आपरेशन जो कि यहां तक ​​कि संकेत के साथ सी में आसान हैं में से एक है - और यह भी जल्दी के बाद से परीक्षण कार्यों सी

में मैक्रो नहीं है हो सकता है वैसे, सुनिश्चित करें कि आप बना दूसरे स्लॉट में एक स्थान के लिए, केवल एक कम केस वैरिएबल नहीं, अन्यथा आप ए या आई शब्द से शुरू होने वाली किसी भी पंक्ति को याद करेंगे