ജാവയിൽ അറേ ലിസ്റ്റുകൾ കാര്യക്ഷമമായി സൃഷ്ടിക്കുന്നു
ജാവ പ്രോജക്റ്റുകളിൽ പ്രവർത്തിക്കുമ്പോൾ, ലിസ്റ്റുകൾ കാര്യക്ഷമമായി സൃഷ്ടിക്കുകയും സമാരംഭിക്കുകയും ചെയ്യുന്നത് സമയം ലാഭിക്കുകയും കോഡ് ക്ലീനർ ആക്കുകയും ചെയ്യും. ടെസ്റ്റിംഗ് ആവശ്യങ്ങൾക്കായി, നിങ്ങൾ പലപ്പോഴും ഓപ്ഷനുകളുടെ ഒരു ലിസ്റ്റ് വേഗത്തിൽ സജ്ജീകരിക്കേണ്ടി വന്നേക്കാം. ഈ ലേഖനത്തിൽ, ഒരു വരിയിൽ ഒരു അറേ ലിസ്റ്റ് എങ്ങനെ ആരംഭിക്കാമെന്ന് ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും.
തുടക്കത്തിൽ, പല ഡെവലപ്പർമാരും ഒരു അറേ ലിസ്റ്റിലേക്ക് ഘടകങ്ങൾ ചേർക്കുന്നതിന് ഒരു മൾട്ടി-സ്റ്റെപ്പ് പ്രോസസ്സ് ഉപയോഗിച്ചേക്കാം. ഇതിനെ ഒരൊറ്റ വരിയിൽ ഘനീഭവിപ്പിക്കുന്ന ഒരു പുനർനിർമ്മാണ സമീപനത്തെക്കുറിച്ച് ഞങ്ങൾ ചർച്ച ചെയ്യും, ഇത് നേടുന്നതിന് ഇതിലും മികച്ച മാർഗമുണ്ടോ എന്ന് പര്യവേക്ഷണം ചെയ്യും.
കമാൻഡ് | വിവരണം |
---|---|
Arrays.asList | ഒരു അറേയെ ഒരു നിശ്ചിത വലിപ്പമുള്ള പട്ടികയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു. ഒരു വരിയിൽ ലിസ്റ്റുകൾ ആരംഭിക്കുന്നതിന് ഉപയോഗപ്രദമാണ്. |
List.of | നിർദ്ദിഷ്ട ഘടകങ്ങൾ അടങ്ങിയ ഒരു മാറ്റമില്ലാത്ത ലിസ്റ്റ് സൃഷ്ടിക്കുന്നു. ജാവ 9 മുതൽ ലഭ്യമാണ്. |
newArrayList | വേരിയബിൾ ആർഗ്യുമെൻ്റുകൾ ഉപയോഗിച്ച് ഒരു അറേ ലിസ്റ്റ് ആരംഭിക്കുന്നതിനുള്ള ഒരു ഇഷ്ടാനുസൃത യൂട്ടിലിറ്റി രീതി. ലിസ്റ്റ് സൃഷ്ടിക്കുന്നത് ലളിതമാക്കുന്നു. |
System.out.println | സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക് നിർദ്ദിഷ്ട സന്ദേശം പ്രിൻ്റ് ചെയ്യുന്നു. ലിസ്റ്റ് ഉള്ളടക്കങ്ങൾ പരിശോധിക്കാൻ ഉപയോഗിക്കുന്നു. |
for-each loop | ഒരു അറേയിലോ ശേഖരത്തിലോ ഉള്ള ഓരോ ഘടകത്തിനും മുകളിൽ ആവർത്തിക്കുന്നു. ലിസ്റ്റിലേക്ക് ഘടകങ്ങൾ ചേർക്കുന്നതിന് യൂട്ടിലിറ്റി രീതിയിൽ ഉപയോഗിക്കുന്നു. |
varargs | ഒരു വേരിയബിൾ നമ്പർ ആർഗ്യുമെൻ്റുകൾ സ്വീകരിക്കാൻ ഒരു രീതിയെ അനുവദിക്കുന്നു. ഫ്ലെക്സിബിൾ യൂട്ടിലിറ്റി രീതികൾ സൃഷ്ടിക്കുന്നതിന് ഉപയോഗപ്രദമാണ്. |
അറേ ലിസ്റ്റുകൾ ആരംഭിക്കുന്നതിനുള്ള കാര്യക്ഷമമായ സാങ്കേതിക വിദ്യകൾ
ആദ്യ സ്ക്രിപ്റ്റ് ഉദാഹരണത്തിൽ, ഒരു സമാരംഭിക്കുന്നതിനുള്ള മൂന്ന് രീതികൾ ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്തു ജാവയിൽ. തുടക്കത്തിൽ, ദി ഒരു മൾട്ടി-സ്റ്റെപ്പ് സമീപനം ഉപയോഗിച്ചാണ് സൃഷ്ടിച്ചത്, അവിടെ ഞങ്ങൾ ലിസ്റ്റ് പ്രഖ്യാപിക്കുകയും ഓരോ ഘടകങ്ങളും വ്യക്തിഗതമായി ചേർക്കുകയും ചെയ്യുന്നു. ഈ രീതി, നേരായതാണെങ്കിലും, വാചാലമാണ്. ഞങ്ങൾ ഇത് ഉപയോഗിച്ച് ഒരൊറ്റ വരിയിലേക്ക് റീഫാക്ടർ ചെയ്തു , ഇത് സ്ട്രിംഗുകളുടെ ഒരു നിരയെ ഒരു നിശ്ചിത വലിപ്പത്തിലുള്ള പട്ടികയിലേക്ക് പരിവർത്തനം ചെയ്യുകയും തുടർന്ന് അത് കൈമാറുകയും ചെയ്യുന്നു ArrayList കൺസ്ട്രക്റ്റർ. ഈ സമീപനം കൂടുതൽ സംക്ഷിപ്തവും വായിക്കാൻ എളുപ്പവുമാണ്. അവസാനം ഞങ്ങൾ അവതരിപ്പിച്ചു ജാവ 9 മുതൽ ലഭ്യമായ രീതി, ഒരൊറ്റ വരിയിൽ ഒരു മാറ്റമില്ലാത്ത ലിസ്റ്റ് സൃഷ്ടിക്കുന്നു. ഒരു ഉപയോഗിക്കുന്നതിന് , ഞങ്ങൾ അത് കൈമാറുന്നു കൺസ്ട്രക്റ്റർ, ലാളിത്യം സംയോജിപ്പിക്കുന്നു List.of എന്ന വഴക്കത്തോടെ .
രണ്ടാമത്തെ സ്ക്രിപ്റ്റ് ഉദാഹരണത്തിൽ, ഞങ്ങൾ ഒരു ഇഷ്ടാനുസൃത യൂട്ടിലിറ്റി രീതി സൃഷ്ടിച്ചു ഒരു വേരിയബിൾ എണ്ണം ആർഗ്യുമെൻ്റുകൾ സ്വീകരിക്കുന്നതിന് ജാവയുടെ 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);
}
}
അറേ ലിസ്റ്റ് ഇനീഷ്യലൈസേഷനായി ഒരു യൂട്ടിലിറ്റി മെത്തേഡ് ഉപയോഗിക്കുന്നു
ഇഷ്ടാനുസൃത യൂട്ടിലിറ്റി രീതികളുള്ള ജാവ പ്രോഗ്രാമിംഗ്
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);
}
}
അറേ ലിസ്റ്റ് ഇനീഷ്യലൈസേഷനായുള്ള നൂതന സാങ്കേതിക വിദ്യകൾ
ഒരു സമാരംഭിക്കാനുള്ള മറ്റൊരു ഫലപ്രദമായ മാർഗം ഒരു വരിയിൽ ഉപയോഗിച്ചാണ് രീതി. ഒരു ശേഖരത്തിലേക്ക് കാര്യക്ഷമമായി ഒന്നിലധികം ഘടകങ്ങൾ ചേർക്കാൻ ഈ രീതി നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ഒരു സൃഷ്ടിക്കാൻ കഴിയും ഉപയോഗിച്ച് ഒരു വരിയിൽ ഘടകങ്ങൾ ചേർക്കുക 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-ൽ ഒരു വരിയിൽ.
- ഉപയോഗിക്കുന്നതിൻ്റെ പ്രയോജനം എന്താണ് ?
- ഒന്നിലേക്ക് ഒന്നിലധികം ഘടകങ്ങൾ ചേർക്കാൻ അനുവദിക്കുന്നു ഒരൊറ്റ, സംക്ഷിപ്തമായ പ്രസ്താവനയിൽ.
- എന്താണ് തമ്മിലുള്ള വ്യത്യാസം ഒപ്പം ?
- അറേയുടെ പിന്തുണയുള്ള ഒരു നിശ്ചിത വലിപ്പത്തിലുള്ള ലിസ്റ്റ് നൽകുന്നു, while ഒരു മാറ്റമില്ലാത്ത പട്ടിക സൃഷ്ടിക്കുന്നു.
ഉപസംഹാരമായി, ഒരു സമാരംഭിക്കുന്നു ഒരൊറ്റ വരിയിൽ നിങ്ങളുടെ കോഡ് ഗണ്യമായി ലളിതമാക്കാൻ കഴിയും. പോലുള്ള ടെക്നിക്കുകൾ , , കൂടാതെ varargs-നെ സ്വാധീനിക്കുന്ന യൂട്ടിലിറ്റി രീതികൾ സംക്ഷിപ്തവും വായിക്കാവുന്നതുമായ പരിഹാരങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു. സൃഷ്ടിച്ച മാറ്റമില്ലാത്ത ലിസ്റ്റുകളിൽ നിന്ന് ഓരോ രീതിക്കും അതിൻ്റേതായ ഗുണങ്ങളുണ്ട് List.of ഇഷ്ടാനുസൃത യൂട്ടിലിറ്റി രീതികൾ വഴി സുഗമമാക്കുന്ന വഴക്കമുള്ളതും ചലനാത്മകവുമായ ലിസ്റ്റുകളിലേക്ക്. ഈ സാങ്കേതിക വിദ്യകൾ മനസ്സിലാക്കുകയും ഉപയോഗിക്കുകയും ചെയ്യുന്നതിലൂടെ, ഡെവലപ്പർമാർക്ക് വൃത്തിയുള്ളതും കൂടുതൽ കാര്യക്ഷമവുമായ ജാവ കോഡ് എഴുതാൻ കഴിയും, ഉൽപ്പാദനക്ഷമതയും കോഡ് പരിപാലനവും മെച്ചപ്പെടുത്തുന്നു.