Java List: ආරම්භකයින් සහ සංවර්ධකයින් සඳහා සම්පූර්ණ මාර්ගෝපදේශය

1. හැඳින්වීම

Java හි List හි වැදගත්කම කුමක්ද?

Java කේතනයේදී, “List” යනු ඉතා නිතර පෙනෙන දත්ත ව්‍යුහයකි. විශේෂයෙන්ම ඔබට බහු සංඛ්‍යාක ක්‍රියාවලියන් එකතුවෙන් කළ යුතු විස්තරවලදී, එය වර්ගීකරණවලට වඩා නම්‍යශීලී සහ භාවිතා කිරීමට පහසු වන අතර, එය බොහෝ ප්‍රායෝගික තත්ත්වයන්හිදී ඉහළ වටිනාකමක් ලබා දෙයි.

“List” යනු Java Collections Framework හි මූලික අතුරුමුහුණතකි සහ ArrayList සහ LinkedList වැනි විවිධ ක්‍රියාත්මක කිරීම් පන්ති මගින් විවිධ තත්ත්වයන් කළමනාකරණය කිරීමේ මෙකොන්මෙන්ට් එකක් සපයයි. දත්ත එකතු කිරීම, මක කිරීම, සෙවීම සහ යාවත්කාලීන කිරීම වැනි ක්‍රියාකාරකම් සිදු කිරීමේ හැකියාව තරමක් සරලව සිදු කිරීම List වෙත ආකර්ෂණය වීමේ හේතුවලින් එකකි.

මෙම ලිපියේ අරමුණ සහ ඉලක්කගත ප්‍රේක්ෂකයින්

මෙම ලිපිය “Java List” මූලික සිට උසස් මට්ටම් දක්වා ආරම්භකයින්ට පහසුවෙන් තේරුම් ගත හැකි ආකාරයෙන් පද්ධතිමයව පැහැදිලි කරනු ඇත. ප්‍රධාන ඉලක්කගත ප්‍රේක්ෂකයින් පහත පරිදි වේ:

• Java ඉගෙනීම ආරම්භ කරන අය සහ List භාවිතා කිරීම ගැන අවිනිශ්චිත වන අය
• Array සහ List අතර වෙනස තේරුම් ගැනීමට අවශ්‍ය අය
• ArrayList සහ LinkedList අතර තෝරා ගැනීමේදී දුෂ්කරතාවයට පත්වන අය
• List ප්‍රායෝගිකව භාවිතා කිරීමට පෙර මූලික දේ පුනරීක්ෂණය කිරීමට අවශ්‍ය අය

මෙම ලිපිය කියවීම අවසන් කිරීමට පෙර, අපගේ ඉලක්කය වන්නේ Java හි List හි මූලික සංකල්ප, ක්‍රියාත්මක කිරීම් ක්‍රම සහ විශේෂිත ක්‍රියාකාරකම් පිළිබඳ තදින් තේරුම් ගැනීමක් ලබා ගැනීමයි, එමගින් ඔබට විශ්වාසයෙන් කේතනය කිරීමට හැකි වේ.

ඊළඟ පරිච්ඡේදයේ සිට, අපි “List යනු කුමක්ද?” යන මූලික කොටස පියවරෙන් පියවර පැහැදිලි කිරීම ආරම්භ කරමු.

2. List යනු කුමක්ද?

List හි දළ විශ්ලේෂණය සහ ලක්ෂණ

Java හි “List” යනු අංග රඳවා තබන සංවිධානාත්මක අනුපිළිවෙලකින් රඳවා තබන එකතුවක අතුරුමුහුණතකි. එහි විශාලතම ලක්ෂණ වන්නේ අංග එකතු කිරීමේ අනුපිළිවෙල ආරක්ෂා වීම සහ අංග එකක් සඳහා සුචිකරණය (0 සිට ආරම්භ වන) භාවිතා කරමින් ප්‍රවේශ විය හැකි බවයි.

List යනු Collections Framework හි කොටසක් ලෙස සපයනු ලැබේ සහ පහත ලක්ෂණ ඇත:

