java list methods sort list
यह ट्यूटोरियल विभिन्न जावा सूची विधियों जैसे कि क्रमबद्ध सूची, सूची में शामिल सूची, सूची जोड़ें, सूची निकालें, सूची आकार, AddAll, RemoveAll, रिवर्स सूची और अधिक:
हम पहले से ही अपने पिछले ट्यूटोरियल में सामान्य रूप से सूची इंटरफ़ेस पर चर्चा कर चुके हैं। सूची इंटरफ़ेस में विभिन्न विधियाँ हैं जिनका उपयोग सूची की सामग्री में हेरफेर करने के लिए किया जाता है। इन विधियों का उपयोग करके आप सूची में तत्वों को सम्मिलित / हटा सकते हैं, सॉर्ट कर सकते हैं और खोज सकते हैं।
इस ट्यूटोरियल में, हम उन सभी विधियों पर चर्चा करेंगे जो सूची इंटरफ़ेस द्वारा प्रदान की जाती हैं।
=> जावा प्रशिक्षण ट्यूटोरियल के ए-जेड को देखने के लिए यहां देखें।
सूची के माध्यम से पुनरावृति करने के लिए, सूची इंटरफ़ेस सूची का उपयोग करता है। यह सूची पुनरावृत्त इट्रेटर इंटरफ़ेस से फैली है। हमारे अगले ट्यूटोरियल में, हम सूची पुनरावृत्त के बारे में अधिक पता लगाएंगे।
आप क्या सीखेंगे:
- जावा में सूची तरीके
- जावा में एक सूची से डुप्लिकेट निकालें
- बार बार पूछे जाने वाले प्रश्न
- निष्कर्ष
- अनुशंसित पाठ
जावा में सूची तरीके
निम्न तालिका जावा में सूची इंटरफ़ेस द्वारा प्रदान किए गए विभिन्न कार्यों को दिखाती है।
| सूची विधि | विधि प्रोटोटाइप | विवरण |
|---|---|---|
| शामिल | बूलियन होता है (ऑब्जेक्ट ओ) | जाँचता है कि क्या निर्दिष्ट तत्व सूची में मौजूद है और यदि मौजूद है तो वापस लौटाता है |
| आकार | int आकार () | सूची का आकार यानी सूची में तत्वों की संख्या या सूची की लंबाई लौटाता है। |
| स्पष्ट | शून्य स्पष्ट () | सूची के सभी तत्वों को हटाकर सूची को साफ करता है |
| जोड़ना | शून्य जोड़ (इंट इंडेक्स, ऑब्जेक्ट एलिमेंट) | दिए गए तत्व को दी गई सूची में सूची में जोड़ता है |
| बूलियन ऐड (ऑब्जेक्ट ओ) | सूची के अंत में दिए गए तत्व को जोड़ता है | |
| सभी जोड़ें | बूलियन addAll (संग्रह सी) | सूची के अंत में दिए गए संपूर्ण संग्रह को जोड़ता है |
| बूलियन AddAll (int index, Collection c) | दिए गए संग्रह (सभी तत्वों) को निर्दिष्ट सूचकांक में सूची में सम्मिलित करता है | |
| सभी शामिल हैं | बूलियन में सभी होते हैं (संग्रह सी) | निर्दिष्ट संग्रह (सभी तत्व) सूची का हिस्सा है या नहीं, इसकी जांच करता है। लौटता है हाँ का सच। |
| बराबरी | बूलियन बराबर (ऑब्जेक्ट ओ) | सूची के तत्वों के साथ समानता के लिए निर्दिष्ट वस्तु की तुलना करता है |
| प्राप्त | ऑब्जेक्ट मिलता है (इंट इंडेक्स) | सूचकांक द्वारा निर्दिष्ट सूची में तत्व देता है |
| हैश कोड | int हैशकोड () | सूची का हैश कोड मान लौटाता है। |
| indexOf` | int indexOf (ऑब्जेक्ट ओ) | इनपुट तत्व की पहली घटना को ढूँढता है और इसके सूचकांक को लौटाता है |
| खाली है | बूलियन इम्प्टी () | सूची खाली है, तो जाँच करता है |
| lastIndexOf | int lastIndexOf (ऑब्जेक्ट ओ) | सूची में इनपुट तत्व की अंतिम घटना को ढूँढता है और इसके सूचकांक को लौटाता है |
| हटाना | ऑब्जेक्ट निकालें (इंट इंडेक्स) | निर्दिष्ट सूचकांक पर तत्व को निकालता है |
| बूलियन निकालें (ऑब्जेक्ट ओ) | सूची में तत्व को उसकी पहली घटना पर हटा देता है | |
| सभी हटाएं | बूलियन रिमूवल (संग्रह c) | सूची से निर्दिष्ट संग्रह में निहित सभी तत्वों को निकालता है |
| अनुरक्षण | बूलियन रिटेल (संग्रह सी) | निष्कासन के विपरीत। सूची में इनपुट संग्रह में निर्दिष्ट तत्व को रखता है। |
| सेट | ऑब्जेक्ट सेट (इंट इंडेक्स, ऑब्जेक्ट एलिमेंट) | निर्दिष्ट मान पर सेट करके तत्व को निर्दिष्ट सूचकांक में बदलता है |
| वश में करनेवाला | सूची सूची (int fromIndex, intIndex) | तत्वों से समावेशी की रिटर्न देता है (समावेशी), औरIndex (अनन्य)। |
| तरह | शून्य प्रकार (तुलनित्र c) | आदेश दिए गए सूची देने के लिए निर्दिष्ट तुलनित्र के अनुसार सूची तत्व को सॉर्ट करता है |
| .अरे | ऑब्जेक्ट () toArray () | सूची की सरणी प्रतिनिधित्व लौटाता है |
| ऑब्जेक्ट () ऐरे (ऑब्जेक्ट () ए) | सरणी प्रतिनिधित्व को लौटाता है जिसका रनटाइम प्रकार निर्दिष्ट सरणी तर्क के समान है | |
| इटरेटर | इटरेटर इटरेटर () | सूची के लिए एक Iterator देता है |
| सूची बनानेवाला | सूची सूची सूची () | सूची के लिए सूची सूची लौटाता है |
| सूची सूची सूची (अंतर सूचकांक) | सूची में निर्दिष्ट सूचकांक में शुरू होने वाले एक सूची सूची लौटाता है |
आगे, हम इन कार्यों के साथ उनके उदाहरणों पर चर्चा करेंगे।
आकार
प्रोटोटाइप: int आकार ()
पैरामीटर: शून्य
प्रतिलाभ की मात्रा: int => सूची में तत्वों की संख्या या दूसरे शब्दों में सूची की लंबाई।
विवरण: आकार () तत्वों की संख्या या सूची का आकार लौटाता है। इसे सरल शब्दों में लंबाई भी कहा जा सकता है।
स्पष्ट
प्रोटोटाइप: शून्य स्पष्ट ()
पैरामीटर: शून्य
प्रतिलाभ की मात्रा: कोई वापसी मूल्य नहीं
विवरण: सूची के सभी तत्वों को हटाकर सूची को साफ़ करता है। यदि ऑपरेशन सूची द्वारा समर्थित नहीं है, तो 'UnSupportedException' को फेंकता है।
नीचे दिया गया उदाहरण आकार () और स्पष्ट () विधि प्रदर्शित करेगा।
import java.util.*; public class Main { public static void main(String() args) { List strList = new ArrayList(); // Creating a list //add items to list strList.add('Java'); strList.add('C++'); //print the size of list System.out.println('Size of list:' + strList.size()); //add more items to list strList.add('Ruby'); strList.add('Python'); strList.add('C#'); //print the size of list again System.out.println('Size of list after adding more elements:' + strList.size()); //clear method strList.clear(); System.out.println('List after calling clear() method:' + strList); } } आउटपुट:
जोड़ना
प्रोटोटाइप: शून्य जोड़ (इंट इंडेक्स, ऑब्जेक्ट एलिमेंट)
पैरामीटर: सूचकांक- एक स्थिति जिस पर तत्व को जोड़ा जाना है।
तत्व- जोड़ा जाने वाला तत्व
प्रतिलाभ की मात्रा: शून्य
विवरण: दिए गए तत्व को दी गई सूची में सूची में जोड़ता है। बाद के तत्वों को दाईं ओर स्थानांतरित कर दिया जाता है।
निम्नलिखित अपवाद फेंके गए हैं:
IndexOutOfBoundsException: सूची सूचकांक सीमा से बाहर है
UnsupportedOperationException: सूची से जोड़ें ऑपरेशन समर्थित नहीं है।
क्लासकैस्ट अपवाद: तत्व को निर्दिष्ट तत्वों के वर्ग के कारण सूची में नहीं जोड़ा जा सकता है।
अवैध तर्क अपवाद: निर्दिष्ट तत्व या कुछ पहलू सही नहीं है।
जोड़ना
प्रोटोटाइप: बूलियन ऐड (ऑब्जेक्ट ओ)
पैरामीटर: o => सूची में जोड़े जाने वाले तत्व
प्रतिलाभ की मात्रा: true => तत्व सफलतापूर्वक जोड़ा गया
मिथ्या => सफल नहीं जोड़ें
विवरण: यह विधि सूची के अंत में दिए गए तत्व को जोड़ती है।
यह ऑपरेशन निम्नलिखित अपवादों को फेंक सकता है।
UnsupportedOperationException: इस सूची द्वारा समर्थित नहीं ऑपरेशन जोड़ें।
क्लासकैस्ट अपवाद: इसकी कक्षा के कारण निर्दिष्ट तत्व नहीं जोड़ा जा सकता है
अवैध तर्क अपवाद: निर्दिष्ट तत्व या कुछ पहलू सही नहीं है।
सभी जोड़ें
प्रोटोटाइप: बूलियन addAll (संग्रह सी)
पैरामीटर: c => संग्रह जिनके तत्वों को सूची में जोड़ा जाना है
प्रतिलाभ की मात्रा: true => विधि निष्पादन सफल
विवरण: AddAll पद्धति संग्रह सी से सभी तत्वों को लेती है और उन्हें सेट किए गए क्रम को बनाए रखते हुए सूची के अंत तक जोड़ देती है।
यह विधि अनिर्दिष्ट व्यवहार को प्रदर्शित करती है यदि ऑपरेशन प्रगति पर है तो संग्रह को बदल दिया जाता है।
विधि निम्न अपवाद फेंकता है:
UnsupportedOperationException: इस सूची द्वारा समर्थित नहीं ऑपरेशन जोड़ें।
क्लासकैस्ट अपवाद: इसकी कक्षा के कारण निर्दिष्ट तत्व नहीं जोड़ा जा सकता है।
अवैध तर्क अपवाद: निर्दिष्ट तत्व या कुछ पहलू सही नहीं है।
सभी जोड़ें
प्रोटोटाइप: बूलियन AddAll (int index, Collection c)
पैरामीटर: सूचकांक => वह स्थिति जिस पर संग्रह डाला जाना है।
C => संग्रह जो सूची में डाला जाना है।
प्रतिलाभ की मात्रा: true => यदि संग्रह तत्वों को सूची में सफलतापूर्वक जोड़ा जाता है।
विवरण: AddAll विधि निर्दिष्ट संग्रह में सूची में निर्दिष्ट संग्रह में सभी तत्वों को सम्मिलित करती है। इसके बाद के तत्वों को दाईं ओर स्थानांतरित कर दिया जाता है। जैसा कि addAll के पिछले अधिभार के मामले में, व्यवहार अनिर्दिष्ट है यदि संग्रह प्रगति पर है, तो संग्रह को बदल दिया जाता है।
इस विधि द्वारा फेंके गए अपवाद हैं:
UnsupportedOperationException: इस सूची द्वारा समर्थित नहीं ऑपरेशन जोड़ें।
क्लासकैस्ट अपवाद: इसकी कक्षा के कारण निर्दिष्ट तत्व नहीं जोड़ा जा सकता है।
अवैध तर्क अपवाद: निर्दिष्ट तत्व या कुछ पहलू सही नहीं है।
IndexOutOfBoundsException: सूचकांक सीमा से बाहर।
नीचे दिए गए कार्यक्रम में सूची के ऐड और एडऑल तरीकों का प्रदर्शन दिखाया गया है।
import java.util.*; public class Main { public static void main(String() args) { List strList = new ArrayList(); // Creating a list strList.add('Java'); strList.add('C++'); //print the list System.out.println('List after adding two elements:' + strList); List llist = new ArrayList(); // Create another list llist.add('Ruby'); llist.add('Python'); llist.add('C#'); // addAll method - add llist to strList strList.addAll(llist); System.out.println('List after addAll:'+ strList); } } आउटपुट:
शामिल
प्रोटोटाइप: बूलियन होता है (ऑब्जेक्ट ओ)
पैरामीटर: o => सूची में खोजा जाने वाला तत्व।
प्रतिलाभ की मात्रा: सत्य => यदि सूची में निर्दिष्ट तत्व है।
विवरण: यदि विधि निर्दिष्ट सूची में मौजूद है और यदि तत्व मौजूद है तो एक बूलियन मान लौटाता है, तो विधि में 'जांच' शामिल है। अन्यथा, यह गलत है।
सभी शामिल हैं
प्रोटोटाइप: बूलियन में सभी होते हैं (संग्रह सी)
पैरामीटर: c => सूची में खोजा जाने वाला संग्रह।
प्रतिलाभ की मात्रा: सत्य => यदि निर्दिष्ट संग्रह के सभी तत्व सूची में मौजूद हैं।
विवरण: यदि सभी निर्दिष्ट तत्व सूची में मौजूद हैं, तो 'समास' विधि जांचता है। यदि वर्तमान में यह एक सही मूल्य देता है और अन्यथा गलत है।
निम्न जावा प्रोग्राम सूची के 'समाहित' और 'समाहित' के तरीकों को प्रदर्शित करता है।
import java.util.*; public class Main { public static void main(String() args) { //define list of strings List list = new ArrayList(); //initialize list to strings list.add('Java'); list.add('Xml'); list.add('Python'); list.add('Ruby'); list.add('JavaScript'); //contains method demo if(list.contains('C')==true) System.out.println('Given list contains string 'C''); else if(list.contains('Java')==true) System.out.println('Given list contains string 'Java' but not string 'C''); //containsAll method demo List myList = new ArrayList(); myList.add('Ruby'); myList.add('Python'); if(list.containsAll(myList)==true) System.out.println('List contains strings 'Ruby' and 'Python''); } }आउटपुट:
दी गई सूची में स्ट्रिंग 'जावा' है, लेकिन स्ट्रिंग 'सी' नहीं है।
सूची में तार 'रूबी' और 'पायथन' शामिल हैं
बराबरी
प्रोटोटाइप: बूलियन बराबर (ऑब्जेक्ट ओ)
पैरामीटर: o => वह वस्तु जिसे समानता के लिए परखा जाना हो।
प्रतिलाभ की मात्रा: true => यदि दी गई वस्तु सूची के बराबर है।
विवरण: इस विधि का उपयोग समानता की सूची के साथ दिए गए ऑब्जेक्ट की तुलना करने के लिए किया जाता है। यदि निर्दिष्ट ऑब्जेक्ट एक सूची है, तो विधि सही है। दोनों सूचियों को समान रूप से कहा जाता है यदि और केवल यदि वे समान आकार के हैं, और दो सूचियों में संबंधित तत्व समान और समान क्रम में हैं।
समान पद्धति का प्रदर्शन नीचे दिया गया है:
import java.util.LinkedList; import java.util.List; public class Main { public static void main(String() args) { //define lists List first_list= new LinkedList(); List second_list = new LinkedList(); List third_list = new LinkedList(); //initialize lists with values for (int i=0;i<11;i++){ first_list.add(i); second_list.add(i); third_list.add(i*i); } //print each list System.out.println('First list: ' + first_list); System.out.println('Second list: ' + second_list); System.out.println('Third list: ' + third_list); //use equals method to check equality with each list to other if (first_list.equals(second_list) == true) System.out.println('
first_list and second_list are equal.
'); else System.out.println('first_list and second_list are not equal.
'); if(first_list.equals(third_list)) System.out.println('first_list and third_list are equal.
'); else System.out.println('first_list and third_list are not equal.
'); if(second_list.equals(third_list)) System.out.println('second_list and third_list are equal.
'); else System.out.println('second_list and third_list are not equal.
'); } } आउटपुट:
प्राप्त
प्रोटोटाइप: ऑब्जेक्ट मिलता है (इंट इंडेक्स)
पैरामीटर: सूचकांक => वह स्थिति जिस पर तत्व को लौटाया जाना है।
प्रतिलाभ की मात्रा: ऑब्जेक्ट => निर्दिष्ट स्थान पर तत्व।
विवरण: दी गई स्थिति में तत्व प्राप्त करता है।
यह विधि 'indexOutOfBoundsException' को फेंकता है यदि निर्दिष्ट सूचकांक सूची की सीमा से बाहर है।
सेट
प्रोटोटाइप: ऑब्जेक्ट सेट (इंट इंडेक्स, ऑब्जेक्ट एलिमेंट)
पैरामीटर: index => वह स्थिति जिस पर नया तत्व सेट किया जाना है।
तत्व => सूचकांक द्वारा दिए गए स्थान पर रखा जाने वाला नया तत्व।
प्रतिलाभ की मात्रा: ऑब्जेक्ट => तत्व जो प्रतिस्थापित किया गया था
विवरण: विधि सेट () तत्व को दिए गए सूचकांक में तत्व द्वारा दिए गए एक और मूल्य द्वारा प्रतिस्थापित करता है।
विधि निम्नलिखित अपवादों को फेंक सकती है:
UnsupportedOperationException: सेट ऑपरेशन सूची द्वारा समर्थित नहीं है।
क्लासकैस्ट अपवाद: तत्व के वर्ग के कारण ऑपरेशन नहीं किया जा सकता है
अवैध तर्क अपवाद: तर्क या उसका कोई पहलू गैरकानूनी है
IndexOutOfBoundsException: सूचकांक सीमा से बाहर।
निम्नलिखित कार्यक्रम प्राप्त () और सेट () विधि का एक उदाहरण दिखाता है।
import java.util.*; public class Main { public static void main(String() args) { //define list List listA = new ArrayList(); listA.add('Java'); listA.add('C++'); listA.add('Python'); //access list elements using index with get () method System.out.println('Element at index 0:' + listA.get(0)); System.out.println('Element at index 1:' + listA.get(1)); System.out.println('Element at index 2:' + listA.get(2)); //set element at index 1 to Ruby listA.set(1,'Ruby'); System.out.println('Element at index 1 changed to :' + listA.get(1) ); } } आउटपुट:
हैश कोड
प्रोटोटाइप: int हैशकोड ()
पैरामीटर: शून्य
प्रतिलाभ की मात्रा: int => सूची का हैशकोड
विवरण: विधि has हैशकोड () 'सूची का हैशकोड लौटाती है जो पूर्णांक मान है।
उदाहरण:
import java.util.*; public class Main { public static void main(String() args) { // Initializing a list of type Linkedlist List mylist = new LinkedList(); mylist.add(1); mylist.add(3); mylist.add(5); mylist.add(7); //print the list System.out.println('The list:' + mylist); //use hashCode() method to find hashcode of list int hash = mylist.hashCode(); System.out.println('Hashcode for list:' + hash); } } आउटपुट:
खाली है
प्रोटोटाइप: बूलियन इम्प्टी ()
पैरामीटर: शून्य
प्रतिलाभ की मात्रा: true => सूची खाली है
विवरण: सूची खाली होने पर theEmpty () विधि जांचती है IsEmpty विधि का उपयोग यह जांचने के लिए किया जाता है कि क्या उन तत्वों को संसाधित करने से पहले सूची में कोई तत्व हैं।
के सूचकांक
प्रोटोटाइप: int indexOf (ऑब्जेक्ट ओ)
पैरामीटर: सूची में खोज करने के लिए ओ => तत्व
प्रतिलाभ की मात्रा: int => सूची में दिए गए तत्व की पहली घटना का सूचकांक या स्थिति। रिटर्न -1 अगर तत्व मौजूद नहीं है।
विवरण: विधि of indexOf () ’सूची में दिए गए तत्व o की पहली घटना का सूचकांक लौटाती है। यदि तत्व नहीं मिला है तो यह रिटर्न -1 है।
lastIndexOf
प्रोटोटाइप: int lastIndexOf (ऑब्जेक्ट ओ)
पैरामीटर: o => ऑब्जेक्ट जिसका सूचकांक खोजा जाना है
प्रतिलाभ की मात्रा: int => सूची में दिए गए तत्व की अंतिम घटना का सूचकांक, -1 अन्यथा।
विवरण: विधि returns lastIndexOf () ’सूची में तत्व ओ के अंतिम घटना का सूचकांक लौटाती है। यदि तत्व नहीं मिला है, तो विधि -1 लौटती है।
नीचे जावा प्रोग्राम सूची के indexOf और lastIndexOf तरीकों के उपयोग को प्रदर्शित करता है।
import java.util.*; public class Main { public static void main(String() args) { // define an integer array List intList = new ArrayList(5); //add elements to the list intList.add(10); intList.add(20); intList.add(30); intList.add(10); intList.add(20); //print the list System.out.println('The list of integers:' + intList); // Use indexOf() and lastIndexOf() methods of list to find first and last index System.out.println('first index of 20:' + intList.indexOf(20)); System.out.println('last index of 10:' + intList.lastIndexOf(10)); } } आउटपुट:
हटाना
प्रोटोटाइप: ऑब्जेक्ट निकालें (इंट इंडेक्स)
पैरामीटर: सूचकांक => उस सूची में सूचकांक या स्थिति जिस पर तत्व को हटाया जाना है
प्रतिलाभ की मात्रा: ऑब्जेक्ट => तत्व हटाया गया
विवरण: At निकालें () 'विधि सूची से दिए गए स्थान पर तत्व को हटा देती है। हटाने के बाद, हटाए गए तत्व के बगल वाले तत्वों को बाएं स्थानांतरित कर दिया जाता है।
यह विधि निम्नलिखित अपवादों को फेंक सकती है:
UnsupportedOperationException: निकालें सूची द्वारा समर्थित नहीं है।
IndexOutOfBoundsException: निर्दिष्ट सूचकांक सीमा से बाहर है
हटाना
प्रोटोटाइप: बूलियन निकालें (ऑब्जेक्ट ओ)
पैरामीटर: o => सूची से हटाया जाने वाला तत्व
प्रतिलाभ की मात्रा: true => तत्व सफलतापूर्वक हटा दिया गया है।
विवरण: हटाने () विधि का यह अतिभारित संस्करण सूची से दिए गए तत्व ओ की पहली घटना को हटाता है। यदि दिए गए तत्व सूची में मौजूद नहीं है, तो यह अपरिवर्तित रहता है।
यह विधि निम्नलिखित अपवाद फेंक सकती है:
UnsupportedOperationException: निकालें सूची द्वारा समर्थित नहीं है।
सभी हटाएं
प्रोटोटाइप: बूलियन रिमूवल (संग्रह c)
पैरामीटर: c => एक संग्रह जिसमें ऐसे तत्व होते हैं जिन्हें सूची से हटा दिया जाता है।
प्रतिलाभ की मात्रा: true => यदि विधि कॉल सफल है और संग्रह c में निर्दिष्ट सभी तत्व सूची से हटा दिए गए हैं।
विवरण: To निष्कासन () 'विधि का उपयोग सूची के सभी तत्वों को निकालने के लिए किया जाता है जो संग्रह c में निर्दिष्ट हैं जो एक तर्क के रूप में पारित किया गया है।
यह विधि निम्नलिखित अपवाद फेंक सकती है:
UnsupportedOperationException: निष्कासन सूची द्वारा समर्थित नहीं है।
हमें हटाने और हटाने के तरीकों का एक उदाहरण देखते हैं।
import java.util.*; public class Main { public static void main(String() args) { // Creating a list List oddList = new ArrayList(); //add elements to the list oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); oddList.add(11); //print the original list System.out.println('Original List:' + oddList); // Removes element from index 1 oddList.remove(1); System.out.println('Oddlist after removing element at index 1:' + oddList); //removeAll method List c1 = new ArrayList(); c1.add(1); c1.add(5); c1.add(11); oddList.removeAll(c1); System.out.println('Oddlist after removing elements {1,5,11}}:' + oddList); } } आउटपुट:
अनुरक्षण
प्रोटोटाइप: बूलियन रिटेल (संग्रह सी)
पैरामीटर: c => संग्रह जिसमें ऐसे तत्व शामिल हैं जिन्हें सूची में बनाए रखा जाना चाहिए।
प्रतिलाभ की मात्रा: true => यदि मेथड कॉल ने सूची बदल दी।
विवरण: यह विधि उन सभी तत्वों को सूची से हटा देती है, सिवाय उनके जो संग्रह c में मौजूद हैं। दूसरे शब्दों में, यह विधि सूची के सभी तत्वों को बनाए रखती है जो संग्रह c में मौजूद हैं और अन्य तत्वों को निकालता है।
यह विधि निम्नलिखित अपवाद फेंक सकती है:
UnsupportedOperationException: अनुरक्षण सूची द्वारा समर्थित नहीं है।
import java.util.*; public class Main { public static void main(String() args) { // Creating a list List oddList = new ArrayList(); //add elements to the list oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); oddList.add(11); //print the original list System.out.println('Original List:' + oddList); //retainAll method List c1 = new ArrayList(); c1.add(1); c1.add(5); c1.add(11); oddList.retainAll(c1); System.out.println('Oddlist after call to retainAll (1,5,11):' + oddList); } } आउटपुट:
वश में करनेवाला
प्रोटोटाइप: सूची सूची (int fromIndex, intIndex)
पैरामीटर: fromIndex => सूची का निचला सूचकांक (सम्मिलित)
ofIndex => सूची का उच्च सूचकांक (अनन्य)
प्रतिलाभ की मात्रा: सूची => दी गई सूची की एक उप-सूची
विवरण: विधि की सूची () सूची का आंशिक दृश्य लौटाती है, जिसे ’इंडेक्स से I’ इंडिंडेक्स ’तक की सूची के रूप में भी जाना जाता है। दी गई सबलिस्ट केवल मूल सूची का एक दृश्य है और इस प्रकार या तो सूची में किए गए कोई भी परिवर्तन हर जगह प्रतिबिंबित होते हैं।
इसी तरह, सूची के सभी ऑपरेशन भी एक सबलिस्ट पर काम करते हैं।
विधि निम्नलिखित अपवाद फेंक सकती है:
IndexOutOfBoundsException: अवैध toIndex मान।
सबलिस्ट विधि के लिए एक उदाहरण कार्यक्रम नीचे दिया गया है।
import java.util.*; public class Main { public static void main(String() args) { // define a string list List strList = new ArrayList(5); //add elements to the list strList.add('Java'); strList.add('Tutorials'); strList.add('Collection'); strList.add('Framework'); strList.add('Series'); //print the original list System.out.println('The original list=>strList: ' + strList); //define another list List subList = new ArrayList(); // take a sublist of elements from 2 to 4 from strList subList = strList.subList(2, 4); //print the sublist System.out.println('The sublist of strList:' + subList); } } आउटपुट:
क्रमबद्ध सूची
प्रोटोटाइप: शून्य प्रकार (तुलनित्र c)
पैरामीटर: c => तुलनित्र जिसके आधार पर सूची को क्रमबद्ध किया जाता है।
प्रतिलाभ की मात्रा: शून्य
विवरण: सूची को सॉर्ट करने के लिए ‘सॉर्ट () 'विधि का उपयोग किया जाता है। विधि सूची को सॉर्ट करने के लिए निर्दिष्ट तुलनित्र का उपयोग करती है।
आइए हम सॉर्ट विधि का एक उदाहरण देखें । हमने इसकी तुलना कलेक्शंस.सॉर्ट विधि से की है जो तत्वों को प्राकृतिक अनुक्रम में क्रमबद्ध करता है। कार्यक्रम का आउटपुट एक ऑर्डर की गई सूची है।
import java.util.Collections; import java.util.ArrayList; import java.util.List; import java.util.Random; public class Main { public static void main(String() args) { //define list List intArray = new ArrayList(); Random random = new Random(); //populate the list with random numbers <20 for (int i = 0; i {return (o2-o1);}); //comparator to sort in reverse System.out.println('Reverse List sorted using comparator:
'+intArray); } }आउटपुट:
.अरे
प्रोटोटाइप: ऑब्जेक्ट () toArray ()
पैरामीटर: शून्य
प्रतिलाभ की मात्रा: ऑब्जेक्ट () => सूची का एरे प्रतिनिधित्व
विवरण: विधि toArray () उचित क्रम में सूची का सरणी प्रतिनिधित्व लौटाता है।
.अरे
प्रोटोटाइप: ऑब्जेक्ट () ऐरे (ऑब्जेक्ट () ए)
पैरामीटर: a => सरणी प्रकार जो सूची को किसी सरणी में परिवर्तित करते समय तत्व प्रकारों को सूचीबद्ध करने के लिए मिलान किया जाना है।
प्रतिलाभ की मात्रा: ऑब्जेक्ट () => सूची का एरे प्रतिनिधित्व।
विवरण: विधि का ओवरलोड () () एरे में सूची में मौजूद एलीमेंट प्रकारों को ए.आर.
यह विधि निम्नलिखित अपवाद फेंक सकती है:
ArrayStoreException: सूची में प्रत्येक तत्व का रनटाइम प्रकार इस सूची में प्रत्येक तत्व के रनटाइम प्रकार का उपप्रकार नहीं है।
निम्नलिखित एरायर विधि के कार्यान्वयन का एक उदाहरण है।
import java.util.*; public class Main { public static void main(String() args) { // create list ArrayList colorsList = new ArrayList(7); // add colors to colorsList colorsList.add('Violet'); colorsList.add('Indigo'); colorsList.add('Blue'); colorsList.add('Green'); colorsList.add('Yellow'); colorsList.add('Orange'); colorsList.add('Red'); System.out.println('Size of the colorsList: ' + colorsList.size()); // Print the colors in the list System.out.println('Contents of colorsList:'); for (String value : colorsList){ System.out.print(value + ' '); } // Create an array from the list using toArray method String colorsArray() = new String(colorsList.size()); colorsArray = colorsList.toArray(colorsArray); // Display the contents of the array System.out.println('
Printing elements of colorsArray:' + Arrays.toString(colorsArray)); } }आउटपुट:
इटरेटर
प्रोटोटाइप: इटरेटर इटरेटर ()
पैरामीटर: शून्य
प्रतिलाभ की मात्रा: Iterator => Iterator सूची के तत्वों पर पुनरावृति करने के लिए
विवरण: यह विधि सूची में तत्वों पर पुनरावृति करने वाले पुनरावृत्ति देता है।
जावा प्रोग्रामर का उपयोग करके प्रदर्शित करने के लिए कार्यक्रम।
import java.util.*; public class Main { public static void main(String() args) { // create list ArrayList colorsList = new ArrayList(7); // add colors to colorsList colorsList.add('Violet'); colorsList.add('Indigo'); colorsList.add('Blue'); colorsList.add('Green'); colorsList.add('Yellow'); colorsList.add('Orange'); colorsList.add('Red'); System.out.println('ColorList using iterator:'); //define iterator for colorsList Iterator iterator = colorsList.iterator(); //iterate through colorsList using iterator and print each item while(iterator.hasNext()){ System.out.print(iterator.next() + ' '); } } } आउटपुट:
सूची बनानेवाला
प्रोटोटाइप: सूची सूची सूची ()
पैरामीटर: शून्य
प्रतिलाभ की मात्रा: सूची में तत्वों की सूची = सूचीकर्ता =>।
विवरण: विधि सूची सूची () सूची में तत्वों की सूची सूची वस्तु लौटाती है। यह पुनरावृत्ति सूची की शुरुआत से शुरू होती है यानी इंडेक्स 0।
सूची बनानेवाला
प्रोटोटाइप: सूची सूची सूची (अंतर सूचकांक)
पैरामीटर: index => वह स्थिति जिस पर सूचीकर्ता प्रारंभ होता है।
प्रतिलाभ की मात्रा: ListIterator => सूची में निर्दिष्ट सूचकांक में सूची-वस्तु वस्तु।
विवरण: विधि सूची अधिलेखक () का अधिभार एक सूची सूची लौटाता है जो सूची में दिए गए स्थान पर शुरू होता है। दिए गए इंडेक्स से संकेत मिलता है कि यह पहला तत्व होगा जिसे पहली कॉल द्वारा वापस लौटा दिया जाएगा।
विधि अनुक्रमणिका के अमान्य मान के लिए IndexOutOfBoundsException को फेंक सकता है।
7 साल के अनुभव के लिए सेलेनियम साक्षात्कार प्रश्न
निम्न उदाहरण listIterator उपयोग प्रदर्शित करता है।
import java.util.*; public class Main { public static void main(String() args) { //define list & add items to list List nameList = new LinkedList(); nameList.add('Java'); nameList.add('C++'); nameList.add('Python'); // get listIterator for the list ListIterator namesIterator = nameList.listIterator(); // Traverse list using listiterator and print each item System.out.println('Contents of list using listIterator:'); while(namesIterator.hasNext()){ System.out.print(namesIterator.next() + ' '); } } } आउटपुट:
हम बाद में विस्तार से ListIterator पर चर्चा करेंगे।
आइए अब कुछ ऐसे विविध ऑपरेशनों के बारे में चर्चा करें, जो सूचियों पर किए जा सकते हैं, लेकिन इसके लिए तरीके सूची इंटरफ़ेस में प्रदान नहीं किए गए हैं।
जावा में कॉपी लिस्ट
एक सूची के तत्वों को किसी अन्य सूची में कॉपी करने के लिए, आपको संग्रह ढांचे द्वारा प्रदान की गई प्रतिलिपि () विधि का उपयोग करना होगा।
विधि Collections.copy () दूसरे तर्क के रूप में प्रदान की गई सूची के सभी तत्वों को पहले तर्क के रूप में प्रदान की गई सूची में कॉपी करती है। ध्यान दें कि जिस सूची में दूसरी सूची की सामग्री हो रही है वह कॉपी किए गए तत्वों को समायोजित करने के लिए पर्याप्त बड़ी होनी चाहिए।
यदि सूची पर्याप्त बड़ी नहीं है, तो प्रतिलिपि विधि 'indexOutOfBoundsEexception' फेंकता है।
निम्न प्रोग्राम एक सूची की सामग्री को दूसरे में कॉपी करता है।
import java.util.*; public class Main { public static void main(String() args) { //create first ArrayList object List aList_1 = new ArrayList(); //Add elements to first ArrayList aList_1.add('R'); aList_1.add('G'); aList_1.add('B'); //print the List System.out.println('The first list:' + aList_1); //create second ArrayList object List aList_2 = new ArrayList(); //Add elements to second Arraylist aList_2.add('Red'); aList_2.add('Green'); aList_2.add('Blue'); aList_2.add('Yellow'); aList_2.add('Brown'); System.out.println('The second list: ' + aList_2); //use Collections.copy() method to copy elements of first list to second list. Collections.copy(aList_2,aList_1); //print the resultant second Arraylist System.out.println('
The second list after copying first list to second list: ' + aList_2); } } आउटपुट:
जावा में एक सूची से डुप्लिकेट निकालें
एक दी गई सूची में दोहराव वाले तत्व या डुप्लिकेट नहीं हो सकते हैं। यदि आप जिस सूची के साथ काम कर रहे हैं, उसमें डुप्लिकेट तत्व हैं और आप सूची में सभी अलग-अलग तत्व चाहते हैं, तो जावा में समर्थित सूची से डुप्लिकेट को निकालने के दो तरीके हैं।
जावा 8 स्ट्रीम का उपयोग करना
सूची से डुप्लिकेट को हटाने के लिए पहली विधि जावा 8 स्ट्रीम द्वारा प्रदान की गई विशिष्ट () विधि का उपयोग करके है। यहां, डुप्लिकेट वाली सूची स्ट्रीम () .distinct विधि और फिर रिटर्न मान को एक नई सूची में बदल देती है, जिसमें केवल विशिष्ट तत्व होंगे।
निम्नलिखित कार्यक्रम विशिष्ट () विधि के उपयोग को प्रदर्शित करता है।
import java.util.*; import java.util.stream.Collectors; class Main { public static void main(String() args) { // original list List intlist = new ArrayList( Arrays.asList(1, 1, 1, 2, 2, 3, 3, 3, 4, 5, 5,6,5,3,4)); // Print the list System.out.println('Original ArrayList: ' + intlist); // using distinct() method of Java 8 stream remove duplicates from original List //and generate a new list without duplicates List distinct_list = intlist.stream().distinct() .collect(Collectors.toList()); // Print the new list System.out.println('ArrayList after removing duplicates: ' + distinct_list); } } आउटपुट:
इटरेटर दृष्टिकोण का उपयोग करना
सूची का उपयोग करके डुप्लिकेट को हटाना एक लंबा और आदिम दृष्टिकोण है। इस दृष्टिकोण में, आपको सूची से पार करना होगा और हर तत्व की पहली घटना को एक नई सूची में डालना होगा। यदि इसके डुप्लिकेट होने पर हर बाद वाले तत्व की जाँच की जाती है
नीचे दिया गया कार्यक्रम इसे प्राप्त करता है।
import java.util.*; public class Main { public static void main(String args()) { // create original list ArrayList aList = new ArrayList( Arrays.asList(1, 1, 1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 5, 3, 4)); // Print the original list System.out.println('Original List: '+ aList); // Create a new list ArrayList new_List = new ArrayList(); // Traverse through the original list to remove duplicates for (Integer element : aList) { // check if element is present in new_List, else add it if (!new_List.contains(element)) { new_List.add(element); } } // Print the new list without duplicates System.out.println('List after removing duplicates: '+ new_List); } } आउटपुट:
बार बार पूछे जाने वाले प्रश्न
Q # 1) जावा में सूची में विधि क्या है?
उत्तर: सूची की विधि का उपयोग सूचकांक के आधार पर सूची में किसी विशेष तत्व को प्राप्त करने के लिए किया जाता है। आप प्राप्त विधि के लिए आवश्यक सूचकांक पास करते हैं और प्राप्त विधि उस सूचकांक पर तत्व मान लौटा देगी।
Q # 2) जावा में ऐरे विधि क्या है?
उत्तर: विधि की सरणी प्रतिनिधित्व सूची प्राप्त करने के लिए विधि () का उपयोग किया जाता है।
Q # 3) आप जावा में सूची कैसे छाँटते हैं?
उत्तर: जावा में, सूची के प्रकार विधि का उपयोग करके एक सूची को सॉर्ट किया जा सकता है। आप पैरामीटर के रूप में सॉर्ट विधि से पास किए गए तुलनित्र इंटरफ़ेस का उपयोग करके अपने स्वयं के सॉर्टिंग मानदंड पास कर सकते हैं।
आप संग्रह का उपयोग भी कर सकते हैं। सूची को क्रमबद्ध करने के लिए विधि को क्रमबद्ध करें। यह विधि प्राकृतिक क्रम के अनुसार सूची को क्रमबद्ध करती है।
क्यू # 4) जावा में Arrays.asList () क्या है?
उत्तर: सरणी का of asList 'सरणी द्वारा समर्थित तत्वों की सूची देता है।
निष्कर्ष
इस ट्यूटोरियल में, हमने उन सभी विधियों को सीखा है जो एक सूची प्रदान करती है। जावा सूची विभिन्न तरीकों को प्रदान करती है, जिनके उपयोग से आप खोज, छँटाई, आदि सहित सूचियों में हेरफेर और प्रक्रिया कर सकते हैं। हमने यहाँ उपयुक्त प्रोग्रामिंग उदाहरणों के साथ प्रत्येक विधि की व्याख्या की है।
हमारे आगामी ट्यूटोरियल में, हम विस्तार से सूची-सूची पर चर्चा करेंगे।
=> यहाँ सरल जावा प्रशिक्षण श्रृंखला का अन्वेषण करें।
अनुशंसित पाठ
- जावा सूची - जावा में सूची कैसे बनाएं, आरंभ करें और उपयोग करें
- जावा में गुप्त और अन्य संग्रह करने के लिए गुप्त सूची
- पायथन एडवांस्ड लिस्ट ट्यूटोरियल (सूची क्रमबद्ध, रिवर्स, इंडेक्स, कॉपी, जॉइन, सम)
- पायथन सूची - तत्वों को बनाएं, एक्सेस, स्लाइस, जोड़ें या हटाएं
- जावा थ्रेड्स विथ मेथड्स एंड लाइफ साइकल
- जावा में एक ऐरे से एक तत्व निकालें / हटाएं
- जावा स्ट्रिंग ट्यूटोरियल | उदाहरण के साथ जावा स्ट्रिंग के तरीके
- सामान्य वायरलेस रूटर ब्रांडों के लिए डिफ़ॉल्ट राउटर आईपी पता सूची