जावा - ॲरेलिस्टचे सिंगल लाइन इनिशियलायझेशन

Java मध्ये कार्यक्षमतेने Arraylists तयार करणे

Java प्रकल्पांवर काम करताना, याद्या तयार करणे आणि प्रारंभ करणे कार्यक्षमतेने वेळ वाचवू शकते आणि कोड क्लीनर बनवू शकते. चाचणी उद्देशांसाठी, तुम्हाला अनेकदा पर्यायांची सूची पटकन सेट करावी लागेल. या लेखात, आम्ही एका ओळीत ArrayList कसे सुरू करायचे ते एक्सप्लोर करू.

सुरुवातीला, अनेक विकासक ॲरेलिस्टमध्ये घटक जोडण्यासाठी बहु-चरण प्रक्रिया वापरू शकतात. आम्ही एका रीफॅक्टर पध्दतीवर चर्चा करू जे याला एका ओळीत संकुचित करते आणि हे साध्य करण्याचा आणखी चांगला मार्ग आहे का ते शोधू.

आज्ञा	वर्णन
Arrays.asList	ॲरेला निश्चित आकाराच्या सूचीमध्ये रूपांतरित करते. एका ओळीत याद्या सुरू करण्यासाठी उपयुक्त.
List.of	निर्दिष्ट घटक असलेली अपरिवर्तनीय सूची तयार करते. Java 9 पासून उपलब्ध.
newArrayList	व्हेरिएबल आर्ग्युमेंटसह ॲरेलिस्ट सुरू करण्यासाठी एक सानुकूल उपयुक्तता पद्धत. सूची तयार करणे सोपे करते.
System.out.println	निर्दिष्ट संदेश मानक आउटपुटवर मुद्रित करते. सूची सामग्री सत्यापित करण्यासाठी वापरले जाते.
for-each loop	ॲरे किंवा संग्रहातील प्रत्येक घटकावर पुनरावृत्ती होते. सूचीमध्ये घटक जोडण्यासाठी उपयुक्तता पद्धतीमध्ये वापरले जाते.
varargs	वितर्कांची व्हेरिएबल संख्या स्वीकारण्यासाठी पद्धतीला अनुमती देते. लवचिक उपयुक्तता पद्धती तयार करण्यासाठी उपयुक्त.

ॲरेलिस्ट सुरू करण्यासाठी कार्यक्षम तंत्रे

पहिल्या स्क्रिप्टच्या उदाहरणामध्ये, आम्ही आरंभ करण्याच्या तीन पद्धती शोधल्या जावा मध्ये. सुरुवातीला, द एक मल्टी-स्टेप पध्दत वापरून तयार केले जाते जेथे आम्ही सूची घोषित करतो आणि नंतर प्रत्येक घटक स्वतंत्रपणे जोडतो. ही पद्धत सरळ असली तरी शब्दशः आहे. त्यानंतर आम्ही हे वापरून एका ओळीत रिफॅक्टर केले , जे स्ट्रिंग्सच्या ॲरेला निश्चित आकाराच्या सूचीमध्ये रूपांतरित करते आणि नंतर त्यास पास करते ArrayList बांधकाम करणारा हा दृष्टिकोन अधिक संक्षिप्त आणि वाचण्यास सोपा आहे. शेवटी, आम्ही ओळख करून दिली पद्धत, Java 9 पासून उपलब्ध आहे, जी एका ओळीत अपरिवर्तनीय सूची तयार करते. मध्ये वापरण्यासाठी , आम्ही ते पास करतो कन्स्ट्रक्टर, च्या साधेपणाचे संयोजन List.of च्या लवचिकतेसह .

दुसऱ्या स्क्रिप्टच्या उदाहरणामध्ये, आम्ही कस्टम युटिलिटी पद्धत तयार केली आहे वितर्कांची व्हेरिएबल संख्या स्वीकारण्यासाठी Java चे varargs वैशिष्ट्य वापरते. ही पद्धत प्रदान केलेल्या प्रत्येक घटकावर पुनरावृत्ती करते आणि त्यास नवीन जोडते . हा दृष्टीकोन सिंगल-लाइन इनिशिएलायझेशनच्या सोयीसह गतिशीलपणे घटक जोडण्याची लवचिकता एकत्र करतो. द मेथडमध्ये यादी भरण्याची प्रक्रिया सुलभ होते आणि varargs वापरल्याने मेथड कॉल स्वच्छ आणि संक्षिप्त होतो. एकंदरीत, या स्क्रिप्ट्स आरंभ करण्यासाठी अनेक उपाय प्रदान करतात ArrayList एकाच ओळीत, वाचनीयता, संक्षिप्तता आणि लवचिकता संतुलित करणे.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // Initial multi-step approach
        ArrayList<String> places = new ArrayList<>();
        places.add("Buenos Aires");
        places.add("Córdoba");
        places.add("La Plata");

        // Refactored approach using Arrays.asList
        ArrayList<String> placesRefactored = new ArrayList<>(
            Arrays.asList("Buenos Aires", "Córdoba", "La Plata")
        );

        // Single line initialization using List.of (Java 9+)
        List<String> placesJava9 = List.of("Buenos Aires", "Córdoba", "La Plata");
        ArrayList<String> placesList = new ArrayList<>(placesJava9);

        // Output all lists to verify
        System.out.println(places);
        System.out.println(placesRefactored);
        System.out.println(placesList);
    }
}