• අනුපිටපත් අංග ඉඩකර ගනී
• සුචිකරණයක් දක්වමින් අංග ලබා ගැනීමට, යාවත්කාලීන කිරීමට සහ මක කිරීමට හැකියි
• අංග ගණන ගතිකව වැඩි කිරීමට හෝ අඩු කිරීමට හැකියි (වර්ගීකරණවලට වඩා, එය නිශ්චිත ප්‍රමාණයක් නොවේ)

මෙය නම්‍යශී දත්ත කළමනාකරණය සඳහා ඉඩ සලසන අතර, එය ප්‍රායෝගික කාර්යයන්හිදී ඉතා නිතර භාවිතා වේ.

Array සිට වෙනස

Java හි, වර්ගීකරණ (වගේ int[] හෝ String[]) බහු සංඛ්‍යාක ක්‍රියාවලියන් රඳවා තබන ආකාරයක් ලෙස පවතී, නමුත් List සිට තවත් වෙනස්කම් කිහිපයක් ඇත.

එබැවින්, List යනු වඩාත් නම්‍යශී සහ විශේෂාංග සම්පන්න එකතුවකි, එය බොහෝ තත්ත්වයන්හිදී වර්ගීකරණවලට වඩා ප්‍රායෝගික වේ.

List අතුරුමුහුණත සහ එහි ක්‍රියාත්මක පන්ති

Java හි List භාවිතා කිරීමේදී, ඔබ සාමාන්‍යයෙන් List අතුරුමුහුණත භාවිතා කරමින් විචල්‍යයක් ප්‍රකාශ කරන අතර, විශේෂිත පන්තියකින් (ක්‍රියාත්මක පන්තියකින්) උදාහරණයක් සාදයි. නියෝජිත ක්‍රියාත්මක පන්ති පහත පරිදි වේ:

• ArrayList වර්ගීකරණයකට සමාන ව්‍යුහයක්, වේගවත් ප්‍රවේශයට ඉඩ සලසයි. දත්ත සෙවීම සහ විඥානික ප්‍රවේශය සඳහා ශක්තිමත්.
• LinkedList ද්විත්ව සම්බන්ධිත ලැයිස්තු ව්‍යුහයකින් ක්‍රියාත්මක කර ඇත. ඇතුළත් කිරීම සහ මක කිරීම සඳහා වේගවත්, මෙහෙයුම් නිතර සිදු වන ලැයිස්තු සඳහා සුදුසු.
• Vector ArrayList සමාන නමුත් තරුණ ආරක්ෂිත බැවින් තරමක් බරපතල. දැන් බොහෝ විට භාවිතා නොවේ.

සාමාන්‍යයෙන්, ArrayList විශේෂ හේතුවක් නොමැති නම් වඩාත් පොදුවේ භාවිතා වේ. පසුකාලීනව විස්තර කරන ප්‍රදර්ශන සංසන්දනය මත, භාවිතය අනුව සුදුසු එක තෝරා ගැනීම හොඳයි.

3. List හි මූලික භාවිතය

මෙම කොටස Java හි List භාවිතා කිරීමේදී මූලික ක්‍රියාකාරකම් පියවරෙන් පියවර පැහැදිලි කරයි. මෙහිදී, අපි ArrayList උදාහරණයක් ලෙස භාවිතා කරමින් List හි නියෝජිත ක්‍රියාකාරකම් හඳුන්වා දෙමු.

List හි ප්‍රකාශය සහ ආරම්භකරණය

පළමුව, ArrayList භාවිතා කරමින් List හි මූලික ප්‍රකාශය සහ ආරම්භකරණය බලමු.

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

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
    }
}

answer.It is common practice to declare a variable with the List interface and instantiate it with ArrayList. Generics are used to specify the type to be stored (here, String).

List අතුරුමුහුණත සමඟ වෙනස්කමක් ප්‍රකාශ කිරීම සහ ArrayList සමඟ ආරම්භ කිරීම සාමාන්‍ය පුරුද්දකි. Generics භාවිතා කර ගබඩා කළ යුතු වර්ගය (මෙහි String) නිරූපණය කරයි.

Adding Elements (add)

අංග එකතු කිරීම (add)

To add elements to a List, use the add() method.

List එකකට අංග එකතු කිරීමට, add() ක්‍රමය භාවිතා කරන්න.

