List — ArrayList আর LinkedList, বাড়তে পারা তালিকার ভেতর-বাহির

১ · সমস্যা — array-এর মাপ আগে থেকে জানতে হয়

পর্ব ১৩-এ array দেখেছেন: new int[5] লিখলে ঠিক পাঁচটি ঘর, তার বেশি নয়, কমও নয়। পর্ব ২২-এর “হিসাব খাতা”-য় এই সীমাবদ্ধতার সাথে সরাসরি লড়তে হয়েছিল। সেখানে একটি বড় array রাখা হয়েছিল, সাথে একটি count — কয়টি ঘর আসলে ভরা। খাতা ভরে গেলে add শুধু false ফেরত দিত। কম ঘর ধরলে খাতা দ্রুত ভরে, বেশি ধরলে মেমরি নষ্ট। আর মাঝের একটি খরচ মুছতে চাইলে বাকি সবাইকে হাতে এক ঘর করে সরাতে হতো।

বাস্তবের বেশিরভাগ তালিকার মাপ আগে থেকে জানা থাকে না। একটি অনলাইন দোকানের shopping cart-এ গ্রাহক কয়টি জিনিস রাখবেন? আজ ক্লাসে কয়জন উপস্থিত? একটি bKash অ্যাকাউন্টে আজ কয়টি লেনদেন হবে? দরকার এমন একটি তালিকা, যা:

• ক্রম মনে রাখে — যে ক্রমে ঢুকিয়েছেন, সেই ক্রমেই থাকে;
• index দিয়ে পৌঁছানো যায় — array-এর মতোই ০ থেকে গোনা;
• দরকার মতো বাড়ে-কমে — যোগ করলে বড় হয়, বাদ দিলে ছোট হয়, বাকিদের সরানোর কাজ নিজেই করে।

Java-তে এমন তালিকার নাম List. আর সবচেয়ে বেশি ব্যবহৃত List হলো ArrayList — মজার ব্যাপার, ভেতরে সে ঠিক আপনার হিসাব খাতার মতোই একটি array আর একটি count রাখে। পার্থক্য একটাই: ভরে গেলে সে নিজেই একটি বড় array বানিয়ে নেয়। এমন নিজে বড় হওয়া array-কে বলে dynamic array.

২ · Collections Framework-এর মানচিত্র — interface এক, implementation অনেক

List একা নয়। Java-র java.util প্যাকেজে ডেটা রাখার একটি পুরো পরিবার আছে, যাকে বলে Collections Framework. পরের কয়েকটি পর্ব এই পরিবারের সদস্যদের নিয়েই। আগে মানচিত্রটা দেখে নিন:

          Iterable<E>
              │
         Collection<E>
     ┌────────┼─────────┐
  List<E>   Set<E>   Queue<E>
     │        │         │
 ArrayList  HashSet  ArrayDeque
 LinkedList TreeSet  PriorityQueue
              (LinkedList-ও Deque)

   Map<K,V>   ← আলাদা, Collection নয়
 HashMap  TreeMap  LinkedHashMap

সবার চূড়ায় Iterable — যে জিনিসের ওপর for-each লুপ চালানো যায় (পর্ব ১১)। তার নিচে Collection: যেকোনো “অনেকগুলো জিনিসের দল”, যাতে add, remove, contains, size, isEmpty আছে। Collection থেকে তিনটি শাখা:

আর Map — key দিয়ে মান খোঁজা (রোল → নাম) — ইচ্ছা করেই Collection-এর বাইরে, কারণ তার প্রতিটি উপাদান একটি জোড়া, একক জিনিস নয়। এর কাহিনি পর্ব ৩১-এ।

বাঁয়ে interface, ডানে implementation

এই নকশার সবচেয়ে বড় শিক্ষা হলো কী করা যায় (interface) আর কীভাবে করা হয় (implementation) আলাদা। তাই List তৈরির প্রচলিত লেখা:

List<String> names = new ArrayList<>();     // ভ্যারিয়েবলের টাইপ: interface
List<String> queue = new LinkedList<>();    // একই interface, অন্য implementation