१

ॲरेलिस्ट इनिशियलायझेशनसाठी प्रगत तंत्रे

प्रारंभ करण्याचा आणखी एक प्रभावी मार्ग एका ओळीत वापरून आहे पद्धत ही पद्धत आपल्याला एका संग्रहामध्ये कार्यक्षमतेने एकाधिक घटक जोडण्याची परवानगी देते. उदाहरणार्थ, आपण एक तयार करू शकता आणि वापरून एका ओळीत त्यात घटक जोडा Collections.addAll(places, "Buenos Aires", "Córdoba", "La Plata"). हा दृष्टीकोन संक्षिप्त आहे आणि वापरण्याची आवश्यकता दूर करते किंवा . हे अधिक लवचिकता देते कारण तुम्ही विद्यमान घटकांमध्ये घटक जोडू शकता नवीन तयार करण्यापेक्षा.

याव्यतिरिक्त, Java 8 मध्ये सादर केलेले Java Streams, याद्या तयार करण्यासाठी आणि प्रारंभ करण्यासाठी एक आधुनिक आणि शक्तिशाली मार्ग प्रदान करतात. वापरून पद्धत, आपण घटकांचा प्रवाह तयार करू शकता आणि नंतर ते वापरून सूचीमध्ये संकलित करू शकता पद्धत ही पद्धत केवळ संक्षिप्तच नाही तर फंक्शनल प्रोग्रामिंग पॅराडाइमचा फायदा देखील घेते, ज्यामुळे कोड अधिक अर्थपूर्ण आणि वाचनीय बनते. उदाहरणार्थ, आपण प्रारंभ करू शकता याप्रमाणे: ArrayList<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toCollection(ArrayList::new)). हे प्रवाहांच्या शक्तीचा फायदा घेते आणि संग्रह तयार करण्यासाठी आणि वाचनीय रीतीने सुरू करते.

1. प्रारंभ करण्याचा सर्वात संक्षिप्त मार्ग कोणता आहे ?
2. वापरत आहे किंवा प्रारंभ करण्याचे संक्षिप्त मार्ग आहेत .
3. मी विद्यमान घटकांमध्ये कसे जोडू शकतो एका ओळीत?
4. तुम्ही वापरू शकता विद्यमान मध्ये एकाधिक घटक जोडण्यासाठी एका ओळीत.
5. वापरून काय फायदा ?
6. एक अपरिवर्तनीय सूची तयार करते, जी केवळ-वाचनीय संग्रहांसाठी उपयुक्त असू शकते.
7. मी इनिशियलाइज कसे करू प्रवाह वापरत आहात?
8. तुम्ही वापरू शकता आणि प्रारंभ करण्यासाठी .
9. प्रारंभ करण्यासाठी मी varargs वापरू शकतो का? ?
10. होय, तुम्ही एक उपयुक्तता पद्धत तयार करू शकता जी इनिशियलाइज करण्यासाठी varargs वापरते .
11. प्रारंभ करणे शक्य आहे का Java 8 मध्ये एका ओळीत?
12. होय, तुम्ही वापरू शकता आणि प्रारंभ करण्यासाठी Java 8 मध्ये एका ओळीत.
13. वापरून काय फायदा ?
14. मध्ये एकाधिक घटक जोडण्याची परवानगी देते एका, संक्षिप्त विधानात.
15. यांच्यात काय फरक आहे आणि ?
16. ॲरेद्वारे समर्थित निश्चित आकाराची यादी परत करते, तर एक अपरिवर्तनीय यादी तयार करते.

शेवटी, प्रारंभ करणे एका ओळीत तुमचा कोड लक्षणीयरीत्या सरलीकृत करू शकतो. सारखे तंत्र , , आणि varargs वापरून उपयुक्तता पद्धती संक्षिप्त आणि वाचनीय उपाय देतात. द्वारे तयार केलेल्या अपरिवर्तनीय सूचींमधून प्रत्येक पद्धतीचे त्याचे अद्वितीय फायदे आहेत List.of सानुकूल उपयुक्तता पद्धतींद्वारे सुलभ आणि गतिशील याद्यांसाठी. ही तंत्रे समजून घेऊन आणि त्याचा वापर करून, विकासक अधिक स्वच्छ, अधिक कार्यक्षम Java कोड लिहू शकतात, उत्पादकता आणि कोड राखण्याची क्षमता दोन्ही सुधारू शकतात.