fruits.add("apple");
fruits.add("banana");
fruits.add("orange");

This adds three elements to the List in sequence. List preserves the order of addition.

මෙය අනුක්‍රමයෙන් අංග තුන List එකට එකතු කරයි. List එකතු කිරීමේ අනුපිළිවෙල රැක ගනී.

Getting Elements (get)

අංග ලබා ගැනීම (get)

To get an element at a specified index, use get(int index).

නිශ්චිත ඉන්ඩෙක්ස් එකක අංගයක් ලබා ගැනීමට, get(int index) භාවිතා කරන්න.

System.out.println(fruits.get(0)); // "apple" will be displayed

Note that indices start from 0.

සැලකිල්ල: ඉන්ඩෙක්ස් 0 සිට ආරම්භ වේ.

Updating Elements (set)

අංග යාවත්කාලීන කිරීම (set)

To update an element at a certain position, use set(int index, E element).

කොටසක අංගයක් යාවත්කාලීන කිරීමට, set(int index, E element) භාවිතා කරන්න.

fruits.set(1, "grape"); // The second element "banana" is replaced with "grape"

Removing Elements (remove)

අංග ඉවත් කිරීම (remove)

You can also remove elements by a specific index or the element itself.

ඔබට ඉන්ඩෙක්ස් එකක් හෝ අංගයම භාවිතා කර අංග ඉවත් කළ හැක.

fruits.remove(0);           // Removes the first element
fruits.remove("orange");    // Removes "orange" (only the first match)

Getting List Size (size)

List ප්‍රමාණය ලබා ගැනීම (size)

The current number of elements can be obtained with the size() method.

වත්මන් අංග ගණන size() ක්‍රමය භාවිතා කර ලබා ගත හැක.

System.out.println(fruits.size()); // Returns 2, etc.

Checking for Element Existence (contains)

අංගය පවතිනදැයි පරීක්ෂා කිරීම (contains)

To check if a specific element is included in the List, use contains().

නිශ්චිත අංගයක් List එකේ ඇතුළත්දැයි පරීක්ෂා කිරීමට, contains() භාවිතා කරන්න.

if (fruits.contains("grape")) {
    System.out.println("grape is present");
}

Summary: List of Frequently Used Basic Operations

සාරාංශය: නිතර භාවිතා වන මූලික මෙහෙයුම් ලැයිස්තුව

4. List Operation Examples

4. ලැයිස්තු මෙහෙයුම් උදාහරණ

In this chapter, we will introduce practical operation examples using Java’s List. There are many situations where you want to process elements in a list sequentially, and here we will cover representative methods using for loop, enhanced for loop, and Stream API.

මෙම පරිච්ඡේදයේ, Java List භාවිතා කර ප්‍රායෝගික මෙහෙයුම් උදාහරණ හඳුන්වා දෙමු. ලැයිස්තුවේ අංග අනුක්‍රමයෙන් සැකසීමට අවශ්‍ය තත්ත්වයන් බොහෝමයක් ඇත, එමනිසා for ලූප්, උත්සාහිත for ලූප්, සහ Stream API භාවිතා කරන නියෝජිත ක්‍රමයන් මෙහි සලකන්නෙමු.

Iteration using a for loop

for ලූප් භාවිතයෙන් පරික‍්‍රමණය

The most basic method is to retrieve elements using an index within a for loop.

මූලිකම ක්‍රමය වන්නේ for ලූප් එකක් තුළ ඉන්ඩෙක්ස් එකක් භාවිතා කර අංග ලබා ගැනීමයි.

List<String> fruits = new ArrayList<>();
fruits.add("apple");
fruits.add("banana");
fruits.add("orange");

for (int i = 0; i < fruits.size(); i++) {
    System.out.println(fruits.get(i));
}

This method allows for fine‑grained control using the index. For example, it is effective when you want to process only elements at even indices.

මෙම ක්‍රමය ඉන්ඩෙක්ස් භාවිතයෙන් නිරවද්‍ය පාලනය ලබා දේ. උදාහරණයක් ලෙස, සමාන (ඉලක්කම්) ඉන්ඩෙක්ස් වල අංග පමණක් සැකසීමට අවශ්‍ය නම් මෙය ප්‍රයෝජනවත් වේ.

