ArrayList तरीके जावा में

arraylist methods java tutorial with example programs

समस्याओं को खत्म करने के लिए हमारे साधन का प्रयास करें

ऑपरेटिंग सिस्टम का चयन करें प्रक्षेपण का एक कार्यक्रम चुनें (वैकल्पिक रूप से)

अपनी समस्या का वर्णन करें

इस ट्यूटोरियल में, हम जावा ArrayList Methods के बारे में चर्चा करेंगे, जैसे कि Add, addAll, remove, removeAll, size, होते हैं, रिटेनएअल, Sort, Reverse, आदि उदाहरणों के साथ:

पिछले ट्यूटोरियल में, हमने ArrayList डेटा संरचना और ArrayList वर्ग को जावा में इस डेटा संरचना / संग्रह के लिए प्रदान किया। हमने ArrayList वस्तुओं का निर्माण, आरंभीकरण आदि सीखा है।

इन विशेषताओं के अलावा जो हमें ArrayList को परिभाषित करने में मदद करते हैं, जावा में ArrayList वर्ग भी एक पूर्ण-फ़ंक्शन फ़ंक्शन API प्रदान करता है जिसमें ArrayList ऑब्जेक्ट्स में हेरफेर करने के लिए उपयोग किए जाने वाले तरीके शामिल हैं।

=> यहाँ सभी जावा ट्यूटोरियल की जाँच करें।

ये विधियाँ हमें ArrayList में तत्वों को जोड़ने, हटाने, खोजने और साथ ही ArrayList तत्वों की लंबाई / आकार को पुनः प्राप्त करने की अनुमति देती हैं, आदि।

Java ArrayList_Methods

इस ट्यूटोरियल में, हम सरल प्रोग्रामिंग उदाहरणों के साथ इन तरीकों पर विस्तार से चर्चा करेंगे।

आप क्या सीखेंगे:

ArrayList तरीके जावा में
निष्कर्ष
- अनुशंसित पाठ

निम्न तालिका उन सभी विधियों को सूचीबद्ध करती है जो ArrayList वर्ग द्वारा प्रदान की जाती हैं।

तरीका	विधि प्रोटोटाइप	विधि का वर्णन
शामिल	बूलियन होता है (ऑब्जेक्ट ओ)	जाँचता है कि सूची में दिए गए तत्व ‘o’ हैं या नहीं। तत्व मौजूद होने पर वापस लौटता है।
जोड़ना	बूलियन ऐड (E e)	सूची के अंत में दिए गए तत्व को जोड़ता है।
जोड़ना	शून्य जोड़ (int index, E element)	दिए गए तत्व 'तत्व' को 'निर्दिष्ट स्थान' सूचकांक पर जोड़ता है।
सभी जोड़ें	बूलियन addAll (संग्रह सी)	सूची के अंत में दिए गए संग्रह में सभी तत्वों को जोड़ता है।
सभी जोड़ें	बूलियन AddAll (int index, Collection c)	दिए गए संग्रह में सभी तत्वों को सूची में ’सूचकांक 'द्वारा निर्दिष्ट स्थिति में जोड़ता है।
स्पष्ट	शून्य स्पष्ट ()	सूची से सभी तत्वों को हटाकर सूची को साफ़ करता है।
क्लोन	ऑब्जेक्ट क्लोन ()	दिए गए ArrayList की उथली प्रति बनाता है।
सुनिश्चितता	शून्य सुनिश्चितता (अंतर न्यूनतम क्षमता)	ArrayList की क्षमता को बढ़ाता है यह सुनिश्चित करने के लिए कि उसमें न्यूनतमता हो।
प्राप्त	E get (int index)	सूची में मौजूद तत्व को 'सूचकांक' द्वारा निर्दिष्ट स्थिति में लौटाता है।
के सूचकांक	int indexOf (ऑब्जेक्ट ओ)	सूची में तत्व ओ की पहली घटना का सूचकांक लौटाता है। -1 यदि तत्व ओ सूची में मौजूद नहीं है।
खाली है	बूलियन इम्प्टी ()	यदि दी गई सूची खाली है तो जाँच करें।
इटरेटर	इटरेटर इटरेटर ()	उचित क्रम में सूची तत्वों पर पार करने के लिए एक पुनरावृत्ति देता है।
lastIndexOf	int lastIndexOf (ऑब्जेक्ट ओ)	सूची में निर्दिष्ट तत्व ओ की अंतिम घटना का सूचकांक लौटाता है। -1 यदि तत्व सूची में मौजूद नहीं है।
सूची बनानेवाला	सूची सूची सूची ()	दिए गए सूची के तत्वों पर पार करने के लिए रिटर्न इट्रेटर सूची।
सूची बनानेवाला	सूची सूची सूची (अंतर सूचकांक)	दी गई सूची के तत्वों पर पार करने के लिए निर्दिष्ट स्थान to सूचकांक ’से शुरू होने वाले सूची पुनरावर्तक को लौटाता है।
हटाना	ई निकालें (इंट इंडेक्स)	ArrayList में Ar सूचकांक ’में तत्व को हटाता है।
हटाना	बूलियन निकालें (ऑब्जेक्ट ओ)	सूची से तत्व ओ की पहली घटना को हटाता है।
सभी हटाएं	बूलियन रिमूवल (संग्रह c)	सूची से सभी तत्वों को निकालता है जो दिए गए संग्रह c में तत्वों से मेल खाता है।
निकालें	संरक्षित शून्य रिमरेंज (int fromIndex, int toIndex)	दी गई श्रेणी में निर्दिष्ट तत्वों को हटाता है, सूची से (समावेशी) से सूची (अनन्य) तक।
अनुरक्षण	बूलियन रिटेल (संग्रह सी)	उन तत्वों को सूची में रखता है जो दिए गए संग्रह में तत्वों से मेल खाते हैं c।
सेट	ई सेट (इंट इंडेक्स, ई एलिमेंट)	तत्व मान को 'तत्व' द्वारा दिए गए नए मूल्य पर 'सूचकांक' पर सेट करता है।
आकार	int आकार ()	तत्वों की कुल संख्या या सूची की लंबाई लौटाता है।
वश में करनेवाला	सूची सूची (int fromIndex, intIndex)	दी गई सूची के लिए दिए गए सीमा से, Indexex toIndex के बीच एक उप-सूची देता है।
.अरे	ऑब्जेक्ट () toArray ()	दी गई सूची को एक सरणी में परिवर्तित करता है।
.अरे	T () toArray (T () a)	दी गई सूची को ए द्वारा दिए गए प्रकार के एक सरणी में परिवर्तित करता है।
ट्रिमटोसेज़	शून्य ट्रिमटाइज़ ()	सूची में मौजूद तत्वों के आकार या संख्या के लिए ArrayList क्षमता को चलाता है।