বাঁ দিকে List, ডান দিকে ArrayList. পর্ব ২১-এর program to an interface নীতি এখানে সবচেয়ে বেশি কাজে লাগে। আপনার বাকি কোড শুধু List-এর method ডাকে, তাই কাল যদি মাপজোখ করে দেখেন অন্য implementation ভালো, শুধু ডান দিকের একটি শব্দ বদলালেই চলবে। Method-এর parameter আর return টাইপেও একই নিয়ম: double average(List<Integer> marks) লিখুন, ArrayList<Integer> নয় — তাহলে যে ডাকে, সে যেকোনো List দিতে পারে, List.of(...)-ও। কৌণিক বন্ধনীর <String> হলো পর্ব ২৮-এর generics — তালিকায় শুধু String ঢুকবে, compiler তা পাহারা দেবে।

৩ · মূল কাজগুলো — আর একটি বিখ্যাত ফাঁদ

List-এর method অনেক, কিন্তু প্রতিদিনের কাজ চলে দশটির মতো দিয়ে:

শেষ সারিটি নতুন। Java 21-এ SequencedCollection নামে একটি interface যোগ হয়েছে (JEP 431), যাতে list.get(list.size() - 1)-এর মতো বিরক্তিকর লেখার বদলে সরাসরি list.getLast() লেখা যায়। পুরোনো বই বা টিউটোরিয়ালে এগুলো পাবেন না।

contains, indexOf আর remove(Object) “সমান” বোঝে equals() দিয়ে, == দিয়ে নয়। তাই String বা Integer-এর তালিকায় এরা ঠিকঠাক কাজ করে। কিন্তু আপনার নিজের class-এ যদি পর্ব ২৩-এর মতো equals override না করেন, তাহলে হুবহু একই তথ্যের দুটি object-ও “আলাদা” — contains মিথ্যা বলবে। record-এ equals নিজে থেকেই তৈরি হয়, তাই এই সমস্যা নেই।

এবার একটি ছোট মুদি দোকানের shopping cart, আর শেষে রোল নম্বরের তালিকায় সেই বিখ্যাত ফাঁদ। চালিয়ে দেখুন:

import java.util.*;
class Main {
    public static void main(String[] args) {
        List<String> cart = new ArrayList<>();
        cart.add("চাল");
        cart.add("ডাল");
        cart.add("তেল");
        cart.add(1, "লবণ");                  // index 1-এ ঢোকানো
        System.out.println(cart + " size=" + cart.size());
        cart.set(3, "সয়াবিন তেল");           // index 3-এর জিনিস বদল
        cart.remove("ডাল");                  // মান ধরে বাদ
        System.out.println(cart.get(0) + ", " + cart.indexOf("সয়াবিন তেল") + ", " + cart.contains("ডাল"));
        System.out.println(String.join(" | ", cart));
        List<Integer> rolls = new ArrayList<>(List.of(3, 7, 1));
        rolls.remove(1);                     // index 1 — মান 1 নয়!
        System.out.println(rolls);
        rolls.remove(Integer.valueOf(1));    // এবার মান 1
        System.out.println(rolls + " " + rolls.isEmpty());
    }
}

ভুল index দিলে List array-এর মতোই সঙ্গে সঙ্গে থামে। [3, 7, 1]-এ rolls.get(5) ডাকলে বার্তা হয় java.lang.IndexOutOfBoundsException: Index 5 out of bounds for length 3 — এটা IndexOutOfBoundsException, array-এর ArrayIndexOutOfBoundsException-এর বড় ভাই।

৪ · ArrayList-এর ভেতরে — capacity, size আর দেড় গুণ বৃদ্ধি

OpenJDK-র ArrayList-এর source খুললে দুটি মূল field পাবেন: Object[] elementData আর int size. অর্থাৎ পর্ব ২২-এর items আর count. এখানে দুটি শব্দ আলাদা করে বোঝা জরুরি:

• size — তালিকায় আসলে কয়টি জিনিস আছে। size() এটাই ফেরত দেয়।
• capacity — ভেতরের array-তে মোট কয়টি ঘর আছে, ভরা হোক বা খালি। এটা দেখার কোনো public method নেই; এটা ArrayList-এর গোপন ব্যাপার।

Size যতক্ষণ capacity-র কম, শেষে যোগ মানে শুধু elementData[size++] = x — একটি লেখা। ভরে গেলে কী হয়, ধাপে ধাপে দেখুন:

1List<String> cart = new ArrayList<>();2cart.add("চাল");3// আরও ৯টি add — মোট ১০4cart.add("চিনি");    // ১১তম5// ভেতরে: grow() → নতুন array6// ১৬তম, ২৩তম add-এ আবার

ধাপ ৬-এর হিসাবকে বলে amortized analysis: কোনো একটি add মাঝে মাঝে ব্যয়বহুল (কপির সময়), কিন্তু অনেকগুলো add-এর মোট খরচ ভাগ করলে প্রতিটির ভাগে ধ্রুব খরচ। তাই বলা হয়, ArrayList-এর শেষে যোগ amortized O(1). এখানে O(1), O(n) লেখার রীতিটিকে বলে Big-O notation: n (তালিকার আকার) বাড়লে কাজের সময় কোন হারে বাড়ে। O(1) মানে তালিকা দশটির হোক বা দশ লাখের, প্রায় একই সময়; O(n) মানে আকারের সমানুপাতে।

শেষে যোগ সস্তা, শুরুতে ঢোকানো দামি

Array পাশাপাশি ঘরে বসে (contiguous memory), তাই get(i) একটি গুণ আর একটি যোগে ঠিকানা পায় — O(1). কিন্তু এই পাশাপাশি থাকারই দাম আছে। add(0, x) করতে হলে আগে বাকি সবাইকে এক ঘর ডানে সরিয়ে প্রথম ঘর খালি করতে হয় (ভেতরে একটি System.arraycopy). দশ লাখ জিনিসের তালিকায় প্রতিবার দশ লাখ সরানো — O(n). একইভাবে remove(0) সবাইকে এক ঘর বাঁয়ে টানে। মাঝখানে ঢোকানো বা বাদেও গড়ে অর্ধেক জিনিস সরে। এখানেই LinkedList-এর গল্প শুরু।

৫ · LinkedList — node-এর শিকল, আর কেন বাস্তবে সে হারে

LinkedList কোনো array রাখে না। প্রতিটি জিনিস থাকে একটি আলাদা ছোট object-এ, যাকে বলে node. প্রতিটি node-এর ভেতরে তিনটি জিনিস: আগের node-এর reference (prev), নিজের মান (item) আর পরের node-এর reference (next). দুই দিকেই হাঁটা যায় বলে এর নাম doubly linked list. তালিকা নিজে শুধু মনে রাখে প্রথম আর শেষ node (first, last) আর size. ধাপে ধাপে দেখুন, শুরুতে একটি জিনিস ঢোকাতে দুটির খরচ কেমন:

index:  0   1   2   3   4
       [B] [C] [D] [E] [ ]
size 4, capacity 5 — ঘর ০ খালি করতে হবে

       [B] [C] [D] [ ] [E]
       [B] [C] [ ] [D] [E]
       [B] [ ] [C] [D] [E]
       [ ] [B] [C] [D] [E]
৪টি সরানো = size — O(n)

       [A] [B] [C] [D] [E]
১০ লাখ জিনিস থাকলে প্রতিবার ১০ লাখ সরানো

first                 last
  ↓                     ↓
 [B] ⇄ [C] ⇄ [D] ⇄ [E]
প্রতিটি [ ] আলাদা Node object:
prev | item | next

new Node [A]
A.next = B;  B.prev = A;  first = A;
 [A] ⇄ [B] ⇄ [C] ⇄ [D] ⇄ [E]
কেউ সরেনি — কয়েকটি reference বদল, O(1)

ArrayList : শুরু + 3 × ঘরের মাপ → এক লাফে
LinkedList: first → A → B → C → D
index ধরে পৌঁছাতে হাঁটতেই হয় — O(n)
(কাছের প্রান্ত থেকে হাঁটে: শুরু বা শেষ)

Big-O টেবিল — পাশাপাশি