Iteration using an enhanced for loop (for‑each)

උත්සාහිත for ලූප් (for‑each) භාවිතයෙන් පරික‍්‍රමණය

If you want to process all elements sequentially without worrying about the index, the enhanced for loop is convenient.

ඉන්ඩෙක්ස් ගැන සැලකිල්ලක් නොදැරී සියලු අංග අනුක්‍රමයෙන් සැකසීමට අවශ්‍ය නම්, උත්සාහිත for ලූප් එක පහසු වේ.

for (String fruit : fruits) {
    System.out.println(fruit);
}

The syntax is simple and easy to read, making it one of the most commonly used methods. This is sufficient for simple processing.

වක්‍රරීතිය සරල සහ කියවීමට පහසු වන අතර එය නිතරම භාවිතා වන ක්‍රමයන්ගෙන් එකක් වේ. සරල සැකසීම සඳහා මෙය ප්‍රමාණවත් වේ.

Iteration using Lambda Expressions and Stream API

ලැම්බ්ඩා ප්‍රකාශන සහ Stream API භාවිතයෙන් පරික‍්‍රමණය

Since Java 8, you can also use the syntax with Stream API and lambda expressions.

Java 8 සිට, ඔබට Stream API සහ ලැම්බ්ඩා ප්‍රකාශන සමඟ මෙම වක්‍රරීතිය භාවිතා කළ හැක.

fruits.stream().forEach(fruit -> System.out.println(fruit));

The strength of this notation is that multiple processes can be chained together. For example, you can easily filter and then print elements based on specific criteria.

මෙම සංකේතනයේ ශක්තිය වන්නේ බහු ක්‍රියාවලීන් එකට සම්බන්ධ කළ හැකි වීම ය. උදාහරණයක් ලෙස, ඔබට පහසුවෙන් විශේෂිත මාර්ගෝපදේශ අනුව අංග පිරික්සී පසු එම අංග මුද්‍රණය කළ හැක.

fruits.stream()
      .filter(fruit -> fruit.contains("a"))
      .forEach(System.out::println);

In this example, it prints only fruits that contain “a”. This is especially recommended for those who want to get used to functional style coding.

මෙම උදාහරණයේ, “a” අකුර අඩංගු පළතුරු පමණක් මුද්‍රණය කරයි. මෙය කාර්යමය ශෛලියට පුරුදු වීමට කැමති අයට විශේෂයෙන් නිර්දේශ කරයි.

Choosing the Right Method

නිවැරදි ක්‍රමය තෝරා ගැනීම

5. Differences and Usage of ArrayList and LinkedList

5. ArrayList සහ LinkedList අතර වෙනස්කම් සහ භාවිතය

The representative classes that implement Java’s List interface are ArrayList and LinkedList. Both can be used as List in the same way, but they have differences in internal structure and performance characteristics, so it is important to use them appropriately in the right situations.

Java List අතුරුමුහුණත ක්‍රියාත්මක කරන නියෝජිත පන්තීන් ArrayList සහ LinkedList වේ. දෙකම එකම ආකාරයෙන් List ලෙස භාවිතා කළ හැකි නමුත්, අභ්‍යන්තර ව්‍යුහය සහ කාර්ය සාධන ගුණාංග වල වෙනස්කම් ඇති බැවින්, නිසි අවස්ථාවලදී ඒවා සුදුසු ලෙස භාවිතා කිරීම වැදගත් වේ.

Characteristics and Suitable Use Cases of ArrayList

ArrayList හි ලක්ෂණ සහ සුදුසු භාවිතා අවස්ථා

ArrayList internally uses a dynamic array (resizable array).

ArrayList අභ්‍යන්තරයෙන් ඩයිනමික අරේ (ප්‍රමාණය වෙනස් කළ හැකි අරේ) භාවිතා කරයි.

Main Characteristics:

ප්‍රධාන ලක්ෂණ:

• අහඹු ප්‍රවේශය (ඉන්ඩෙක්ස්-අධාරිත) සඳහා ඉතා වේගවත්
• ලැයිස්තුවේ අවසානයේ අංග එකතු කිරීම වේගවත් (සාමාන්‍ය O(1))
• මැද භාගයේ ඇතුළත් කිරීම සහ මකා දැමීම මන්දගාමී (O(n))

