जावा रेगेक्स में मैचों () और ढूंढें () के बीच अंतर

Question

मैं matches()और के बीच के अंतर को समझने की कोशिश कर रहा हूं find()।

जावदोक के अनुसार, (जो मुझे समझ में आता है) से, matches()वह जो खोज रहा है वह मिलने पर भी पूरी स्ट्रिंग खोजेगा और find()जब वह खोजेगा तो उसे वही मिलेगा जो उसे खोज रहा है।

यदि यह धारणा सही है, मैं नहीं देख सकते हैं कि जब भी आप उपयोग करना चाहते हैं matches()के बजाय find(), जब तक आप यह पाता मैचों की संख्या की गणना करना चाहते।

मेरी राय में स्ट्रिंग वर्ग को एक अंतर्निर्मित विधि के find()बजाय होना चाहिए matches()।

इसलिए संक्षेप में:

1. क्या मेरी धारणा सही है?
2. matches()इसके बजाय कब उपयोग करना उपयोगी है find()?

Comments

ध्यान रखें कि find()कई बार कॉल करने पर अलग-अलग परिणाम मिल सकते हैं Matcher। नीचे मेरा जवाब देखें।

— एल। होलांडा

Answer 1

matchesपूरे स्ट्रिंग के खिलाफ अभिव्यक्ति का मिलान करने की कोशिश करता है ^और $आपके पैटर्न के अंत में संक्षेप में जोड़ देता है , जिसका अर्थ है कि यह एक विकल्प की तलाश नहीं करेगा। इसलिए इस कोड का उत्पादन:

public static void main(String[] args) throws ParseException {
    Pattern p = Pattern.compile("\\d\\d\\d");
    Matcher m = p.matcher("a123b");
    System.out.println(m.find());
    System.out.println(m.matches());

    p = Pattern.compile("^\\d\\d\\d$");
    m = p.matcher("123");
    System.out.println(m.find());
    System.out.println(m.matches());
}

/* output:
true
false
true
true
*/

123एक विकल्प है a123bताकि find()विधि सही आउटपुट हो। matches()केवल 'देखता है' a123bजो कि एक जैसा नहीं है 123और इस तरह झूठा है।

Comments

यह उत्तर भ्रामक है। matchers()बस find()^ और $ के आसपास निहित के साथ नहीं है । ध्यान रखें कि .find()एक बार से अधिक कॉल करने पर अलग-अलग परिणाम हो सकते हैं यदि पहले से न हों reset(), जबकि matches()हमेशा एक ही परिणाम वापस आएगा। नीचे मेरा जवाब देखें।

— एल। होलांडा

Answer 2

matchesयदि पूरा स्ट्रिंग दिए गए पैटर्न से मेल खाता है तो वापस लौटें। findएक विकल्प खोजने की कोशिश करता है जो पैटर्न से मेल खाता है।

Comments

आप कह सकते हैं कि matches(p)यह वैसा ही है जैसा find("^" + p + "$")कि कोई स्पष्ट हो।

— jensgram

उत्तर को स्पष्ट करने के लिए सिर्फ एक उदाहरण: "[az] +" स्ट्रिंग के साथ "123abc123" मैचों () का उपयोग करने में विफल रहेगा लेकिन खोज () का उपयोग करने में सफल होगा।

— bezmax 12

@ मोम बिल्कुल, के "123abc123".matches("[a-z]+")रूप में असफल हो "123abc123".find("^[a-z]+$")जाएगा। मेरा कहना था, कि matches()एक पूर्ण मैच के लिए जाता है, जैसे find()शुरू और अंत दोनों एंकर।

— jensgram

Pattern.compile("some pattern").matcher(str).matches()के बराबर हैPattern.compile("^some pattern$").matcher(str).find()

— एलेक्सआर

@AlexR / @jensgram: ...("some pattern").matcher(str).matches()यह पहली कॉल में केवल सच के बराबर नहीं है ...("^some pattern$").matcher(str).find()। नीचे मेरा जवाब देखें।

— एल। होलांडा

Answer 3