अगला, हम ArrayList function API से इनमें से प्रत्येक विधि पर विस्तार से और वर्तमान प्रोग्रामिंग उदाहरणों पर चर्चा करेंगे। ऊपर सूचीबद्ध सभी तरीकों पर चर्चा करने के बाद, हम कुछ विशिष्ट ऑपरेशन भी करेंगे जो ArrayLists का उपयोग करके किए गए हैं जो ArrayList फ़ंक्शन API का हिस्सा नहीं हैं।

ArrayList add करें

मैं

प्रोटोटाइप: बूलियन ऐड (E e)
पैरामीटर: e => एरियर सूची में जोड़ा जाने वाला तत्व।
प्रतिलाभ की मात्रा: true => तत्व सफलतापूर्वक जोड़ा गया।
विवरण: दिए गए तत्व को सूची के अंत में जोड़ता है।

II।

प्रोटोटाइप: शून्य जोड़ (int index, E element)

पैरामीटर:

सूचकांक => वह स्थिति जिस पर तत्व को जोड़ा जाना है।
तत्व => तत्व को ArrayList में जोड़ा जाना है।

प्रतिलाभ की मात्रा: शून्य

विवरण: दिए गए तत्व ’तत्व’ को निर्दिष्ट स्थान पर ’सूचकांक’ में जोड़कर तत्व को उस स्थिति में और बाद के तत्वों को दाईं ओर स्थानांतरित कर देता है।

अपवाद: IndexOutOfBoundsException => यदि निर्दिष्ट इंडेक्स सीमा से बाहर है।

ArrayList addAll

मैं

प्रोटोटाइप: बूलियन addAll (संग्रह सी)
पैरामीटर: c => संग्रह जिसके तत्वों को ArrayList में जोड़ा जाना है।
प्रतिलाभ की मात्रा: true => यदि ऑपरेशन ने ArrayList को बदल दिया है।

विवरण: सूची के अंत में दिए गए संग्रह में सभी तत्वों को जोड़ता है। यदि ऑपरेशन प्रगति पर है, तो संग्रह के परिणाम को अपरिभाषित किया जाता है।

अपवाद: NullPointerException => यदि दिया गया संग्रह c null है।

द्वितीय

प्रोटोटाइप: बूलियन AddAll (int index, Collection c)
पैरामीटर: इंडेक्स => वह स्थिति जिस पर दिए गए संग्रह में तत्वों को जोड़ा जाना है।
प्रतिलाभ की मात्रा: true => यदि ऑपरेशन के परिणामस्वरूप सूची बदल गई है।

विवरण: दिए गए संग्रह में सभी तत्वों को सूची में ’सूचकांक 'द्वारा निर्दिष्ट स्थिति में जोड़ता है। निर्दिष्ट सूचकांक और बाद के तत्वों के तत्व को दाईं ओर स्थानांतरित किया जाता है। यदि ऑपरेशन प्रगति पर है, तो संग्रह के परिणाम को अपरिभाषित किया जाता है, जब संग्रह को जोड़ा जाता है।

अपवाद: IndexOutOfBoundsException: यदि इंडेक्स जहां संग्रह जोड़ा जाना है, सीमा से बाहर है
NullPointerException: यदि दिया गया संग्रह c null है।

निम्न जावा प्रोग्राम ऐड और ऐडऑल विधियों के उपयोग को प्रदर्शित करता है।