සුදුසු අවස්ථා:

• සෙවීම (get()) නිතර සිදුවන අවස්ථා
• අංග ගණන පෙර අනුමාන කළ හැකි අවස්ථා
• අංග එකතු කිරීම/මකා දැමීම අඩු වන, කියවීමට මූලික වූ සැකසීම

  List<String> list = new ArrayList<>();
  

LinkedList හි ලක්ෂණ සහ සුදුසු භාවිතා අවස්ථා

LinkedList ද්වි-සම්බන්ධ ලැයිස්තු ව්‍යුහයක් භාවිතා කරමින් ක්‍රියාත්මක වේ.

ප්‍රධාන ලක්ෂණ:

• අංග එකතු කිරීම සහ මකා දැමීම සඳහා වේගවත් (විශේෂයෙන් ආරම්භයේ හෝ අවසානයේ)
• අහඹු ප්‍රවේශය (get(index)) මන්දගාමී (O(n))
• මතක භාවිතය ArrayList ට වඩා ටිකක් වැඩි

සුදුසු අවස්ථා:

• අංග නිතර ඇතුළත් කිරීම හෝ මකා දැමීම සිදුවන අවස්ථා (විශේෂයෙන් ආරම්භයේ හෝ මැද භාගයේ)
• එය Queue හෝ Stack වැනි භාවිතා කිරීමට අවශ්‍ය වන විට
• පරික්‍රමණය මත අවධානය යොමු කර, ඉන්ඩෙක්ස් ප්‍රවේශය අවශ්‍ය නොවන විට

  List<String> list = new LinkedList<>();
  

කාර්ය සාධන සැසඳීම

පහත වගුව සාමාන්‍යයෙන් භාවිතා වන ක්‍රියාකාරකම් සඳහා සාධාරණ කාල සංකීර්ණතාව (Big O සංකේතය) පෙන්වයි.

• සැබෑ සැකසීමේ කාලය දත්ත ප්‍රමාණය, JVM අනුකූල කිරීම ආදිය මගින්ද බලපෑම් විය හැක.

ප්‍රායෝගික භාවිතයේ වෙනස්කම් සඳහා කරුණු

• දත්ත ලැයිස්තුවක් ලෙස සලකා ඉන්ඩෙක්ස් මගින් ප්‍රවේශ වන්නේ නම්, ArrayList භාවිතා කරන්න
• ආරම්භයේ හෝ මැද භාගයේ ඇතුළත් කිරීම/මකා දැමීම නිතර සිදුවේ නම්, LinkedList භාවිතා කරන්න
• කාර්ය සාධන-සංවේදී සැකසීම සඳහා, සැමවිටම බෙන්ච්මාර්ක් කර තහවුරු කරන්න

6. ලැයිස්තුවේ උසස් භාවිතය

මෙහිදී, Java හි List වඩාත් පහසුවෙන් භාවිතා කිරීමට උසස් තාක්ෂණික ක්‍රම හඳුන්වා දෙමු. List එක සරල දත්ත එකතුවක් ලෙස පමණක් නොව, වර්ගීකරණය, සකල කිරීම, පෙරහන් කිරීම, පරිවර්තනය ආදිය මගින් විවිධ ක්‍රියාකාරකම් සිදු කළ හැක.

ලැයිස්තුව වර්ගීකරණය (Collections.sort)

Collections.sort() භාවිතා කර, ලැයිස්තුවේ අංග ඉහළින් පහළට (ආරෝහණ) වර්ගීකරණය කළ හැක. අංගයන් Comparable අතුරුමුහුණත ක්‍රියාත්මක කළ යුතුය.

import java.util.*;

List<String> fruits = new ArrayList<>();
fruits.add("banana");
fruits.add("apple");
fruits.add("orange");

Collections.sort(fruits);

System.out.println(fruits); // [apple, banana, orange]

අභිරුචි ක්‍රමයකින් වර්ගීකරණය (Comparator භාවිතා කර)

fruits.sort(Comparator.reverseOrder()); // Sorts in descending order

