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

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

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

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

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

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

दुसऱ्या स्क्रिप्टच्या उदाहरणामध्ये, आम्ही कस्टम युटिलिटी पद्धत तयार केली आहे ९ वितर्कांची व्हेरिएबल संख्या स्वीकारण्यासाठी Java चे varargs वैशिष्ट्य वापरते. ही पद्धत प्रदान केलेल्या प्रत्येक घटकावर पुनरावृत्ती करते आणि त्यास नवीन जोडते ArrayList. हा दृष्टीकोन सिंगल-लाइन इनिशिएलायझेशनच्या सोयीसह गतिशीलपणे घटक जोडण्याची लवचिकता एकत्र करतो. द for-each loop मेथडमध्ये यादी भरण्याची प्रक्रिया सुलभ होते आणि 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);
    }
}

१

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

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

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