ஜாவா - வரிசைப்பட்டியலின் ஒற்றை வரி துவக்கம்

ஜாவாவில் அர்ரேலிஸ்ட்களை திறம்பட உருவாக்குதல்

ஜாவா திட்டப்பணிகளில் பணிபுரியும் போது, ​​பட்டியலைத் திறமையாக உருவாக்குவதும் துவக்குவதும் நேரத்தை மிச்சப்படுத்துவதுடன் குறியீட்டை சுத்தமாக்கும். சோதனை நோக்கங்களுக்காக, நீங்கள் அடிக்கடி விருப்பங்களின் பட்டியலை விரைவாக அமைக்க வேண்டியிருக்கும். இந்தக் கட்டுரையில், ஒரே வரியில் வரிசைப்பட்டியலை எவ்வாறு துவக்குவது என்பதை ஆராய்வோம்.

ஆரம்பத்தில், பல டெவலப்பர்கள் வரிசைப்பட்டியலில் கூறுகளைச் சேர்க்க பல-படி செயல்முறையைப் பயன்படுத்தலாம். இதை ஒரே வரியில் சுருக்கி மறுவடிவமைக்கப்பட்ட அணுகுமுறையைப் பற்றி விவாதிப்போம், மேலும் இதை அடைவதற்கு இன்னும் சிறந்த வழி இருக்கிறதா என்று ஆராய்வோம்.

வரிசை பட்டியல்களை துவக்குவதற்கான திறமையான நுட்பங்கள்

முதல் ஸ்கிரிப்ட் எடுத்துக்காட்டில், ஐ துவக்குவதற்கான மூன்று முறைகளை ஆராய்ந்தோம் ArrayList ஜாவாவில். ஆரம்பத்தில், தி ArrayList பல-படி அணுகுமுறையைப் பயன்படுத்தி உருவாக்கப்பட்டது, அங்கு நாம் பட்டியலை அறிவித்து, பின்னர் ஒவ்வொரு உறுப்புகளையும் தனித்தனியாக சேர்க்கிறோம். இந்த முறை, நேரடியானதாக இருந்தாலும், வாய்மொழியானது. இதைப் பயன்படுத்தி ஒற்றை வரியாக மறுவடிவமைத்தோம் Arrays.asList, இது சரங்களின் வரிசையை ஒரு நிலையான அளவு பட்டியலாக மாற்றி பின்னர் அதை அனுப்புகிறது ArrayList கட்டமைப்பாளர். இந்த அணுகுமுறை மிகவும் சுருக்கமானது மற்றும் படிக்க எளிதானது. இறுதியாக, நாங்கள் அறிமுகப்படுத்தினோம் List.of முறை, ஜாவா 9 முதல் கிடைக்கும், இது ஒற்றை வரியில் மாறாத பட்டியலை உருவாக்குகிறது. அதை பயன்படுத்த ஒரு ArrayList, நாங்கள் அதை அனுப்புகிறோம் ArrayList கட்டமைப்பாளர், எளிமையை இணைத்தல் List.of என்ற நெகிழ்வுத்தன்மையுடன் ArrayList.

இரண்டாவது ஸ்கிரிப்ட் எடுத்துக்காட்டில், தனிப்பயன் பயன்பாட்டு முறையை உருவாக்கியுள்ளோம் newArrayList மாறி எண்ணிக்கையிலான வாதங்களை ஏற்க ஜாவாவின் 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);
    }
}

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 முறை. ஒரு சேகரிப்பில் பல கூறுகளை திறம்பட சேர்க்க இந்த முறை உங்களை அனுமதிக்கிறது. உதாரணமாக, நீங்கள் ஒன்றை உருவாக்கலாம் ArrayList பயன்படுத்துவதன் மூலம் ஒரு வரியில் கூறுகளைச் சேர்க்கவும் Collections.addAll(places, "Buenos Aires", "Córdoba", "La Plata"). இந்த அணுகுமுறை சுருக்கமானது மற்றும் பயன்படுத்த வேண்டிய தேவையை நீக்குகிறது Arrays.asList அல்லது List.of. ஏற்கனவே உள்ள கூறுகளை நீங்கள் சேர்க்க முடியும் என்பதால் இது அதிக நெகிழ்வுத்தன்மையை வழங்குகிறது ArrayList புதிய ஒன்றை உருவாக்குவதை விட.

கூடுதலாக, ஜாவா 8 இல் அறிமுகப்படுத்தப்பட்ட ஜாவா ஸ்ட்ரீம்கள், பட்டியல்களை உருவாக்க மற்றும் துவக்குவதற்கு நவீன மற்றும் சக்திவாய்ந்த வழியை வழங்குகிறது. பயன்படுத்தி Stream.of முறை, நீங்கள் உறுப்புகளின் ஸ்ட்ரீமை உருவாக்கலாம் மற்றும் அவற்றைப் பயன்படுத்தி ஒரு பட்டியலில் சேகரிக்கலாம் Collectors.toList முறை. இந்த முறை சுருக்கமானது மட்டுமல்ல, செயல்பாட்டு நிரலாக்க முன்னுதாரணத்தைப் பயன்படுத்துகிறது, மேலும் குறியீட்டை மேலும் வெளிப்படுத்தக்கூடியதாகவும் படிக்கக்கூடியதாகவும் ஆக்குகிறது. உதாரணமாக, நீங்கள் ஒரு துவக்க முடியும் ArrayList இது போன்ற: ArrayList<String> places = Stream.of("Buenos Aires", "Córdoba", "La Plata").collect(Collectors.toCollection(ArrayList::new)). இது ஒரு திரவ மற்றும் படிக்கக்கூடிய முறையில் சேகரிப்புகளை உருவாக்குவதற்கும் துவக்குவதற்கும் ஸ்ட்ரீம்களின் ஆற்றலைப் பயன்படுத்துகிறது.