ලැයිස්තුව සකල කිරීම (Collections.shuffle)

අංග අහඹු ලෙස පිළිවෙල වෙනස් කිරීමට, Collections.shuffle() භාවිතා කළ හැක.

Collections.shuffle(fruits);
System.out.println(fruits); // [banana, orange, apple] (example)

මෙය ක්‍රීඩාවක් සඳහා කාඩ්පත් තට්ටුවක් හෝ අහඹු ප්‍රදර්ශන පිළිවෙලක් අවශ්‍ය වන විට ප්‍රයෝජනවත් වේ.

Stream API (filter) භාවිතා කර පෙරහන් කිරීම

Java 8 සිට Stream භාවිතා කර, කොන්දේසියකට ගැළපෙන අංග පමණක් ලබා ගැනීමට කෙටි කේතයක් ලියන්න පුළුවන්.

List<String> filtered = fruits.stream()
    .filter(fruit -> fruit.contains("a"))
    .collect(Collectors.toList());

System.out.println(filtered); // [apple, banana, orange] (depending on original content and filter)

Stream API (map) භාවිතා කර පරිවර්තනය

අංග වෙනත් ආකාරයකට පරිවර්තනය කිරීමට, map() භාවිතා කරන්න.

List<Integer> lengths = fruits.stream()
    .map(String::length)
    .collect(Collectors.toList());

System.out.println(lengths); // Lengths of each fruit name [5, 6, 6] etc.

map() දත්ත ආකාර පරිවර්තනය සහ පෙර සැකසීම සඳහා ශක්තිමත් මෙවලමකි.

උසස් ක්‍රියාකාරකම් සාරාංශය

7. පොදු දෝෂ සහ ඒවාගේ විසඳුම්

Java හි List සමඟ වැඩ කරන විට, අරඹන්නන්ට බොහෝ විට “අපවාද (දෝෂ)” මත වැටෙයි. මෙහිදී, නිතර සිදුවන නියෝජිත දෝෂ, ඒවායේ හේතු, සහ ඒවා විසඳා ගැනීම පිළිබඳ විස්තර කරමු.

IndexOutOfBoundsException

හේතුව:

නොමැති ඉන්ඩෙක්ස් එකක් ප්‍රවේශ කිරීමට උත්සාහ කරන විට සිදුවේ.

List<String> list = new ArrayList<>();
list.add("apple");

System.out.println(list.get(1)); // Error: Index 1 out of bounds

විසඳුම:

ප්‍රවේශ වීමට පෙර ප්‍රමාණය පරීක්ෂා කරන්න හෝ කොන්ඩිෂනල් බ්‍රැන්චිං භාවිතා කරමින් සුරකිනුදාම්කරණය කරන්න ඉන්ඩෙක්ස් වලංගු බව සහතික කිරීමට.

if (list.size() > 1) {
    System.out.println(list.get(1));
}

NullPointerException

හේතුව:

List හෝ List අංගයක් null වන විට එහි ක්‍රමයක් කැඳවීමෙන් ඇති වේ.

List<String> list = null;
list.add("apple"); // NullPointerException occurs

විසඳුම:

විචල්‍යය null නොවන බව පෙර පරීක්ෂා කරන්න, හෝ Optional ආදිය භාවිතා කරන්න.

if (list != null) {
    list.add("apple");
}

අමතක නොකර ආරම්භකරණය කිරීම ගැනද සැලකිලිමත් වන්න:

List<String> list = new ArrayList<>(); // Correct initialization

ConcurrentModificationException

හේතුව:

for-each ලූපයක් හෝ Iterator භාවිතා කරමින් List එක තුළින් ඉටරේට් කිරීමේදී List එක සෘජුව වෙනස් කිරීමෙන් ඇති වේ.

for (String fruit : list) {
    if (fruit.equals("banana")) {
        list.remove(fruit); // ConcurrentModificationException
    }
}

විසඳුම:

අංග ආරක්ෂිතව ඉවත් කිරීමට Iterator භාවිතා කරන්න, හෝ removeIf() වැනි ක්‍රම භාවිතා කරන්න.

Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if (it.next().equals("banana")) {
        it.remove(); // Safe removal
    }
}

