සරල පිළිතුර
දී ජාවා 9 හෝ පසුව, පසු List.of()එක් කරන ලදී:
List<String> strings = List.of("foo", "bar", "baz");
සමග ජාවා 10 හෝ පසුව, මෙම සමඟ කෙටි කළ හැකි varඉඟි පද.
var strings = List.of("foo", "bar", "baz");
මෙය ඔබට වෙනස් කළ නොහැකිList බැවින් එය වෙනස් කළ නොහැක.
ඔබ එය සූදානම් කරන බොහෝ අවස්ථාවන්හිදී ඔබට අවශ්ය වන්නේ එයයි.
ජාවා 8 හෝ ඊට පෙර:
List<String> strings = Arrays.asList("foo", "bar", "baz");
මෙය ඔබට Listඅරාවකින් පිටුබලය ලබා දෙන බැවින් එයට දිග වෙනස් කළ නොහැක.
නමුත් ඔබට ඇමතිය හැකිය List.set, එබැවින් එය තවමත් විකෘති වේ.
Arrays.asListස්ථිතික ආනයනයකින් ඔබට ඊටත් වඩා කෙටි කළ හැකිය :
List<String> strings = asList("foo", "bar", "baz");
ස්ථිතික ආනයනය:
import static java.util.Arrays.asList;
ඕනෑම නවීන IDE එකක් ඔබ වෙනුවෙන් ස්වයංක්‍රීයව කරනු ඇත.
උදාහරණයක් ලෙස IntelliJ IDEA හි ඔබ ඔබාගෙන Alt+Enterතෝරන්න Static import method....
කෙසේ වෙතත්, මම List.ofක්‍රමවේදය කෙටි කිරීමට නිර්දේශ නොකරමි of, මන්ද එය ව්‍යාකූල වේ.
List.ofදැනටමත් ප්‍රමාණවත් තරම් කෙටි වන අතර හොඳින් කියවයි.
StreamS භාවිතා කිරීම
එය විය යුත්තේ Listඇයි?
ජාවා 8 හෝ ඊට පසු ඔබට Streamවඩාත් නම්‍යශීලී එකක් භාවිතා කළ හැකිය :
Stream<String> strings = Stream.of("foo", "bar", "baz");
ඔබට සමගාමී විය හැකිය Stream:
Stream<String> strings = Stream.concat(Stream.of("foo", "bar"),
Stream.of("baz", "qux"));
නැතහොත් ඔබට a Streamසිට a දක්වා යා හැකිය List:
import static java.util.stream.Collectors.toList;
List<String> strings = Stream.of("foo", "bar", "baz").collect(toList());
නමුත් වඩාත් සුදුසු වන්නේ Streamඑය එකතු නොකොට a List.
ඔබට සැබවින්ම අවශ්ය නම්java.util.ArrayList
(ඔබ බොහෝ විට එසේ නොකරනු ඇත.) JEP 269
උපුටා දැක්වීමට (මගේ අවධාරණය):
ඒ නිසා එය කුඩා කට්ටලයක් සාරධර්ම වලට කෙළින් කට්ටලය සමඟ mutable එකතුව උදාහරණයක් ආරම්භනය සඳහා භාවිතා රෝගීන්. සාමාන්යයෙන් එම පූර්ව නිශ්චිත අගයන් වෙනස් කළ නොහැකි එකතුවක තිබීම වඩාත් සුදුසුය, පසුව පිටපත් සාදන්නෙකු හරහා විකෘති එකතුව ආරම්භ කිරීම වඩාත් සුදුසුය.
ඔබට අවශ්ය නම් දෙකම prepopulate ක ArrayList සහ ඒ සඳහා, පසුව භාවිතා කරන්න (ඇයි?)
ArrayList<String> strings = new ArrayList<>(List.of("foo", "bar"));
strings.add("baz");
හෝ ජාවා 8 හෝ ඊට පෙර:
ArrayList<String> strings = new ArrayList<>(asList("foo", "bar"));
strings.add("baz");
හෝ භාවිතා කිරීම Stream:
import static java.util.stream.Collectors.toCollection;
ArrayList<String> strings = Stream.of("foo", "bar")
.collect(toCollection(ArrayList::new));
strings.add("baz");
නමුත් නැවතත්, එය Streama ට එකතු කිරීම වෙනුවට කෙලින්ම භාවිතා කිරීම වඩා හොඳය List.
ක්රියාත්මක කිරීම සඳහා නොව අතුරු මුහුණත් සඳහා වැඩසටහන
ඔබ කියා සිටියේ ඔබ ලැයිස්තුව ArrayListඔබේ කේතයේ ඇති බව ප්‍රකාශ කළ නමුත් ඔබ එය කළ යුත්තේ ඔබ ArrayListඑහි නොමැති යම් සාමාජිකයෙකු භාවිතා කරන්නේ නම් පමණි List.
ඔබ බොහෝ විට නොකරන දේ.
සාමාන්යයෙන් ඔබ විචල්ය ඔබ භාවිතා කිරීමට බලාපොරොත්තු වන බව වඩාත් පොදු අතුරුමුහුණත් විසින් (උදා: ප්රකාශයට පත් කළ යුතු Iterable, Collection, හෝ List) උදා:, සහ විශේෂිත ක්රියාත්මක කිරීම ඔවුන්ට ආරම්භනය ( ArrayList, LinkedListහෝArrays.asList() ).
එසේ නොමැතිනම් ඔබ ඔබේ කේතය එම විශේෂිත වර්ගයට සීමා කරයි, ඔබට අවශ්ය විට එය වෙනස් කිරීම දුෂ්කර වනු ඇත.
උදාහරණයක් ලෙස, ඔබ මෙය ArrayListවෙත යොමු කරන්නේ නම් void method(...):
// Iterable if you just need iteration, for (String s : strings):
void method(Iterable<String> strings) {
for (String s : strings) { ... }
}
// Collection if you also need .size(), .isEmpty(), or .stream():
void method(Collection<String> strings) {
if (!strings.isEmpty()) { strings.stream()... }
}
// List if you also need .get(index):
void method(List<String> strings) {
strings.get(...)
}
// Don't declare a specific list implementation
// unless you're sure you need it:
void method(ArrayList<String> strings) {
??? // You don't want to limit yourself to just ArrayList
}
InputStreamසාමාන්යයෙන් උදාහරණයක් ලෙස FileInputStreamහෝ a BufferedInputStreamඑකක් වුවද සෑම විටම විචල්‍යය ප්‍රකාශ කිරීම තවත් උදාහරණයකි , මන්ද යම් දවසක ඔබට හෝ වෙනත් කෙනෙකුට වෙනත් ආකාරයක භාවිතා කිරීමට අවශ්ය වනු ඇත InputStream.
ArrasyList<String> places = ["Buenos Aires", "Córdoba", "La Plata"]