টেবিল দেখে মনে হতে পারে, শুরুতে বা মাঝে বেশি ঢোকানো-বাদ থাকলে LinkedList নিশ্চয়ই জিতবে। বাস্তবের মাপজোখে প্রায়ই উল্টোটা দেখা যায়, আর তার কারণ Big-O-তে লেখা থাকে না: cache locality. আধুনিক CPU মূল মেমরি থেকে একটি একটি byte আনে না; পাশাপাশি একটি পুরো খণ্ড একবারে তার খুব দ্রুত cache-এ তুলে আনে। ArrayList-এর reference-গুলো পাশাপাশি, তাই একটি পড়লেই পরের কয়েকটি বিনা খরচে হাতে চলে আসে, আর System.arraycopy-ও একটানা মেমরি সরাতে অত্যন্ত দক্ষ। LinkedList-এর প্রতিটি node heap-এর আলাদা জায়গায় — প্রতিটি next ধরে লাফ মানে সম্ভবত আরেকবার ধীর মূল মেমরিতে যাওয়া। ফলে “O(n) সরানো” প্রায়ই “O(n) হাঁটা”-র চেয়ে অনেক দ্রুত। বাড়তি Node object garbage collector-এর কাজও বাড়ায়।

৬ · ঘুরে দেখা — আর ঘোরার মধ্যে বাদ দিলে যা ভাঙে

একটি তালিকার প্রতিটি জিনিস দেখার চারটি উপায় আছে:

for (String item : cart) System.out.println(item);           // ১. for-each — সবচেয়ে প্রচলিত

for (int i = 0; i < cart.size(); i++)                        // ২. index লুপ — index-ও দরকার হলে
    System.out.println((i + 1) + ". " + cart.get(i));

Iterator<String> it = cart.iterator();                       // ৩. Iterator — ঘুরতে ঘুরতে বাদ দিতে
while (it.hasNext()) System.out.println(it.next());

cart.forEach(item -> System.out.println(item));              // ৪. forEach + lambda (পর্ব ৩৪)

প্রথমটি আসলে তৃতীয়টির ছদ্মবেশ। Compiler for (String item : cart)-কে বদলে লেখে একটি Iterator দিয়ে: hasNext() জিজ্ঞেস করে আর কিছু আছে কি না, next() পরেরটি দেয়। চতুর্থটিতে item -> ... হলো একটি lambda — “প্রতিটি item নিয়ে এই কাজ করো”; পর্ব ৩৪-এ বিস্তারিত। LinkedList-এ index লুপ (উপায় ২) সাবধানে: প্রতিটি get(i) নিজেই O(n), তাই পুরো লুপ O(n²) — দশ হাজার জিনিসে পাঁচ কোটির মতো ধাপ। for-each বা iterator সব List-এ O(n).

ফেল করা ছাত্রদের বাদ দেওয়া — সবচেয়ে স্বাভাবিক ভুল

একটি পরীক্ষার নম্বরের তালিকা, যেখান থেকে ৩৩-এর কম পাওয়া নম্বরগুলো বাদ দিতে হবে। সবচেয়ে স্বাভাবিক কোড:

import java.util.*;
class Main {
    public static void main(String[] args) {
        List<Integer> marks = new ArrayList<>(List.of(72, 28, 35, 90));
        for (Integer m : marks) {                 // লাইন ৫
            if (m < 33) marks.remove(m);          // ফেল করা বাদ
        }
        System.out.println(marks);
    }
}

Exception in thread "main" java.util.ConcurrentModificationException
	at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1095)
	at java.base/java.util.ArrayList$Itr.next(ArrayList.java:1049)
	at Main.main(Main.java:5)

Stack trace নিচ থেকে পড়ুন: আপনার লাইন ৫ (for-each-এর মাথা) ডেকেছে ArrayList$Itr.next — সেই লুকানো iterator — আর সে ডেকেছে checkForComodification, যে exception ছুড়েছে। আপনার লাইন ৬-এর remove নিজে ঠিকঠাক কাজ করেছে; সমস্যা ধরা পড়েছে পরের ঘুরে। ভেতরে ঠিক কী ঘটল, দেখুন:

1List<Integer> marks = ...(72, 28, 35, 90);2for (Integer m : marks) {  // লুকানো it3    if (m < 33) marks.remove(m);4}5// ঠিক পথ: it.remove() বা removeIf

নিরাপদ দুটি পথ এক প্রোগ্রামে — record দিয়ে ছাত্রের তালিকা থেকে Iterator-এ বাদ, নম্বরের তালিকা থেকে removeIf দিয়ে বাদ, তারপর একটু পরের অংশের পূর্বাভাস:

import java.util.*;
record Student(String name, int marks) { }
class Main {
    public static void main(String[] args) {
        List<Student> cls = new ArrayList<>(List.of(new Student("Rahim", 72),
            new Student("Karim", 28), new Student("Ayesha", 30), new Student("Mitu", 90)));
        Iterator<Student> it = cls.iterator();
        while (it.hasNext())
            if (it.next().marks() < 33) it.remove();   // নিরাপদ পথ ১
        System.out.println(cls);
        List<Integer> marks = new ArrayList<>(List.of(72, 28, 30, 90, 15));
        marks.removeIf(m -> m < 33);                    // নিরাপদ পথ ২
        List<Integer> view = Collections.unmodifiableList(marks);
        List<Integer> copy = List.copyOf(marks);
        marks.add(55);
        System.out.println(marks + " " + view + " " + copy);
        marks.sort(null);
        System.out.println(marks + " max=" + Collections.max(marks));
    }
}

৭ · অপরিবর্তনীয় তালিকা আর view — কে কপি, কে জানালা

সব তালিকা বদলানোর জন্য নয়। সপ্তাহের দিনের নাম, একটি পরীক্ষার বিষয়ের তালিকা, বা কোনো method-এর ফেরত দেওয়া ফল — এগুলো বাইরের কেউ বদলালে bug. Java-তে এমন তালিকা বানানোর কয়েকটি উপায় আছে, আর এদের পার্থক্য সূক্ষ্ম কিন্তু গুরুত্বপূর্ণ।

List.of — সত্যিকারের অপরিবর্তনীয়

import java.util.*;
class Main {
    public static void main(String[] args) {
        List<String> days = List.of("শনি", "রবি", "সোম");
        System.out.println(days.get(1));
        days.add("মঙ্গল");                   // লাইন ৬
    }
}

রবি
Exception in thread "main" java.lang.UnsupportedOperationException
	at java.base/java.util.ImmutableCollections.uoe(ImmutableCollections.java:142)
	at java.base/java.util.ImmutableCollections$AbstractImmutableCollection.add(ImmutableCollections.java:147)
	at Main.main(Main.java:6)

Java 9 থেকে আসা List.of(...) একটি unmodifiable collection দেয়: পড়া চলে, কিন্তু add, remove, set, clear — যেকোনো বদলে UnsupportedOperationException. লক্ষ করুন, এটা compile-এর সময় ধরা পড়ে না; List interface-এ add আছে, তাই compiler আপত্তি করে না — ভুল ধরা পড়ে চলার সময়। আরেকটি নিয়ম: List.of কোনো null নেয় না। List.of("a", null) তৈরির সময়েই NullPointerException দেয়, আর এমনকি days.contains(null) জিজ্ঞেস করলেও NullPointerException. (সাধারণ ArrayList-এ null রাখা যায়: [null], size ১।)

View — নিজের কপি নেই, মূলটার জানালা

কিছু method নতুন তালিকা বানায় না; বিদ্যমান ডেটার ওপর একটি নতুন “চেহারা” দেয়। একে বলে collection view. View-এর ভেতরে নিজের কোনো জিনিস নেই — সে শুধু মূলটার দিকে তাকিয়ে আছে। মূলটা বদলালে view-তে সেই বদল দেখা যায়; কোনো কোনো view দিয়ে মূলটা বদলানোও যায়। চারটি পরিচিত উদাহরণ ধাপে ধাপে:

String[] arr = {"চাল", "ডাল"};
List<String> cart = Arrays.asList(arr);

arr  ──▶ [চাল][ডাল] ◀── cart
একটিই array — cart শুধু তাকে List হিসেবে দেখায়

cart.set(0, "আটা");
System.out.println(arr[0]);   → আটা
set চলে, আর array-ও বদলে যায়

cart.add("তেল");
UnsupportedOperationException
array-এর মাপ স্থির, তাই add/remove নিষেধ
বদলাতে চাইলে: new ArrayList<>(Arrays.asList(arr))

marks = [72, 90]
view = Collections.unmodifiableList(marks);
copy = List.copyOf(marks);
marks.add(55);
view → [72, 90, 55]   জানালা — বদল দেখে
copy → [72, 90]       কপি — আলাদা

আটা
Exception in thread "main" java.lang.UnsupportedOperationException
	at java.base/java.util.AbstractList.add(AbstractList.java:155)
	at java.base/java.util.AbstractList.add(AbstractList.java:113)
	at Main.main(Main.java:8)

ওপরের trace এসেছে ধাপ ১–৩-এর কোড পুরো প্রোগ্রাম হিসেবে চালিয়ে (লাইন ৮-এ cart.add("তেল"))। লক্ষ করুন, এবার exception আসছে AbstractList.add থেকে — Arrays.asList-এর তালিকা add-কে override-ই করেনি, তাই মূল class-এর “আমি পারি না” সংস্করণটা চলেছে।

subList — তালিকার একটি টুকরোর জানালা

list.subList(from, to) index from থেকে to-এর আগ পর্যন্ত অংশের একটি view দেয়। কপি নয়, তাই খুব কাজের কৌশল চলে: [1, 2, 3, 4, 5, 6]-এ s.subList(1, 4).clear() মাঝের তিনটি মুছে মূল তালিকাকে করে [1, 5, 6]. কিন্তু উল্টো দিকে সাবধান: subList বানানোর পর মূল তালিকায় add বা remove করলে, পরে subList ছুঁতে গেলেই ConcurrentModificationException — একই modCount পাহারা। subList দীর্ঘদিন রেখে দেবেন না; দরকার হলে new ArrayList<>(list.subList(a, b)) দিয়ে কপি করুন।

Array ↔ List রূপান্তর

• Array থেকে বদলানো যায় এমন List: new ArrayList<>(Arrays.asList(arr)). শুধু পড়ার জন্য: List.of(arr) (কপি) বা Arrays.asList(arr) (view).
• List থেকে array: String[] back = list.toArray(new String[0]); — ঠিক টাইপের নতুন array. শুধু toArray() দিলে আসে Object[].
• Primitive array-এর ফাঁদ: int[] a = {1, 2, 3};-এ Arrays.asList(a) তিন জিনিসের তালিকা দেয় না — দেয় List<int[]>, size ১! Generics-এ int চলে না, তাই পুরো array-টাই একটি জিনিস হিসেবে ঢোকে। int[] থেকে List<Integer> বানাতে Stream লাগে (পর্ব ৩৫) বা একটি সাধারণ লুপ।

৮ · সাজানো, Collections-এর কাজের method আর হিসাব খাতার নতুন রূপ

সাজানো — একটি পূর্বাভাস

দুটি সমান উপায়: list.sort(null) আর Collections.sort(list). null মানে “আলাদা কোনো নিয়ম নেই, জিনিসের নিজের স্বাভাবিক ক্রম” — সংখ্যা ছোট থেকে বড়, String বর্ণানুক্রমে (পর্ব ২৩-এর compareTo, যাকে বলে natural ordering). ["Mitu", "Rahim", "Ayesha"] সাজালে [Ayesha, Mitu, Rahim]; Collections.sort(names, Collections.reverseOrder()) দিলে উল্টো: [Rahim, Mitu, Ayesha]. নিজের নিয়মে — GPA অনুযায়ী, তারপর নাম অনুযায়ী — সাজাতে লাগে Comparator, যার পুরো গল্প পর্ব ৩৩-এ। List.of-এর তালিকা সাজাতে গেলে আবার UnsupportedOperationException — সাজানোও একটি বদল।

java.util.Collections — কাজের method-এর বাক্স

নামের শেষে “s” — Collections class আর Collection interface এক জিনিস নয়। পর্ব ১৩-এর Arrays-এর মতো, এটি static method-এ ভরা একটি utility class. সবচেয়ে কাজের কয়েকটি (সব আউটপুট যাচাই করা):

shuffle-এর ক্রম Random-এর বাস্তবায়নের ওপর নির্ভর করে; seed ছাড়া চালালে প্রতিবার আলাদা ফল আসবে, আর সেটাই স্বাভাবিক।

List<int> নেই — আর boxing-এর দাম

পর্ব ২৮-এ দেখেছেন, type argument শুধু reference টাইপ হতে পারে। চেষ্টা করলে:

Main.java:4: error: unexpected type
        List<int> marks = new ArrayList<>();
             ^
  required: reference
  found:    int
1 error

তাই List<Integer>, আর marks.add(72)-এ autoboxing নিজে থেকে Integer object বানায়। এর মানে, ArrayList-এর ভেতরের array-তে সংখ্যা নয়, reference থাকে — প্রতিটি reference heap-এর আলাদা একটি Integer object দেখায়। int[]-এর তুলনায় মেমরি কয়েক গুণ, আর প্রতিটি পড়ায় একটি বাড়তি লাফ (আবার সেই cache locality). কয়েকশো বা কয়েক হাজার নম্বরে এটা কোনো ব্যাপার নয়; কয়েক কোটি সংখ্যার হিসাবে int[] বা IntStream ভাবুন। আর Integer-এর মান তুলনায় == নয়, equals — পর্ব ০৬-এর Integer cache-এর ফাঁদ মনে রাখুন।

হিসাব খাতা — array থেকে ArrayList

পর্ব ২২-এর ExpenseBook-এর ভেতরটা এবার বদলে দেখুন। বাইরের কেউ (কমান্ড class, main loop) কিছুই টের পাবে না, কারণ array আর count দুটিই private ছিল:

class ExpenseBook {
    private final List<Expense> items = new ArrayList<>();   // capacity-র চিন্তা শেষ

    boolean add(Expense e) { return items.add(e); }           // আর কখনো "ভরা" নয়
    Expense removeLast() { return items.isEmpty() ? null : items.removeLast(); }
    int size() { return items.size(); }
    Expense get(int i) { return items.get(i); }
    List<Expense> all() { return Collections.unmodifiableList(items); }  // বাইরে শুধু পড়া
    int total(String cat) {
        int sum = 0;
        for (Expense e : items)
            if (cat == null || e.category().equals(cat)) sum += e.amount();
        return sum;
    }
}

তিনটি জিনিস লক্ষ করুন। প্রথমত, count ভ্যারিয়েবল আর “খাতা ভরা” পরীক্ষা পুরো উধাও — ArrayList নিজের size নিজে রাখে। দ্বিতীয়ত, Java 21-এর removeLast() সরাসরি ব্যবহার হয়েছে; পুরোনো items[count] = null লিখে garbage-এর জন্য reference মুছে দেওয়ার কাজটাও ArrayList নিজে করে। তৃতীয়ত, নতুন all() method ভেতরের তালিকা সরাসরি ফেরত দেয় না — দেয় একটি পড়ার-অনুমতিওয়ালা view. ভেতরের items ফেরত দিলে যে কেউ book.all().clear() লিখে পুরো খাতা মুছে ফেলতে পারত, আর encapsulation-এর সব পরিশ্রম জলে যেত। সম্পূর্ণ আলাদা স্থির ছবি চাইলে List.copyOf(items) — পর্ব ১৭-এর defensive copy.

৯ · AI-এর যুগে — তালিকার কোড রিভিউ করতে শিখুন

তালিকার কোড AI খুব দ্রুত লিখে দেয়, আর বেশিরভাগ সময় তা চলেও। সমস্যা হলো, এই পর্বের প্রতিটি ফাঁদ এমন যে কোড compile হয় এবং ছোট টেস্টে ঠিকঠাক চলে — ভুল ধরা পড়ে বড় ডেটায়, বা বিশেষ একটি ক্রমে, বা অন্য কেউ আপনার তালিকা বদলালে। AI-এর তালিকা-সংক্রান্ত সাধারণ ভুলগুলো চিনে রাখুন:

AI-এর তালিকার কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• প্রতিটি ভ্যারিয়েবল আর parameter-এর টাইপ List; কোথাও অকারণ LinkedList নেই
• কোনো for-each বা সামনের দিকের index লুপের ভেতরে সেই তালিকারই add/remove নেই
• Arrays.asList বা List.of-এর তালিকায় পরে কোনো add, remove বা sort হয়নি
• List<Integer>-এর প্রতিটি remove-এর জন্য বলতে পারি সেটা index না মান
• class-এর ভেতরের mutable তালিকা কোনো getter দিয়ে সরাসরি বাইরে যাচ্ছে না
• মাপ আগে জানা থাকলে new ArrayList<>(n), আর বিশাল সংখ্যার হিসাবে int[] বিবেচনা করা হয়েছে