कुछ संरचित ऑब्जेक्ट

Question

पर सादे पाठ को पार्स करना मैं सादे पाठ को पार्स करने और इसे कुंजी-मूल्य जोड़े में परिवर्तित करने पर काम कर रहा हूं। उदाहरण के लिए, सादा पाठ:

some_uninteresting_thing 
key1 valueA, some_uninteresting_thing valueB 
key2 valueD 
key3 some_uninteresting_thing valueE 
key4 valueG(valueH, valueI) 
key5 some_uninteresting_thing 

और संभव मैपिंग:

Map(

key1 ->(valueA, valueB,valueC), 
key2 ->(valueD, valueE), 
key3 ->(valueF) 
key4 ->(valueH, valueI) 

... 
) 

Amd परिणाम होगा:

key1 ->(valueA, valueB) 
key2 ->(valueD) 
key4 ->(valueH, valueI) 

(key5 क्योंकि कोई उचित मान हैं मैप नहीं किया जाना चाहिए। जैसा कि आप सादे पाठ को देख सकते हैं। यह जावा पुस्तकालय इसे संभालने में कैसे मदद करेगा?

Answer 1

यदि आप औपचारिक भाषाओं, टोकननाइजेशन/व्याकरण आदि से परिचित हैं, तो आप JavaCC जैसे पार्सर जनरेटर का उपयोग कर सकते हैं। जावासीसी आपके द्वारा लिखी गई व्याकरण फ़ाइल लेता है और जावा कोड उत्पन्न करता है जो पाठ फ़ाइल को टोकन की श्रृंखला, या एक सिटैक्स पेड़ में पार्स करता है। मेवेन और चींटी के लिए प्लगइन हैं जो आपके अतिरिक्त स्रोत को आपके निर्माण में एकीकृत करने में मदद कर सकते हैं।

रनटाइम-केवल समाधान के लिए, RunCC है, जिसे मैंने अच्छे परिणामों के साथ उपयोग किया है। (मुझे संदेह है कि यह जावासीसी जितना तेज नहीं है, लेकिन मेरे मामले के लिए प्रदर्शन ठीक था।)

Chaperon भी है, जो ग्रामर फ़ाइल का उपयोग करके सादा पाठ को एक्सएमएल में परिवर्तित करता है।

इनमें से एक विकल्प रेगेक्स और StringTokenizer के विज्ञापन मिश्रण का उपयोग करना है।

एक पार्सर परियोजना या रेगुलर एक्सप्रेशन से सशस्त्र और तैयार के साथ, अपने सामान्य दृष्टिकोण इस तरह तो है:

1. अपने सादा पाठ फ़ाइल के लिए एक व्याकरण लिखें। कुछ विवरण आपके सादा पाठ प्रारूप के बारे में गायब हैं, लेकिन आप फ़ाइल की लाइनों को पढ़ने के लिए BufferedReader.readLine() और StringTokenizer को रिक्त स्थान और अल्पविरामों पर लाइन को सबस्ट्रिंग में विभाजित करने में सक्षम हो सकते हैं।

2. तार जो आप पार्सर बनाते हैं, पहली स्ट्रिंग जिसे आप कुंजी के रूप में उपयोग करते हैं, और बाद के तार मूल्य हैं, जिन्हें आप मानचित्र में जोड़ते हैं। जैसे छद्म कोड

   मानचित्र> मानचित्र = नया हैश मैप>(); प्रत्येक पंक्ति के लिए { सूची टोकन = ...; // स्ट्रिंग कुंजी = tokens.get (0) को विभाजित करने का परिणाम; map.add (कुंजी, tokens.sublist (1, tokens.size()); }

   यहां तक ​​कि अगर पार्सर नीरस पाठ फ़िल्टर नहीं करता, यह बाद में फ़िल्टर कर दिया जाएगा एक

3. बिल्ड। नक्शा फ़ाइल प्रारूप को पार्स करने के लिए उपर्युक्त परियोजनाओं के साथ पार्सर। फिर, आप रेगेक्स और स्ट्रिंगटोकनाइज़र के साथ एक साधारण पार्सर बनाने में सक्षम हो सकते हैं। नक्शा बनाने के लिए पार्सर का उपयोग करें। मानचित्र के ऊपर जैसा ही हस्ताक्षर है, यानी Map<String,List<String>>.

4. अंत में, अनुमत मान मानचित्र के विरुद्ध इनपुट मानचित्र फ़िल्टर करें।

ऐसा कुछ।

Map<String,List<String>> input = ...; // from step 1. 
    Map<String,List<String>> allowed = ...; // from step 3. 
    Map<String,List<String>> result = new HashMap<String<list<String>>(); // the final map 
    for (String key : input.keySet()) { 
     if (allowd.contains(key)) { 
     List<String> outputValues = new ArrayList(); 
     List<String> allowedValues = allowed.get(key); 
     List<String> inputValues = input.get(key); 
     for (String value: inputValues) { 
      if (allowedValues.contains(value)) 
       outputValues.add(value); 
     } 
     if (!outputValues.isEmpty()) 
      output.put(key, outputValues); 
     } 
    } 
    // final result in filter 

Answer 2

आप एक इंटरप्रेटर और बिल्डर का उपयोग कर सकते हैं।

इंटरप्रेटर स्रोत को पार करता है और बिल्डर को पास की जाने वाली कुंजी और मानों की पहचान करता है, जो आपकी इच्छानुसार किसी भी डेटा संरचना को बनाता है।