जावा - एक ArrayList का सिंगल लाइन इनिशियलाइज़ेशन

Paul Boyer

शनिवार, 29 जून 2024 को 11:43:22 am

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

आज्ञा विवरण

Arrays.asList किसी सारणी को निश्चित आकार की सूची में परिवर्तित करता है। सूचियों को एक पंक्ति में आरंभ करने के लिए उपयोगी।

List.of निर्दिष्ट तत्वों वाली एक अपरिवर्तनीय सूची बनाता है। जावा 9 से आगे उपलब्ध है।

newArrayList परिवर्तनीय तर्कों के साथ ArrayList आरंभ करने के लिए एक कस्टम उपयोगिता विधि। सूची निर्माण को सरल बनाता है.

System.out.println निर्दिष्ट संदेश को मानक आउटपुट पर प्रिंट करता है। सूची सामग्री को सत्यापित करने के लिए उपयोग किया जाता है।

for-each loop किसी सरणी या संग्रह में प्रत्येक तत्व पर पुनरावृत्ति करता है। सूची में तत्वों को जोड़ने के लिए उपयोगिता विधि में उपयोग किया जाता है।

varargs किसी विधि को चर संख्या में तर्क स्वीकार करने की अनुमति देता है। लचीली उपयोगिता पद्धतियाँ बनाने के लिए उपयोगी।

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

ArrayLists को आरंभ करने की कुशल तकनीकें

पहले स्क्रिप्ट उदाहरण में, हमने आरंभ करने के तीन तरीकों का पता लगाया जावा में. प्रारंभ में, बहु-चरणीय दृष्टिकोण का उपयोग करके बनाया गया है जहां हम सूची घोषित करते हैं और फिर प्रत्येक तत्व को व्यक्तिगत रूप से जोड़ते हैं। यह विधि सरल होते हुए भी क्रियात्मक है। इसके बाद हमने इसका उपयोग करके इसे एक पंक्ति में बदल दिया , जो स्ट्रिंग्स की एक सरणी को एक निश्चित आकार की सूची में परिवर्तित करता है और फिर इसे पास करता है ArrayList निर्माता. यह दृष्टिकोण अधिक संक्षिप्त और पढ़ने में आसान है। अंत में, हमने इसका परिचय दिया विधि, जावा 9 के बाद से उपलब्ध है, जो एक पंक्ति में एक अपरिवर्तनीय सूची बनाती है। इसे एक में उपयोग करने के लिए , हम इसे पास करते हैं कंस्ट्रक्टर, की सादगी का संयोजन List.of के लचीलेपन के साथ .

दूसरे स्क्रिप्ट उदाहरण में, हमने एक कस्टम उपयोगिता विधि बनाई यह विभिन्न प्रकार के तर्कों को स्वीकार करने के लिए जावा के वैरार्ग्स सुविधा का उपयोग करता है। यह विधि प्रत्येक प्रदान किए गए तत्व को दोहराती है और इसे एक नए में जोड़ती है . यह दृष्टिकोण एकल-पंक्ति आरंभीकरण की सुविधा के साथ तत्वों को गतिशील रूप से जोड़ने के लचीलेपन को जोड़ता है। विधि के भीतर सूची को पॉप्युलेट करने की प्रक्रिया सरल हो जाती है, और varargs का उपयोग करने से विधि कॉल साफ़ और संक्षिप्त हो जाती है। कुल मिलाकर, ये स्क्रिप्ट आरंभ करने के लिए कई समाधान प्रदान करती हैं ArrayList एक ही पंक्ति में, पठनीयता, संक्षिप्तता और लचीलेपन को संतुलित करते हुए।

जावा में 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 आरंभीकरण के लिए उपयोगिता विधि का उपयोग करना

कस्टम उपयोगिता विधियों के साथ जावा प्रोग्रामिंग

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

public class ListUtils {
    public static <T> ArrayList<T> newArrayList(T... elements) {
        ArrayList<T> list = new ArrayList<>();
        for (T element : elements) {
            list.add(element);
        }
        return list;
    }
}

public class Main {
    public static void main(String[] args) {
        // Using utility method for single line initialization
        ArrayList<String> places = ListUtils.newArrayList("Buenos Aires", "Córdoba", "La Plata");

        // Output to verify
        System.out.println(places);
    }
}

ArrayList आरंभीकरण के लिए उन्नत तकनीकें

आरंभ करने का एक और प्रभावी तरीका एक पंक्ति में का उपयोग करके है तरीका। यह विधि आपको एक संग्रह में कुशलतापूर्वक कई तत्व जोड़ने की अनुमति देती है। उदाहरण के लिए, आप एक बना सकते हैं और इसका उपयोग करके तत्वों को एक पंक्ति में जोड़ें Collections.addAll(places, "Buenos Aires", "Córdoba", "La Plata"). यह दृष्टिकोण संक्षिप्त है और उपयोग की आवश्यकता को समाप्त करता है या . यह अधिक लचीलापन प्रदान करता है क्योंकि आप किसी मौजूदा में तत्व जोड़ सकते हैं एक नया निर्माण करने के बजाय.

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

किसी को प्रारंभ करने का सबसे संक्षिप्त तरीका क्या है? ?
का उपयोग करते हुए या आरंभ करने के संक्षिप्त तरीके हैं .
मैं किसी मौजूदा में तत्व कैसे जोड़ सकता हूँ? एक पंक्ति में?
आप उपयोग कर सकते हैं किसी मौजूदा में एकाधिक तत्व जोड़ने के लिए एक पंक्ति में.
इस्तेमाल करने से क्या फायदा ?
एक अपरिवर्तनीय सूची बनाता है, जो केवल पढ़ने योग्य संग्रहों के लिए उपयोगी हो सकता है।
मैं कैसे प्रारंभ करूं? स्ट्रीम का उपयोग कर रहे हैं?
आप उपयोग कर सकते हैं और एक प्रारंभ करने के लिए .
क्या मैं किसी को प्रारंभ करने के लिए varargs का उपयोग कर सकता हूँ? ?
हाँ, आप एक उपयोगिता विधि बना सकते हैं जो किसी को आरंभ करने के लिए varargs का उपयोग करती है .
क्या किसी को प्रारंभ करना संभव है? जावा 8 में एक पंक्ति में?
हाँ, आप उपयोग कर सकते हैं और एक प्रारंभ करने के लिए जावा 8 में एक पंक्ति में।
प्रयोग करने से क्या फायदा है ?
एक में कई तत्व जोड़ने की अनुमति देता है एक एकल, संक्षिप्त कथन में.
के बीच क्या अंतर है और ?
जबकि, सरणी द्वारा समर्थित एक निश्चित आकार की सूची लौटाता है एक अपरिवर्तनीय सूची बनाता है.

अंत में, एक आरंभीकरण एक पंक्ति में आपके कोड को काफी सरल बनाया जा सकता है। जैसी तकनीकें , , और varargs का लाभ उठाने वाली उपयोगिता विधियाँ संक्षिप्त और पठनीय समाधान प्रदान करती हैं। द्वारा बनाई गई अपरिवर्तनीय सूचियों से प्रत्येक विधि के अपने अनूठे फायदे हैं List.of कस्टम उपयोगिता विधियों द्वारा सुविधाजनक लचीली और गतिशील सूचियों के लिए। इन तकनीकों को समझकर और उपयोग करके, डेवलपर्स उत्पादकता और कोड रखरखाव दोनों में सुधार करते हुए क्लीनर, अधिक कुशल जावा कोड लिख सकते हैं।