matches()यदि पूर्ण स्ट्रिंग का मिलान किया जाता है तो केवल सच वापस आएगा। रेगेक्स से मेल खाने वाले सबस्ट्रिंग के भीतर अगली घटना find()को खोजने की कोशिश करेंगे । "अगले" पर जोर दें। इसका अर्थ है, find()कई बार कॉल करने का परिणाम समान नहीं हो सकता है। इसके अलावा, उपयोग करके find()आप start()उस स्थिति को वापस करने के लिए कॉल कर सकते हैं, जब सबस्ट्रिंग का मिलान किया गया था।

final Matcher subMatcher = Pattern.compile("\\d+").matcher("skrf35kesruytfkwu4ty7sdfs");
System.out.println("Found: " + subMatcher.matches());
System.out.println("Found: " + subMatcher.find() + " - position " + subMatcher.start());
System.out.println("Found: " + subMatcher.find() + " - position " + subMatcher.start());
System.out.println("Found: " + subMatcher.find() + " - position " + subMatcher.start());
System.out.println("Found: " + subMatcher.find());
System.out.println("Found: " + subMatcher.find());
System.out.println("Matched: " + subMatcher.matches());

System.out.println("-----------");
final Matcher fullMatcher = Pattern.compile("^\\w+$").matcher("skrf35kesruytfkwu4ty7sdfs");
System.out.println("Found: " + fullMatcher.find() + " - position " + fullMatcher.start());
System.out.println("Found: " + fullMatcher.find());
System.out.println("Found: " + fullMatcher.find());
System.out.println("Matched: " + fullMatcher.matches());
System.out.println("Matched: " + fullMatcher.matches());
System.out.println("Matched: " + fullMatcher.matches());
System.out.println("Matched: " + fullMatcher.matches());

उत्पादन होगा:

पाया: गलत
पाया: सही - स्थिति 4
पाया: सही - स्थिति 17
पाया: सही - स्थिति 20
पाया: गलत
पाया: गलत
मिलान किया गया: गलत
-----------
पाया: सच - स्थिति ०
पाया: गलत
पाया: गलत
मिलान: सच है
मिलान: सच है
मिलान: सच है
मिलान: सच है

तो, find()कई बार कॉल करते समय सावधान रहें यदि Matcherऑब्जेक्ट रीसेट नहीं किया गया था, तब भी जब रेगेक्स चारों ओर से घिरा हुआ हो ^और $पूर्ण स्ट्रिंग से मेल खाता हो।

Comments

बहुत मददगार दोस्त

— DockYard

Answer 4

find()नियमित अभिव्यक्ति के खिलाफ उप-स्ट्रिंग matches()पर विचार करेगा जहां पूर्ण अभिव्यक्ति पर विचार किया जाएगा।

find() तभी सही होगा जब अभिव्यक्ति का उप-स्ट्रिंग पैटर्न से मेल खाता हो।

public static void main(String[] args) {
        Pattern p = Pattern.compile("\\d");
        String candidate = "Java123";
        Matcher m = p.matcher(candidate);

        if (m != null){
            System.out.println(m.find());//true
            System.out.println(m.matches());//false
        }
    }

Answer 5

matches();बफर नहीं है, लेकिन find()बफ़र्स। find()पहले स्ट्रिंग के अंत में खोज, परिणाम अनुक्रमित करता है, और बूलियन मान और संबंधित सूचकांक वापस करता है।

इसीलिए जब आपके पास जैसा कोड होता है

1:Pattern.compile("[a-z]");

2:Pattern.matcher("0a1b1c3d4");

3:int count = 0;

4:while(matcher.find()){

5:count++: }

पर 4: पैटर्न संरचना का उपयोग द्वारा निर्दिष्ट अनुसार अपने कोड (सूचकांक के सूचकांक के पूरे के माध्यम से पढ़ा जाएगा regex इंजन regex[single character]। कम से कम एक मैच खोजने के लिए अगर इस तरह के मिलान हो जाता है, यह तो अनुक्रमित किया जाएगा पाश के आधार पर निष्पादित करेंगे अनुक्रमित परिणाम और अगर यह आगे की गणना की तरह नहीं किया है, जो matches()नहीं करता है। जबकि मिलान किए गए स्ट्रिंग के पहले चरित्र के बाद से कथन कभी भी निष्पादित नहीं होगा।