හෝ, Java 8 සිට වඩා සංක්ෂිප්තව:

list.removeIf(fruit -> fruit.equals("banana"));

අනෙකුත් සැලකිලිමත් විය යුතු කරුණු

• List null නොවන බව පරීක්ෂා කිරීම
• විචල්‍යයක් ප්‍රකාශ කිරීම නමුත් භාවිතා නොකිරීම ඉතා සුලබයි. ආරම්භකරණය අත්‍යවශ්‍යයි.
• ඉන්ඩෙක්ස් 0 සිට ආරම්භ වන බව තේරුම් ගැනීම
• ආරම්භකයින් බොහෝ විට “පළමු අංගය ඉන්ඩෙක්ස් 1” යනුවෙන් වැරදිව සිතති.

දෝෂ වැළැක්වීම් සාරාංශය

8. නිගමනය

Java List හි මූලික දේ පුනරාවර්තනය

මෙම ලිපියෙහි, Java හි List හි මූලික සිට උසස් අංශ දක්වා පියවරෙන් පියවර පැහැදිලි කිරීම් කර ඇත. List Java collections අතර විශේෂයෙන්ම භාවිතා වන අතර දත්ත නම්‍යශීලීව කළමනාකරණය කිරීමට වැදගත් මෙවලමකි.

පළමුව, List යනු කුමක්ද යන්න තේරුම් ගැනීමෙන් පසු, අපි පහත කරුණු ඉගෙන ගත්තෙහි:

• List යනු නිළධාරී එකතුවකි duplicates ඉඩදීමට සහ ඉන්ඩෙක්ස් මෙහෙයුම් සඳහා සහාය දක්වයි
• ArrayList සහ LinkedList වැනි නියෝජිත ක්‍රියාත්මක කිරීම් පන්ති ඇති අතර, ඒවායේ විශේෂ ලක්ෂණ සහ භාවිතයන් වෙනස් වේ
• මූලික මෙහෙයුම් (add, get, update, remove, search) ප්‍රවේශය දක්වා ගැනීමෙන් නම්‍යශී දත්ත කළමනාකරණයට හැකිය
• අනුපාතයට ගැලපෙන ඉටරේටිව් සැකසුම් , ලූප්, enhanced for loops, සහ Stream API වැනි
• වර්ගීකරණය, සමනය, සහ පරිවර්තනය වැනි උසස් මෙහෙයුම් සඳහා සහාය
• සුලබ දෝෂ, ඒවායේ හේතු, සහ විසඳුම් තේරුම් ගැනීමෙන් ගැටලු වැළැක්වීමට උපකාරී වේ

ArrayList සහ LinkedList භාවිතය අතර වෙනස්කම්

කුමන List ක්‍රියාත්මක කිරීම භාවිතා කළ යුදා යන්න තෝරා ගැනීම වැදගත් වන අතර එය සැකසුම් අන්තර්ගතය සහ දත්ත ප්‍රමාණය මත පදනම් විය යුතුය. පහත මාර්ගෝපදේශය මග පෙන්වන්න:

• ArrayList : නිතර random access, ප්‍රධාන වශයෙන් කියවීම
• LinkedList : නිතර ඇතුළත් කිරීම/ඉවත් කිරීම, ප්‍රවේශ ක්‍රමය වැදගත්

අනාගත ඉගෙනීම් කෙරෙහි

List යනු Java හි collections හි “ප්‍රවේශ දොරටුව” පමණි. වඩා උසස් දත්ත ව්‍යුහයන් සහ උපකාරීතා කළමනාකරණය කිරීමට, පහත පන්ති සහ ලක්ෂණ පිළිබඳ තේරුම්ගැනීම ගැඹුරු කිරීම නිර්දේශ කෙරේ:

• Set සහ Map : අනන්‍ය අංග කළමනාකරණය, key-value pair ව්‍යුහය
• Collections utility class : වර්ගීකරණය, min/max සෙවීම, ආදිය.
• Stream API භාවිතය : functional programming හඳුන්වා දීම
• Generics තේරුම් ගැනීම : Type-safe collection මෙහෙයුම්