import java.util.*; class Main{ public static void main(String args()){ //create an ArrayList ArrayList city_List=new ArrayList(); //add elements to the ArrayList using add method city_List.add('Delhi'); city_List.add('Mumbai'); city_List.add('Chennai'); city_List.add('Kolkata'); //print the list System.out.println('Initial ArrayList:' + city_List); //add an element at index 1 using add method overload city_List.add(1, 'NYC'); //print the list System.out.println('
rrayList after adding element at index 1:' + city_List); //define a second list ArrayList more_Cities = new ArrayList(Arrays.asList('Pune', 'Hyderabad')); //use addAll method to add the list to ArrayList at index 4 city_List.addAll(4,more_Cities); //print the list System.out.println('
ArrayList after adding list at index 4:' + city_List); } }

आउटपुट:

प्रारंभिक एरियरिस्ट: (दिल्ली, मुंबई, चेन्नई, कोलकाता)
1 सूचकांक में तत्व जोड़ने के बाद rrayList: (दिल्ली, एनवाईसी, मुंबई, चेन्नई, कोलकाता)
सूचकांक 4 में सूची को जोड़ने के बाद ArrayList: (दिल्ली, एनवाईसी, मुंबई, चेन्नई, पुणे, हैदराबाद, कोलकाता)

कैसे जावा में एक कतार घोषित करने के लिए

जावा ArrayList का उत्पादन addAll

उपरोक्त प्रोग्राम सूची में तत्वों को जोड़ने के लिए ऐड विधि के दोनों संस्करणों का उपयोग करता है। यह निर्दिष्ट सूचकांक में सूची में एक संग्रह भी जोड़ता है। प्रोग्राम के आउटपुट से स्पष्ट रूप से ArrayList के दाईं ओर तत्वों की शिफ्टिंग पर ध्यान दें।

ArrayList फ्रंट में जोड़ें

जैसा कि पहले ही उल्लेख किया गया है, ऐड विधि का पहला संस्करण तत्वों को सूची के अंत में जोड़ता है। यदि आप ArrayList की शुरुआत में तत्वों को जोड़ना चाहते हैं, तो आपको ऐड विधि के दूसरे संस्करण का उपयोग करना होगा। यह ऐड मेथड इंडेक्स को एक पैरामीटर के रूप में लेता है। यह सूचकांक वह स्थिति है जिस पर तत्व को जोड़ा जाना है।

इस प्रकार सूची की शुरुआत में तत्व को जोड़ने के लिए, आपको सूचकांक को 0 के रूप में निर्दिष्ट करना होगा जो सूची की शुरुआत है।

निम्न प्रोग्राम ArrayList के सामने एक तत्व जोड़ता है।

import java.util.ArrayList; public class Main { public static void main(String() args) { //define new ArrayList and initialize it ArrayList numList = new ArrayList(); numList.add(5); numList.add(7); numList.add(9); //print the ArrayList System.out.println('Initial ArrayList:'); System.out.println(numList); //use add method with index=0 to add elements to the beginning of the list numList.add(0, 3); numList.add(0, 1); System.out.println('ArrayList after adding elements at the beginning:'); //print ArrayList System.out.println(numList); } }

आउटपुट:

प्रारंभिक ऐरेलास्ट:
(५, 9, ९)
शुरुआत में तत्वों को जोड़ने के बाद ArrayList:
(१, ३, ५, 5, ९)

आउटपुट - ArrayList सामने की तरफ जोड़ते हैं

ArrayList को हटा दें

मैं।

प्रोटोटाइप: ई निकालें (इंट इंडेक्स)
पैरामीटर: index => वह स्थिति जिस पर तत्व को ArrayList से हटाया जाना है।
प्रतिलाभ की मात्रा: ई => तत्व जो हटा दिया गया है
विवरण: ArrayList में Ar इंडेक्स ’पर तत्व हटाता है और बाद के तत्वों को बाईं ओर ले जाता है।
अपवाद: IndexOutOfBoundsException => निर्दिष्ट सूचकांक सीमा से बाहर है।

II।

प्रोटोटाइप: बूलियन निकालें (ऑब्जेक्ट ओ)
पैरामीटर: o => तत्व जो कि ArrayList से हटाया जाना है।
प्रतिलाभ की मात्रा: true => यदि तत्व सूची में मौजूद है।

विवरण: सूची से तत्व ओ की पहली घटना को हटाता है। यदि तत्व सूची में मौजूद नहीं है, तो इस ऑपरेशन का कोई प्रभाव नहीं है। एक बार तत्व हटाए जाने के बाद, बाद के तत्वों को बाईं ओर स्थानांतरित कर दिया जाता है।

ArrayList को हटा दें

प्रोटोटाइप: बूलियन रिमूवल (संग्रह c)
पैरामीटर: c => संग्रह जिनके तत्व ArrayList के साथ मेल खाते हैं और उन्हें हटाया जाना है।
प्रतिलाभ की मात्रा: true => यदि ArrayList ऑपरेशन द्वारा बदल दिया गया है।

विवरण: सूची से सभी तत्वों को निकालता है जो दिए गए संग्रह c में तत्वों से मेल खाता है। परिणामस्वरूप, शेष तत्वों को सूची के बाईं ओर स्थानांतरित कर दिया जाता है।

अपवाद: ClassCastException => वर्ग समान नहीं है जो निर्दिष्ट संग्रह का अर्थ है जो वर्ग असंगत है।
NullPointerException => यदि दिया गया संग्रह c null है; या यदि c में एक अशक्त तत्व है और इसे संग्रह द्वारा अनुमति नहीं है।

ArrayList removeRange

प्रोटोटाइप: संरक्षित शून्य रिमरेंज (int fromIndex, int toIndex)
पैरामीटर: fromIndex => हटाए जाने वाले रेंज के शुरुआती तत्व का सूचकांक।
inIndex => निकाले जाने वाले रेंज में अंतिम तत्व के बाद तत्व का सूचकांक।
प्रतिलाभ की मात्रा: शून्य
विवरण: दी गई श्रेणी में निर्दिष्ट तत्वों को हटाता है, सूची से (समावेशी) से सूची (अनन्य) तक। यह ऑपरेशन सूची की लंबाई को छोटा करता है (toIndex-fromIndex)। इस ऑपरेशन का Indexex = tondex के मामले में कोई प्रभाव नहीं है।
अपवाद: IndexOutOfBoundsException => यदि कोई भी सूचकांक (fromIndex या tondex) सीमा से बाहर है।

आइए हम इनमें से कुछ तरीकों को प्रदर्शित करने के लिए जावा प्रोग्राम को लागू करते हैं, जिनकी हमने ऊपर चर्चा की थी।

import java.util.*; class Main{ public static void main(String args()){ //create an ArrayList ArrayList city_List=new ArrayList(Arrays.asList('Delhi','Mumbai','Chennai', 'Kolkata', 'Pune', 'Hyderabad')); //print the list System.out.println('Initial ArrayList:' + city_List); //remove element at index 2 city_List.remove(2); //print the list System.out.println('
ArrayList after removing element at index 2:' + city_List); //remove the element 'Kolkata' city_List.remove('Kolkata'); //print the list System.out.println('
ArrayList after removing element -> Kolkata:' + city_List); //create new list ArrayList newCities=new ArrayList(Arrays.asList('Delhi','Hyderabad')); //call removeAll to remove elements contained in newCities list. city_List.removeAll(newCities); //print the list System.out.println('
ArrayList after call to removeAll:' + city_List); } }

आउटपुट:

प्रारंभिक एरियरिस्ट: (दिल्ली, मुंबई, चेन्नई, कोलकाता, पुणे, हैदराबाद
सूचकांक 2 में तत्व को हटाने के बाद ArrayList: (दिल्ली, मुंबई, कोलकाता, पुणे, हैदराबाद)
तत्व को हटाने के बाद ArrayList -> कोलकाता: (दिल्ली, मुंबई, पुणे, हैदराबाद)
हटाने के लिए कॉल करने के बाद ArrayList: (मुंबई, पुणे)

आउटपुट- ArrayList removeAll रेंज

सरणी आकार (लंबाई)

प्रोटोटाइप: int आकार ()
पैरामीटर: शून्य
प्रतिलाभ की मात्रा: int => ArrayList में तत्वों की संख्या।
विवरण: तत्वों की कुल संख्या या ArrayList की लंबाई लौटाता है।

सुनिश्चित करें

प्रोटोटाइप: शून्य सुनिश्चितता (अंतर न्यूनतम क्षमता)
पैरामीटर: न्यूनतम क्षमता => एरियरिस्ट के लिए वांछित न्यूनतम क्षमता।
प्रतिलाभ की मात्रा: शून्य
विवरण: ArrayList की क्षमता को बढ़ाता है यह सुनिश्चित करने के लिए कि उसमें न्यूनतम क्षमता है।

ट्रिमटोसेज़

प्रोटोटाइप: शून्य ट्रिमटाइज़ ()
पैरामीटर: शून्य
प्रतिलाभ की मात्रा: शून्य
विवरण: सूची में मौजूद तत्वों के आकार या संख्या के लिए ArrayList क्षमता को चलाता है।

नीचे प्रोग्रामिंग उदाहरण विधियों का आकार (), सुनिश्चितता () और trimToSize () प्रदर्शित करता है।

import java.util.ArrayList; public class Main { public static void main(String () args) { //Create and initialize Arraylist ArrayList evenList=new ArrayList(5); System.out.println('Initial size: '+evenList.size()); evenList.add(2); evenList.add(4); evenList.add(6); evenList.add(8); evenList.add(10); //print the list and size System.out.println('Original List: ' + evenList); System.out.println('ArrayList Size after add operation: '+evenList.size()); //call ensureCapacity () with minimum capacity =10 evenList.ensureCapacity(10); //add two more elements evenList.add(12); evenList.add(14); //print the size again System.out.println('ArrayList Size after ensureCapacity() call and add operation: '+evenList.size()); //call trimToSize() evenList.trimToSize(); //print the size and the ArrayList System.out.println('ArrayList Size after trimToSize() operation: '+evenList.size()); System.out.println('ArrayList final: '); for(int num: evenList){ System.out.print(num + ' '); } } }

आउटपुट:

प्रारंभिक आकार: 0
मूल सूची: (२, ४, ६,,, १०)
जोड़ आपरेशन के बाद ArrayList का आकार: 5
सुनिश्चित करने के बाद ArrayList का आकार () कॉल और ऑपरेशन जोड़ें: 7
ट्राइऑटसाइज़ () ऑपरेशन के बाद ArrayList का आकार: 7
ArrayList फाइनल:
२ ४ ६ 8 १० १२ १४

आउटपुट- सरणी आकार (लंबाई)

ArrayList में होता है

प्रोटोटाइप: बूलियन होता है (ऑब्जेक्ट ओ)
पैरामीटर: ओ => एलीमिस्ट में मौजूद होने पर तत्व की जाँच की जानी है।
प्रतिलाभ की मात्रा: true => यदि ArrayList में तत्व o है।
विवरण: जाँचता है कि सूची में दिए गए तत्व ‘o’ हैं या नहीं। तत्व मौजूद होने पर वापस लौटता है।

हम निम्नलिखित कार्यक्रम में ’सम्‍मिलित’ विधि का उपयोग करते हैं।

import java.util.ArrayList; public class Main { public static void main(String() args) { //create and initialize colorsList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('White'); //call contains method to check if different strings are present in ArrayList System.out.println('ArrayList contains ('Red Green'): ' +colorsList.contains('Red Green')); System.out.println('ArrayList contains ('Blue'): ' +colorsList.contains('Blue')); System.out.println('ArrayList contains ('Yellow'): ' +colorsList.contains('Yellow')); System.out.println('ArrayList contains ('White'): ' +colorsList.contains('White')); } }

आउटपुट:

ArrayList में (’रेड ग्रीन’) शामिल है: गलत
ArrayList में (ist Blue ’) शामिल है: सच
ArrayList में (ist Yellow ’) शामिल है: गलत
ArrayList में (ist श्वेत) शामिल हैं: सच

आउटपुट - ArrayList में होता है

जैसा कि ऊपर दिए गए आउटपुट में दिखाया गया है, अगर ArrayList में मौजूद तर्क मौजूद है और सही या गलत है, तो in मेथड ’की जाँच होती है।

ArrayList मिलता है

प्रोटोटाइप: E get (int index)
पैरामीटर: इंडेक्स => एरेलेस्ट से किस तत्व को इंडेक्स किया जाना है।
प्रतिलाभ की मात्रा: ई => एरेलेस्ट में दिए गए सूचकांक में तत्व मूल्य।
विवरण: सूची में मौजूद तत्व को 'सूचकांक' द्वारा निर्दिष्ट स्थिति में लौटाता है।
अपवाद: IndexOutOfBoundsException => यदि इंडेक्स सीमा से बाहर है।

ArrayList सेट (तत्व बदलें)

प्रोटोटाइप: ई सेट (इंट इंडेक्स, ई एलिमेंट)
पैरामीटर: सूचकांक => वह सूचकांक जिस पर तत्व को प्रतिस्थापित किया जाना है।
तत्व => निर्दिष्ट सूचकांक पर सेट किया जाने वाला नया तत्व।
प्रतिलाभ की मात्रा: E => तत्व जो सेट ऑपरेशन द्वारा प्रतिस्थापित किया जाता है।
विवरण: दिए गए the सूचकांक में तत्व मूल्य को 'तत्व' द्वारा दिए गए नए मूल्य पर सेट करता है।
अपवाद: IndexOutOfBoundsException => यदि इंडेक्स सीमा से बाहर है

ArrayList में मूल्यों को पुनः प्राप्त करने और बदलने के लिए जावा प्रोग्राम नीचे दिए गए () और सेट () विधि का उपयोग करता है।

import java.util.ArrayList; public class Main { public static void main(String() args) { //create and initialize colorsList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('White'); //call get () method to retrieve value at index 2 System.out.println('Entry at index 2 before call to set: ' + colorsList.get(2)); //replace the value at index 2 with new value colorsList.set(2,'Yellow'); //print the value at index 2 again System.out.println('Entry at index 2 after call to set: ' + colorsList.get(2)); } }

आउटपुट:

सेट करने के लिए कॉल करने से पहले इंडेक्स 2 में प्रवेश करें: नीला
सेट करने के लिए कॉल के बाद इंडेक्स 2 में प्रवेश: पीला

उत्पादन

स्पष्टवादी

प्रोटोटाइप: शून्य स्पष्ट ()
पैरामीटर: शून्य
प्रतिलाभ की मात्रा: शून्य
विवरण: सूची से सभी तत्वों को हटाकर सूची को साफ़ करता है।

ArrayList खाली है

प्रोटोटाइप: बूलियन इम्प्टी ()
पैरामीटर: शून्य
प्रतिलाभ की मात्रा: true => यदि सूची खाली है
विवरण: यदि दी गई सूची खाली है तो जाँच करें।

स्पष्ट () और isEmpty () फ़ंक्शन नीचे प्रदर्शित किए गए हैं।

import java.util.ArrayList; public class Main { public static void main(String() args) { //create and initialize colorsList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('White'); //print the ArrayList System.out.println('The ArrayList: ' + colorsList); //call clear() nethod on ArrayList colorsList.clear(); //check if ArrayList is empty using isEmpty() method System.out.println('Is ArrayList empty after clear ()? :' + colorsList.isEmpty()); } }

आउटपुट:

द अरैलिस्ट: (रेड, ग्रीन, ब्लू, व्हाइट)
स्पष्ट () के बाद ArrayList खाली है? :सच

आउटपुट - खाली ArrayList

ArrayList indexOf

प्रोटोटाइप: int indexOf (ऑब्जेक्ट ओ)
पैरामीटर: o => तत्व जिसका सूचकांक ArrayList में पाया जाना है।
प्रतिलाभ की मात्रा: int => सूची में तत्व की पहली घटना का सूचकांक।
विवरण: सूची में तत्व ओ की पहली घटना का सूचकांक लौटाता है। -1 यदि तत्व ओ सूची में मौजूद नहीं है।

ArrayList lastIndexOf

प्रोटोटाइप: int lastIndexOf (ऑब्जेक्ट ओ)
पैरामीटर: o => खोजे जाने वाला तत्व।
प्रतिलाभ की मात्रा: int => सूची में तत्व की अंतिम घटना का सूचकांक।
विवरण: सूची में निर्दिष्ट तत्व ओ की अंतिम घटना का सूचकांक लौटाता है। -1 यदि तत्व सूची में मौजूद नहीं है।

नीचे जावा प्रोग्राम ArrayList के indexOf और lastIndexOf तरीकों को प्रदर्शित करता है।

import java.util.ArrayList; public class Main { public static void main(String() args) { //create and initialize intList ArrayList intList = new ArrayList(); intList.add(1); intList.add(1); intList.add(2); intList.add(3); intList.add(5); intList.add(3); intList.add(2); intList.add(1); intList.add(1); //print the ArrayList System.out.println('The ArrayList: ' + intList); //call indexOf() and lastIndexOf() methods to check the indices of specified elements System.out.println('indexOf(1) : ' + intList.indexOf(1)); System.out.println('lastIndexOf(1) : ' + intList.lastIndexOf(1)); System.out.println('indexOf(2) : ' + intList.indexOf(2)); System.out.println('lastIndexOf(2) : ' + intList.lastIndexOf(2)); System.out.println('indexOf(3) : ' + intList.indexOf(3)); System.out.println('lastIndexOf(3) : ' + intList.lastIndexOf(3)); System.out.println('indexOf(5) : ' + intList.indexOf(5)); System.out.println('lastIndexOf(5) : ' + intList.lastIndexOf(5)); } }

आउटपुट:

द अरैलिस्ट: (१, १, २, ३, ५, ३, २, १, १)
indexOf (1): 0
lastIndexOf (1): 8
indexOf (2): 2
lastIndexOf (2): 6
indexOf (3): 3
lastIndexOf (3): 5
indexOf (5): 4
lastIndexOf (5): 4

उत्पादन

ArrayListAArray

प्रोटोटाइप: ऑब्जेक्ट () toArray ()
पैरामीटर: शून्य
प्रतिलाभ की मात्रा: वस्तु () => एक सरणी। इस लौटे सरणी में सूची के सभी तत्व उचित क्रम में हैं।
विवरण: दी गई सूची को एक सरणी में परिवर्तित करता है।

प्रोटोटाइप: T () toArray (T () a)

पैरामीटर: a => सूची के तत्वों को संग्रहीत करने के लिए सरणी। यदि सरणी का आकार सूची तत्वों के लिए पर्याप्त नहीं है, तो स्टोरिंग तत्वों के लिए बनाया गया एक ही प्रकार के साथ एक और सरणी।

प्रतिलाभ की मात्रा: T () => एरे जिसमें सभी सूची तत्व शामिल हैं।
विवरण: दी गई सूची को ए द्वारा दिए गए प्रकार के एक सरणी में परिवर्तित करता है।

अपवाद: ArrayStoreException => यदि रनटाइम प्रकार के एरेमे और रनटाइम प्रकार या इसके तत्वों के सुपरटेप में कोई बेमेल है।
NullPointerException => दिया गया सरणी अशक्त है

नीचे दिया गया Java प्रोग्राम ArrayList की .Array विधि को प्रदर्शित करता है।

import java.util.*; public class Main { public static void main(String() args) { // define and initialize ArrayList ArrayList intList = new ArrayList(); intList.add(10); intList.add(20); intList.add(30); intList.add(40); intList.add(50); // print ArrayList System.out.println('ArrayList: ' + intList); //declare array Integer myArray() = new Integer(intList.size()); //use toArray method to convert ArrayList to Array myArray = intList.toArray(myArray); //print the Array System.out.println('Array from ArrayList:' + Arrays.toString(myArray)); } }

आउटपुट:

ArrayList: (10, 20, 30, 40, 50)
ArrayList से सरणी: (१०, २०, ३०, ४०, ५०)

आउटपुट - ऐरे ऐरेस्टलिस्ट

ArrayList क्लोन

प्रोटोटाइप: ऑब्जेक्ट क्लोन ()
पैरामीटर: शून्य
प्रतिलाभ की मात्रा: ऑब्जेक्ट => एरियर लिस्ट का क्लोन।
विवरण: दिए गए ArrayList की उथली प्रति बनाता है।

import java.util.ArrayList; public class Main { public static void main(String a()){ ArrayList fruitsList = new ArrayList(); //Adding elements to the ArrayList fruitsList.add('Apple'); fruitsList.add('Orange'); fruitsList.add('Melon'); fruitsList.add('Grapes'); System.out.println('Original ArrayList: '+fruitsList); ArrayList clone_list = (ArrayList)fruitsList.clone(); System.out.println('Cloned ArrayList: '+ clone_list); //add one elmeent & remove one element from original arraylist fruitsList.add('Mango'); fruitsList.remove('Orange'); //print original and cloned ArrayList again System.out.println('
Original ArrayList after add & remove:'+fruitsList); System.out.println('Cloned ArrayList after original changed:'+clone_list); } }

आउटपुट:

मूल ArrayList: (Apple, Orange, Melon, Grapes)
क्लोन किए गए कलाकार: (Apple, Orange, Melon, Grapes)
जोड़ने और हटाने के बाद मूल ArrayList: (Apple, तरबूज, अंगूर, आम)
मूल परिवर्तन के बाद क्लोन किए गए कलाकार: (सेब, नारंगी, खरबूजा, अंगूर)

आउटपुट - सरणी सूची क्लोन

उपरोक्त कार्यक्रम आउटपुट से, आप देख सकते हैं कि क्लोन ArrayList मूल ArrayList की उथली प्रति है। इसका मतलब यह है कि जब मूल एरेलेस्ट को बदल दिया जाता है, तो ये बदलाव क्लोन एरेलेलिस्ट में प्रतिबिंबित नहीं होते हैं क्योंकि वे प्रत्येक तत्व के मेमोरी स्थानों को साझा नहीं करते हैं।

यूट्यूब एमपी 3 ऑनलाइन कनवर्टर की समीक्षा करने के लिए

Array की एक गहरी प्रतिलिपि बनाने के लिए, मूल ArrayList को ट्रैवर्स किया जाना चाहिए और इसके प्रत्येक तत्व को ArrayList को गंतव्य पर कॉपी करने की आवश्यकता है।

ArrayList उपसूची

प्रोटोटाइप: सूची सूची (int fromIndex, intIndex)
पैरामीटर: fromIndex => श्रेणी का समावेशी सूचकांक (समावेशी)
ofIndex => सीमा का अंत सूचकांक (अनन्य)
प्रतिलाभ की मात्रा: सूची => दी गई सीमा में सूची को प्रस्तुत करना।

विवरण: दी गई सूची के लिए इंडेक्स, इंडेक्स से इंडेक्स के बीच एक उप-सूची देता है। ध्यान दें कि यह सबलिस्ट या दी गई सीमा में सूची का दृश्य सूची द्वारा समर्थित सभी कार्यों का समर्थन करता है। यदि कोई दृश्य वापस नहीं किया गया है

अपवाद: IndexOutOfBoundsException => जब InIndex सीमा से बाहर हो, तो उसे फेंक दें।
IllegalArgumentException => यदि fromIndex> toIndex यानी इंडेक्स ऑर्डर से बाहर हैं।

आइए हम सबलिस्ट विधि का एक उदाहरण देखें।

import java.util.ArrayList; import java.util.List; class Main{ public static void main(String a()){ //create and initialize the ArrayList ArrayList intList = new ArrayList(); intList.add(5); intList.add(10); intList.add(15); intList.add(20); intList.add(25); intList.add(30); intList.add(35); intList.add(40); intList.add(45); intList.add(50); //print the ArrayList System.out.println('Original ArrayList: '+intList); //create a sublist for the given ArrayList ArrayList sub_ArrayList = new ArrayList(intList.subList(2, 6)); //print the sublist System.out.println('Sublist of given ArrayList: '+sub_ArrayList); } }

आउटपुट:

मूल सरणी: (5, 10, 15, 20, 25, 30, 35, 40, 45, 50)
दिए गए ArrayList की सूची: (१५, २०, २५, ३०)

उत्पादन

ArrayList को बरकरार रखें

प्रोटोटाइप: बूलियन रिटेल (संग्रह सी)
पैरामीटर: c => सूची में बनाए रखने वाले तत्वों के साथ संग्रह।
प्रतिलाभ की मात्रा: true => यदि ऑपरेशन के परिणामस्वरूप ArrayList बदल गया।
विवरण: उन तत्वों को सूची में रखता है जो दिए गए संग्रह में तत्वों से मेल खाते हैं c।

अपवाद: ClassCastException => संग्रह प्रकार और सूची प्रकार मेल नहीं खाते
NullPointerException => दिया गया संग्रह शून्य है या सूची में शून्य तत्व है और संग्रह नल की अनुमति नहीं देता है।

निम्न प्रोग्राम रिटेन एएलएल पद्धति को प्रदर्शित करता है।

import java.util.*; class Main{ public static void main(String args()){ //create and initialize ArrayList ArrayList colorsList=new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Yellow'); //print the ArrayList System.out.println('Original ArrayList:' + colorsList); //define another collection ArrayList color_collection=new ArrayList(); color_collection.add('Red'); color_collection.add('Blue'); System.out.println('Collection elements to be retained in the list:' + color_collection); //call retainAll method with above collection as an argument colorsList.retainAll(color_collection); //print the ArrayList after retainAll call. System.out.println('ArrayList after retainAll call:' + colorsList); } }

आउटपुट:

मूल सरणी: (लाल, हरा, नीला, पीला)
सूची में बनाए रखने के लिए संग्रह तत्व: (लाल, नीला)
रिट्रेवल कॉल के बाद ArrayList: (रेड, ब्लू)

आउटपुट - रिटेल ऑल विधि

ArrayList Iterator

प्रोटोटाइप: इटरेटर इटरेटर ()
पैरामीटर: शून्य
प्रतिलाभ की मात्रा: Iterator => सूची तत्वों पर पुनरावृत्ति करनेवाला।
विवरण: उचित क्रम में सूची तत्वों पर पार करने के लिए एक पुनरावृत्ति देता है।

ArrayList listIterator

मैं।

प्रोटोटाइप: सूची सूची सूची ()
पैरामीटर: शून्य
प्रतिलाभ की मात्रा: ListIterator => listIterator सूची तत्वों पर।
विवरण: दिए गए सूची के तत्वों पर पार करने के लिए रिटर्न इट्रेटर सूची।

II।

प्रोटोटाइप: सूची सूची सूची (अंतर सूचकांक)
पैरामीटर: index => listIterator में पहले तत्व की स्थिति।
प्रतिलाभ की मात्रा: सूची सूचकांक => निर्दिष्ट सूचकांक से सूची के लिए सूची-सूची।
विवरण: दी गई सूची के तत्वों पर पार करने के लिए निर्दिष्ट स्थान to सूचकांक ’से शुरू होने वाले सूची पुनरावर्तक को लौटाता है।
अपवाद: IndexOutOfBoundsException => दिया गया सूचकांक सीमा से बाहर है।

इटरेटर () और सूची-सूचक () विधियों का उदाहरण।

import java.util.*; class Main{ public static void main(String args()){ //create ArrayList and initialize it ArrayList cities=new ArrayList(); cities.add('Mumbai'); cities.add('Pune'); cities.add('Hyderabad'); cities.add('Delhi'); //use iterator() method to traverse through the list System.out.println('List contents using Iterator () method:'); Iterator iter=cities.iterator(); while(iter.hasNext()){ System.out.print(iter.next() + ' '); } //use listIterator() method to traverse through the list System.out.println('

List contents using listIterator () method:'); ListIterator list_iter=cities.listIterator(); while(list_iter.hasNext()) { System.out.print(list_iter.next() + ' '); } } }

आउटपुट:

Iterator () विधि का उपयोग करते हुए सूची सामग्री:
मुंबई पुणे हैदराबाद दिल्ली
सूची सामग्री () विधि का उपयोग करके सूची सामग्री:
मुंबई पुणे हैदराबाद दिल्ली

आउटपुट - Iterator और listIterator Methods

जावा में ArrayList में Array जोड़ें

ArrayList ArrayList में संग्रह के तत्वों को जोड़ने के लिए addAll विधि का समर्थन करता है। इसी तरह से, आप ArrayList में एक ऐरे को भी जोड़ सकते हैं। यह 'Collections.addAll' पद्धति का उपयोग करके किया जाता है।

ArrayList में एक ऐरे को जोड़ने का उदाहरण।

import java.util.*; class Main{ public static void main(String args()){ //create an ArrayList ArrayList city_List=new ArrayList(); //add elements to the ArrayList using add method city_List.add('Delhi'); city_List.add('Mumbai'); city_List.add('Chennai'); city_List.add('Kolkata'); //print ArrayList System.out.println('
Initial ArrayList :' + city_List); //define an array. String() myArray = new String(){'Cochin', 'Goa'}; //add the array to the ArrayList Collections.addAll(city_List,myArray); //print the ArrayList System.out.println('
ArrayList after adding array :' + city_List); } }

आउटपुट:

प्रारंभिक एरियरिस्ट: (दिल्ली, मुंबई, चेन्नई, कोलकाता)
सरणी जोड़ने के बाद ArrayList: (दिल्ली, मुंबई, चेन्नई, कोलकाता, कोचीन, गोवा)

आउटपुट - जावा में Array को Array जोड़ें

Java में ArrayList को क्रमबद्ध करें

ArrayList अपने तत्वों को सॉर्ट करने के लिए Collections.sort विधि का उपयोग करता है। डिफ़ॉल्ट रूप से, सूची को Collections.sort विधि द्वारा आरोही क्रम में क्रमबद्ध किया जाता है। यदि ArrayList को अवरोही क्रम में सॉर्ट करना है, तो आपको सॉर्ट विधि के लिए ions Collections.reverseOrder () पैरामीटर प्रदान करना होगा।

नीचे दिए गए क्रम में आरोही को क्रमबद्ध करने के लिए एक कार्यक्रम दिया गया है:

import java.util.*; public class Main { public static void main(String args()){ //Create and initialize an ArrayList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Yellow'); //print initial ArrayList System.out.println('Initial ArrayList:' + colorsList); //sort ArrayList in ascending order Collections.sort(colorsList); //print sorted ArrayList System.out.println('
ArrayList sorted in ascending order:'); System.out.println(colorsList); //sort ArrayList in reverse(desending) order Collections.sort(colorsList, Collections.reverseOrder()); //print sorted list System.out.println('
ArrayList sorted in descending order:'); System.out.println(colorsList); } }

आउटपुट:

प्रारंभिक ऐरेलास्ट: (लाल, हरा, नीला, पीला)
ArrayList आरोही क्रम में क्रमबद्ध:
(नीला, हरा, लाल, पीला)
अवरोही क्रम में क्रमबद्ध:
(पीला, लाल, हरा, नीला)

आउटपुट - जावा में सॉर्ट एशलिस्ट

यदि ArrayList में अन्य श्रेणी की वस्तुएं तत्व के रूप में हैं, तो आप तुलनात्मक और तुलनित्र इंटरफेस का उपयोग कर सकते हैं। इंटरफेस के बारे में अधिक विवरण हमारे बाद के ट्यूटोरियल में शामिल किए जाएंगे।

जावा में एक ArrayList उल्टा

आप जावा में एक ArrayList को भी उल्टा कर सकते हैं। ऐसा करने का एक तरीका यह है कि ArrayList को उल्टे क्रम में ट्रेस करने के पारंपरिक तरीके का उपयोग करें और प्रत्येक तत्व को एक नए ArrayList में कॉपी करें।

एक अन्य विधि संग्रह वर्ग का उपयोग कर रही है जो संग्रह को उलटने के लिए उपयोग की जाने वाली 'रिवर्स' विधि प्रदान करता है।

संग्रह वर्ग का उपयोग करके एक ArrayList को उल्टा करने का कार्यक्रम नीचे दिया गया है।

import java.io.*; import java.util.*; public class Main { public static void main(String() args) { // create and initialize an ArrayList ArrayList oddList = new ArrayList(); oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); System.out.print('Initial ArrayList: ' + oddList); // use Collections.reverse method to reverse the ArrayList Collections.reverse(oddList); //print the ArrayList System.out.print('
Reversed ArrayList: ' + oddList); } }

आउटपुट:

आरंभिक अरैलिस्ट: (1, 3, 5, 7, 9)
उलट दिया गया सरणी: (९,,, ५, ३, १)

आउटपुट - रिवर्स और एरियरिस्ट

जावा में एक ArrayList से डुप्लिकेट निकालें

ArrayList से डुप्लिकेट को निकालने के लिए, आप एक बार फिर ArrayList के माध्यम से यात्रा करने के लिए पुनरावृत्ति का उपयोग करने की पारंपरिक विधि का सहारा ले सकते हैं और तत्व की पहली घटना को एक अलग ArrayList में संग्रहीत कर सकते हैं।

फिर भी एक और तरीका है स्ट्रीम के ‘अलग () विधि का उपयोग करके () वर्ग। यह विधि विभिन्न तत्वों की एक धारा लौटाती है। जावा में 8 से आगे स्ट्रीम () सुविधा उपलब्ध है।

धारा का कार्यान्वयन ()। मूल () विधि नीचे दी गई है:

import java.util.*; import java.util.stream.Collectors; public class Main { public static void main(String() args) { // Create an ArrayList of numbers ArrayList numList = new ArrayList (Arrays.asList(1, 2, 3, 1, 3, 5, 5, 6, 6, 7, 7, 8, 8)); //print the original ArrayList System.out.println('Original ArrayList:' + numList); //Use Java 8 stream().distinct() method to remove duplicates from the list List distinctList = numList.stream().distinct().collect(Collectors.toList()); //print the new list System.out.println('ArrayList without duplicates:' + distinctList); } }

आउटपुट:

मूल सरणी: (1, 2, 3, 1, 3, 5, 5, 6, 6, 7, 7, 8, 8)
डुप्लिकेट के बिना ArrayList: (1, 2, 3, 5, 6, 7, 8)

आउटपुट - ArrayList से डुप्लिकेट निकालें

शफ़ल (रैंडमाइज़) जावा में एक एरेलेलिस्ट

आप le फेरबदल ’भी कर सकते हैं या ArrayList तत्वों को यादृच्छिक कर सकते हैं। यह Collections.shuffle () पद्धति का उपयोग करके किया जाता है। इस पद्धति का उपयोग करते हुए, या तो आप डिफ़ॉल्ट सेटिंग्स के साथ एरेलेलिस्ट को फेरबदल कर सकते हैं या एक यादृच्छिक () फ़ंक्शन प्रदान कर सकते हैं जो प्रदान किए गए यादृच्छिक मूल्य के अनुसार तत्वों को यादृच्छिक करेंगे।

इसे प्राप्त करने के लिए एक जावा प्रोग्राम नीचे दिया गया है।

import java.util.*; public class Main { public static void main(String() args) { //create and initialize a String ArrayList ArrayList strlist = new ArrayList(); strlist.add('east'); strlist.add('west'); strlist.add('north'); strlist.add('south'); strlist.add('southwest'); strlist.add('northeast'); //print the original list System.out.println('Original ArrayList : 
' + strlist); //shuffle the ArrayList without random function Collections.shuffle(strlist); System.out.println('
Shuffled ArrayList without Random() : 
' + strlist); // shuffle the ArrayList with random() function Collections.shuffle(strlist, new Random()); System.out.println('
Shuffled ArrayList with Random() : 
' + strlist); // use random (2) to shuffle the ArrayList Collections.shuffle(strlist, new Random(2)); System.out.println('
Shuffled ArrayList with Random(2) : 
' + strlist); } }

आउटपुट:

मूल ArrayList: (पूर्व, पश्चिम, उत्तर, दक्षिण, दक्षिण-पश्चिम, उत्तर-पूर्व) बिना फेरबदल के ArrayList (): (उत्तर, उत्तर-पूर्व, पूर्व, दक्षिण-पश्चिम, दक्षिण, पश्चिम)
यादृच्छिक के साथ फेरबदल ArrayList (): (दक्षिण, पूर्व, उत्तर, उत्तर पूर्व, पश्चिम, दक्षिण पश्चिम)
यादृच्छिक (2) के साथ ArrayList फेरबदल: (दक्षिण पश्चिम, दक्षिण, पूर्व, उत्तर पूर्व, उत्तर, पश्चिम)

आउटपुट - फेरबदल (एक यादृच्छिक)

बार बार पूछे जाने वाले प्रश्न

Q # 1) जावा में सजातीय और विषम कंटेनर में क्या अंतर है?

उत्तर: सजातीय कंटेनरों में एक ही प्रकार के ऑब्जेक्ट / तत्व होते हैं। दूसरी ओर, विषम कंटेनरों में मिश्रित प्रकार की वस्तुएं होती हैं।

क्यू # 2) क्या जावा Heterogeneous में ArrayList है?

उत्तर: हाँ। चूंकि ArrayLists जेनेरिक का समर्थन करते हैं और इसलिए इरेज़र टाइप करते हैं, इसलिए सामान्य ArrayList के रूप में कार्यान्वित होने पर इसमें मिश्रित वस्तुएँ हो सकती हैं।

क्यू # 3) क्या ArrayList int को स्टोर कर सकता है?

उत्तर: नहीं। ArrayLists int की तरह मानों को संग्रहीत नहीं कर सकता है लेकिन यह Integer वस्तुओं को संग्रहीत कर सकता है क्योंकि ArrayLists में केवल ऑब्जेक्ट हो सकते हैं। इस प्रकार आदिम प्रकारों को संग्रहीत करने के लिए आपको इन्टर्स के लिए इंटेगर जैसे रैपर वर्गों का उपयोग करना चाहिए।

क्यू # 4) क्या होता है जब ArrayList भरा हुआ है?

उत्तर: हर ArrayList ऑब्जेक्ट में एक सुविधा है जिसका नाम 'क्षमता' है। जब ArrayList भरा होता है, तो अधिक तत्वों के लिए जगह बनाने के लिए ArrayList की क्षमता अपने आप बढ़ जाती है।

क्यू # 5) ArrayList में RemoveAll और maintainAll विधि के बीच क्या अंतर है?

उत्तर: ArrayList विधियाँ A निष्कासन ’और ll अनुरक्षण’ को विपरीत व्यवहार प्रदर्शित करती हैं।

जबकि निष्कासन विधि सूची से उन सभी तत्वों को हटा देती है जो संग्रह के साथ मेल खाते हैं, इस पद्धति के तर्क के रूप में, रिटेल। दूसरी ओर, सूची के सभी तत्वों को संग्रह के साथ मेल खाने वाले सूची में बनाए रखता है।

निष्कर्ष

इस ट्यूटोरियल में, हमने ArrayList विधियों पर विस्तार से चर्चा की है।

हमने सूची के सामने तत्वों को जोड़ने जैसे कुछ विशेष मामलों पर भी विचार किया है। हमने ArrayList पर अन्य कार्यों की भी चर्चा की, जैसे ArrayList की छँटाई, उलट-फेर करना और फेरबदल करना।

हमारे आगामी ट्यूटोरियल में, हम कुछ ArrayList रूपांतरणों पर चर्चा करेंगे।

=> यहाँ सरल जावा प्रशिक्षण श्रृंखला देखें।

ArrayList तरीके जावा में - उदाहरण कार्यक्रमों के साथ ट्यूटोरियल