java - Splitting List into sublists along elements -

मेरे पास यह सूची है ( सूची & lt; स्ट्रिंग & gt; ):

 < कोड> ["ए", "बी", रिक्त, "सी", रिक्त, "डी", "ई"]  

और मुझे ऐसा कुछ चाहिए:

दूसरे शब्दों में मैं चाहता हूं कि <> "<"> "<">

  [["a", "b"], ["c"], ["d", "e"]]  

सूचियों की सूची ( सूची & lt; सूची & lt; स्ट्रिंग & gt; & gt; ) प्राप्त करने के लिए, सेपरेटर के रूप में null मान का उपयोग करके मेरी सूची को विभाजित करने के लिए। मैं एक जावा 8 समाधान की तलाश में हूं मैंने कलेक्टरों के साथ प्रयास किया है। विभाजित करना लेकिन मुझे यकीन नहीं है कि मैं यही चाहता हूं। धन्यवाद!

इस पल के लिए मैं एकमात्र समाधान अपने खुद के कस्टम कलेक्टर को लागू कर रहा हूं।

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

तो आपको यह जानना होगा कि यदि समानांतर में पाइपलाइन चलाया जाता है तो यह चुपचाप तोड़ने कर देगा।

यह एक वांछनीय व्यवहार नहीं है और से बचा होना चाहिए यही कारण है कि मैं संयोजन के भाग में ( (l1, l2) - & gt; {l1.addAll (l2); रिटर्न एल 1;} के बजाय एक अपवाद फेंक सकता हूं, क्योंकि इसका उपयोग संयोजन के समानांतर में किया जाता है दो सूचियों, ताकि आपके पास गलत परिणाम के बजाय एक अपवाद हो।

इसके अलावा यह सूची प्रतिलिपि के कारण बहुत ही कुशल नहीं है (हालांकि यह अंतर्निहित सरणी को कॉपी करने के लिए एक मूल विधि का उपयोग करता है)।

तो यहां कलेक्टर कार्यान्वयन है:

  निजी स्थिर कलेक्टर & lt; स्ट्रिंग, सूची & lt; सूची & lt; स्ट्रिंग & gt; & gt ;, सूची & lt; सूची & lt; स्ट्रिंग & gt; & gt; & gt; SplitBySeparator (प्रमाणित & lt; स्ट्रिंग & gt; sep) {अंतिम सूची & lt; स्ट्रिंग & gt; वर्तमान = नया ArrayList & lt; & gt; (); रिटर्न कलेक्टर.फ (() - & gt; नया अर्रेलिस्ट & lt; सूची & lt; स्ट्रिंग & gt; & gt; (), (एल, एएमएम) - & gt; {if (sep.test (elem)) {l.add (नया ArrayList & lt; & gt; (चालू)); वर्तमान.क्लर ();} और {वर्तमान.एड (एएमएम);}}, (एल 1, एल 2) -> gt; नया रनटाइम एक्सपैशन ("इसे समानांतर में नहीं चलाना चाहिए");}, l - & gt; {if (current.size ()! = 0) {l.add (चालू); वापसी l;}); }  

और उसका उपयोग कैसे करें:

  सूची & lt; सूची & lt; स्ट्रिंग & gt; & gt; Ll = list.stream ()। इकट्ठा (विभाजित बिहेसिपारेटर (ऑब्जेक्ट :: इज़नल));  

आउटपुट:

  [[a, b], [c], [d, e]]  

<एचआर /> जैसा लगता है, ऐसा लगता है कि यह समानांतर में किया जा सकता है (उस के लिए उसे श्रेय दें!)। इसके साथ यह कस्टम कलेक्टर कार्यान्वयन कम कर देता है:

  निजी स्थिर कलेक्टर & lt; स्ट्रिंग, सूची & lt; सूची & lt; स्ट्रिंग & gt; & gt ;, सूची & lt; सूची & lt; स्ट्रिंग & gt; & gt; & gt; (एआरएएस.एएसएलआईआईएसटी (lt; & gt; ())), (एल, एएमएम) - & gt; (एएलएएम) - & gt; नई एरे लिस्ट & lt; सूची & lt; स्ट्रिंग & gt; & gt; ; {If (sep.test (elem)) {l.add (नया अर्रेलिस्ट & lt; & gt; ());} और l.get (l.size () - 1) .add (elem);}, (l1, L2) - & gt; {l1.get (l1.size () - 1) .addAll (l2.remove (0)); l1.addAll (l2); वापसी l1;}); }  

जो समानांतरवाद के बारे में पैराग्राफ को थोड़ी अप्रचलित करने देते हैं, हालांकि मैं इसे एक अच्छा अनुस्मारक बना सकता हूं।

---

ध्यान दें कि स्ट्रीम एपीआई हमेशा एक विकल्प नहीं है ऐसे कार्य हैं जो धाराओं का उपयोग करना आसान और अधिक उपयुक्त हैं और ऐसे कार्य हैं जो नहीं हैं। आपके मामले में, आप इसके लिए एक उपयोगिता विधि भी बना सकते हैं:

  निजी स्थिर & lt; T & gt; सूची के & lt; सूची से & lt; टी & gt; & gt; SplitBySeparator (सूची & lt; T & gt; सूची, शुद्धिकरण & lt ;? सुपर टी & gt; पूर्वानुमान) {अंतिम सूची & lt; सूची & lt; T & gt; & gt; FinalList = नया अर्रेलिस्ट & lt; & gt; (); Int fromIndex = 0; Int toIndex = 0; के लिए (टी एम्स: सूची) {यदि (predicate.test (एएमएम)) {finalList.add (list.subList (इंडेक्स, टू इंडैक्स) से); FromIndex = toIndex + 1; } Toindex ++; } अगर (से इंडैक्स! = इंडियन) {finalList.add (list.subList (इंडैंड, टू इंडैक्स)); } वापसी अंतिम सूची; }  

और इसे सूची & lt; सूची & lt; स्ट्रिंग & gt; & gt; List = splitBySeparator (मूल लिस्ट, ऑब्जेक्ट :: इज़नल); ।

किनारों के मामलों को जांचने के लिए इसे सुधार किया जा सकता है