List හි මූලික දේ ප්‍රවේශය දක්වා ගැනීමෙන් ඔබගේ සමස්ත Java ප්‍රොග්‍රෑමිං සැලකිය යුතු ලෙස කළමනාකරණය කිරීමට පහසු වේ.

සුලබ අසන ප්‍රශ්න (FAQ)

Java හි List සම්බන්ධයෙන් ආරම්භකයින් බොහෝ විට ප්‍රශ්න කරන කරුණු එකතු කර ඇත. ප්‍රායෝගිකව නිතර හමුවන අන්තර්ගතය තෝරා ගෙන ඇත.

Q1. Java හි List සහ Array අතර වෙනස කුමක්ද?

A. Array එකක ස්ථිර සංඛ්‍යාවක අංග ඇති අතර එහි ප්‍රමාණය ප්‍රකාශනයේදී තීරණය කළ යුතුය. එහි වෙනත් පැත්ත, List එකක විචල්‍ය ප්‍රමාණයක් ඇත, අංග එකතු කිරීම සහ මකා දැමීම සඳහා නම්‍යශීලී ඉඩක් ලබා දෙයි. තවද, List එක සමඟ බොහෝ පහසු ක්‍රම ඇත (add, remove, contains, ආදිය) සහ කියවීමේ හැකියාව සහ නඩත්තු කිරීමේ හැකියාව අනුව උත්තරීතරය.

Q2. මට ArrayList හෝ LinkedList භාවිතා කළ යුතුද?

A. ArrayList එක ප්‍රධාන වශයෙන් අනුපිට index මගින් සෙවීම (random access) නිතර සිදු වන විට සුදුසුය. LinkedList එක අංග ඇතුළත් කිරීම සහ මකා දැමීම නිතර සිදු වන විට සුදුසුය. සැකයක් ඇත්නම්, ArrayList එක සමඟ ආරම්භ කිරීම සාමාන්‍යයෙන් යෝජනා කෙරේ.

Q3. මට List එකක primitive types (උදා: int හෝ double) ගබඩා කළ හැකිද?

A. සෘජුවම නොවේ. Java හි List එක object types පමණක් කළමනාකරණය කරන බැවින්, int වැනි primitive types සඳහා ඒවායේ සම්බන්ධ wrapper classes (Integer, Double, ආදිය) භාවිතා කළ යුතුය.

List<Integer> numbers = new ArrayList<>();
numbers.add(10); // Auto-boxed and stored as Integer type

Q4. List එකක අංග වර්ගීකරණය කරන්නේ කෙසේද?

A. Collections.sort(list) භාවිතයෙන් ascending order එකක වර්ගීකරණය කළ හැකිය. තවද, custom order එකක වර්ගීකරණය කිරීමට අවශ්‍ය නම්, නම්‍යශීලී වර්ගීකරණය සඳහා Comparator එකක් විශේෂ කළ හැකිය.

Q5. මට duplicates නොමැතිව අංග කළමනාකරණය කිරීමට අවශ්‍ය නම් මොනවද කළ යුතු?

A. List එක duplicates ඉඩදීමක් ඇති collection එකකි. Duplicates වළක්වා ගැනීමට අවශ්‍ය නම්, Set එකක් (උදා: HashSet) භාවිතා කිරීම සලකා බලන්න. නමුත්, order එක සහතික කර නැත. List එකක් ලෙස තබා ගනිමින් duplicates ඉවත් කිරීමට අවශ්‍ය නම්, පහත Stream processing ද කළ හැකිය:

List<String> distinctList = list.stream()
    .distinct()
    .collect(Collectors.toList());

Q6. List එකකින් සියලුම අංග clear කිරීමට මොනවද කළ යුතු?

A. List එකකින් සියලුම අංග ඉවත් කිරීමට clear() method එක භාවිතා කළ හැකිය.

list.clear();

Q7. List එකේ වඩාත් නිතර භාවිතා වන operations මොනවාද?

A. ප්‍රායෝගිකව වඩාත් නිතර භාවිතා වන operations වන්නේ add (එකතු කිරීම), get (සෙවීම), remove (ඉවත් කිරීම), සහ size (ප්‍රමාණය ලබා ගැනීම) ය. මේවා ප්‍රායෝගිකව බොහෝ මූලික processing ආවරණය කරයි.