array — একই ধরনের অনেক মান, পাশাপাশি সাজানো

১ · ৪০ জনের নম্বর — ৪০টি ভ্যারিয়েবল?

ধরুন একটি ক্লাসে ৪০ জন শিক্ষার্থী, আর আপনাকে সবার পরীক্ষার নম্বর রেখে গড় বের করতে হবে। এ পর্যন্ত যা শিখেছেন, তা দিয়ে লিখতে হতো int m1, m2, m3, …, m40; — চল্লিশটি আলাদা নাম। গড় বের করতে চল্লিশটি নাম যোগ করার একটি লম্বা লাইন। কাল যদি শিক্ষার্থী হয় ৪৫ জন? পুরো কোড নতুন করে লিখতে হবে। আর পর্ব ১১-এর লুপ এখানে কোনো কাজেই আসবে না, কারণ m1, m2 নামগুলো লুপের ভ্যারিয়েবল দিয়ে বানানো যায় না।

দরকার এমন একটি জিনিস, যার একটি নাম, কিন্তু ভেতরে অনেকগুলো ঘর, আর প্রতিটি ঘরকে একটি নম্বর দিয়ে ধরা যায়। তাহলে “৭ নম্বর ঘর” লেখা যায়, আর “৭”-এর জায়গায় একটি ভ্যারিয়েবল বসিয়ে লুপে সব ঘর ঘোরা যায়। এই জিনিসটির নাম array.

প্রতিটি ঘরের নম্বরকে বলে index. Java-তে index শুরু হয় ০ থেকে, তাই পাঁচ ঘরের array-এর শেষ index ৪। কেন ০? কারণ index আসলে “শুরু থেকে কত ঘর দূরে”। প্রথম ঘর শুরু থেকে ০ ঘর দূরে। ঘরগুলো মেমরিতে পাশাপাশি থাকে (contiguous memory), তাই JVM যেকোনো ঘরের ঠিকানা বের করে একটি সরল সূত্রে: শুরুর ঠিকানা + index × ঘরের মাপ। ঘর ০ হোক বা ঘর ৯,৯৯৯ — সময় লাগে একই। এই কারণেই array এত দ্রুত।

২ · ঘোষণা, তৈরি আর শুরুর মান

Java-তে array নিয়ে কাজের দুটি আলাদা ধাপ আছে, আর এদের আলাদা করে বোঝা জরুরি: ভ্যারিয়েবল ঘোষণা আর array তৈরি।

int[] marks;               // ১. শুধু ভ্যারিয়েবল — এখনো কোনো array নেই
marks = new int[5];        // ২. heap-এ ৫ ঘরের array তৈরি, সব ঘরে 0

double[] temps = new double[7];         // ঘোষণা + তৈরি, এক লাইনে; সব ঘরে 0.0
int[] scores = {78, 85, 91};            // ঘোষণা + তৈরি + মান, এক লাইনে
String[] days = new String[]{"শনি", "রবি", "সোম"};  // মান দিয়ে, যেকোনো জায়গায়

প্রথম লাইনে int[] মানে “int-এর array”, আর marks হলো একটি ভ্যারিয়েবল যা এমন একটি array-এর reference রাখতে পারবে। এখনো কোনো ঘর তৈরি হয়নি। দ্বিতীয় লাইনে new int[5] heap-এ পাঁচটি int-এর জায়গা নেয়, আর তার reference যায় marks-এ। তৃতীয় লাইন দুটি ধাপ এক লাইনে সারে — ঢাকার ৭ দিনের তাপমাত্রার জন্য ৭টি double ঘর। চতুর্থ লাইনের {78, 85, 91} লেখার ধরনকে বলে array initializer — compiler নিজেই ঘর গুনে ৩ ঘরের array বানায়। এই সংক্ষিপ্ত রূপ শুধু ঘোষণার লাইনেই চলে; পরে নতুন মান দিতে চাইলে পঞ্চম লাইনের মতো new String[]{…} লিখতে হয়।

Default value — নতুন array কখনো আবর্জনা দেখায় না

new int[5] লিখে কোনো মান না দিলে ঘরগুলোতে কী থাকে? C-তে উত্তর হতো “যা খুশি” — আগের কোনো প্রোগ্রামের ফেলে যাওয়া আবর্জনা। Java-তে প্রতিটি নতুন array-এর প্রতিটি ঘর নিশ্চিতভাবে একটি default value পায়:

শেষ সারিটি খেয়াল করুন: new String[2] দুটি String তৈরি করে না। এটি তৈরি করে দুটি খালি reference-ঘর, দুটিই null. কোনো ঘরে মান না বসিয়ে names[0].length() লিখলে আসবে NullPointerException — নতুনদের খুব সাধারণ ভুল।

length — field, method নয়

প্রতিটি array নিজের ঘরের সংখ্যা জানে: marks.length. এর পরে বন্ধনী নেই — এটি একটি final field-এর মতো আচরণ করে, যার মান তৈরির সময়ই স্থির হয়ে যায়। তুলনা করুন: String-এর দৈর্ঘ্য name.length() (method, বন্ধনীসহ), আর পর্ব ৩০-এর ArrayList-এর আকার list.size(). তিনটি জিনিস, তিন রকম লেখা — MCQ-তে এটি একটি পরিচিত ফাঁদ, আর কেন এমন হলো তা ভাবনার প্রশ্ন ৩-এ আছে। marks.length = 10; লিখলে compile error — দৈর্ঘ্য বদলানো যায় না।

৩ · Index আর সীমা — যেখানে Java পাহারা দেয়

কোনো ঘর পড়তে বা লিখতে লিখুন array-এর নাম, তারপর বর্গবন্ধনীতে index: marks[2] পড়ে তৃতীয় ঘর, marks[2] = 95; সেখানে নতুন মান লেখে। শেষ ঘর সবসময় marks[marks.length - 1]. Index হিসেবে যেকোনো int প্রকাশ চলে — marks[i], marks[i + 1], marks[n / 2].

এবার সেই প্রশ্ন, যা C আর Java-কে আলাদা করে দেয়: পাঁচ ঘরের array-এ marks[5] লিখলে কী হয়? C-তে কোনো যাচাই হয় না — প্রোগ্রাম চুপচাপ array-এর ঠিক পরের মেমরি পড়ে বা লিখে ফেলে, যেখানে হয়তো অন্য কোনো ভ্যারিয়েবল থাকে। ফল হতে পারে ভুল উত্তর, হঠাৎ ক্র্যাশ, অথবা নিরাপত্তা-ছিদ্র। Java-তে এমন কোড compile হয় (compiler সাধারণত জানে না চলার সময় index কত হবে), কিন্তু চলার সময় JVM প্রতিটি array-ঘরে ঢোকার আগে যাচাই করে 0 ≤ index < length কি না। না হলে সে ছোড়ে ArrayIndexOutOfBoundsException:

class Main {
    public static void main(String[] args) {
        int[] marks = {78, 85, 91, 64, 85};
        System.out.println(marks[5]);   // ঘর আছে 0 থেকে 4
    }
}

Java 21-এ চালালে terminal-এ আসে:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 5
	at Main.main(Main.java:4)

সবচেয়ে পরিচিত কারণ হলো off-by-one ভুল — লুপের শর্তে i <= marks.length লেখা, যেখানে লেখা উচিত i < marks.length. শেষ পাকে i হয় ৫, আর exception. সমাধান সহজ: যেখানে সম্ভব for-each ব্যবহার করুন, যেখানে index লাগে সেখানে শর্তে < আর length লিখুন — কখনো হাতে লেখা সংখ্যা নয়।

৪ · লুপে array — for, for-each আর চারটি পরিচিত কাজ

Array আর লুপ একসাথে জন্মানো জুটি। পর্ব ১১-এ দুই রকম লুপ দেখেছেন; array-তে দুটিরই নিজস্ব জায়গা আছে:

// index-ওয়ালা for: কোন ঘরে আছি জানা দরকার, বা ঘর বদলাতে হবে
for (int i = 0; i < marks.length; i++) {
    marks[i] = marks[i] + 5;          // সবাইকে ৫ নম্বর গ্রেস
}

// for-each: শুধু প্রতিটি মান পড়ব, index লাগবে না
for (int m : marks) {
    System.out.println(m);
}

for-each লুপ (for (int m : marks)) পড়ুন “marks-এর প্রতিটি m-এর জন্য”। এতে index নেই, তাই off-by-one ভুলের সুযোগও নেই। কিন্তু দুটি সীমা মনে রাখুন। এক, m হলো ঘরের মানের একটি কপি — m = 0; লিখলে array বদলায় না। দুই, কোন ঘরে আছেন তা জানা যায় না। তাই ঘর বদলাতে বা পাশের ঘরের সাথে তুলনা করতে index-ওয়ালা for লাগে।

এবার সবচেয়ে পরিচিত কাজটি ধাপে ধাপে দেখি — ঢাকার পাঁচ দিনের সর্বোচ্চ তাপমাত্রা থেকে সবচেয়ে গরম দিন খোঁজা। মূল কৌশল হলো একটি “এখন পর্যন্ত সেরা” ভ্যারিয়েবল, যা প্রতিটি ঘরের সাথে তুলনা করে দরকার হলে বদলায়:

1int[] t = {33, 35, 31, 36, 34};2int max = t[0];3for (int x : t) {4    if (x > max) max = x;5}6System.out.println("max = " + max);

আরও তিনটি কাজ, যা বারবার লাগবে

একটি দোকানের ১২ মাসের বিক্রি একটি array-তে আছে ধরুন। নিচের তিনটি ছাঁচ প্রায় প্রতিটি প্রোগ্রামে কোনো না কোনো রূপে আসে:

// ১. linear search: ৫০০০ টাকা বিক্রি হয়েছে কোন মাসে?
int found = -1;
for (int i = 0; i < sales.length; i++) {
    if (sales[i] == 5000) { found = i; break; }
}

// ২. গোনা: কত মাসে বিক্রি ৪০০০-এর বেশি?
int count = 0;
for (int s : sales) if (s > 4000) count++;

// ৩. উল্টানো (নতুন array ছাড়া, জায়গায় দাঁড়িয়ে)
for (int i = 0, j = sales.length - 1; i < j; i++, j--) {
    int tmp = sales[i]; sales[i] = sales[j]; sales[j] = tmp;
}

Linear search শুরু থেকে একটি একটি করে দেখে; না পেলে -1 ফেরত দেওয়া একটি প্রচলিত রীতি, কারণ -১ কখনো বৈধ index নয়। উল্টানোর কৌশলে দুই প্রান্ত থেকে দুটি index মাঝের দিকে আসে, প্রতিবার দুটি ঘর অদলবদল করে, আর দেখা হলেই থামে — অর্ধেক পাকেই কাজ শেষ। শর্ত i < j খেয়াল করুন: i <= j দিলেও ক্ষতি নেই, কিন্তু i < length দিলে দ্বিতীয়ার্ধে আবার অদলবদল হয়ে array আগের রূপে ফিরে যায় — একটি ক্লাসিক ভুল।

৫ · Array একটি reference — শেয়ার, কপি আর method-এ পাঠানো

পর্ব ০৫-এ দেখেছেন, object-এর ভ্যারিয়েবলে object নিজে থাকে না, থাকে তার reference. Array-ও object, তাই একই নিয়ম। এর একটি ফল প্রথমবার প্রায় সবাইকে চমকে দেয়। নিচের পাঁচ লাইন ধাপে ধাপে দেখুন:

1int[] a = {10, 20, 30};2int[] b = a;3b[0] = 99;4System.out.println(a[0]);5b = new int[]{1, 2, 3};

সত্যিকারের কপি — কয়েকটি উপায়

আলাদা একটি array চাইলে, যেটা বদলালে আসলটি অক্ষত থাকে, কয়েকটি প্রচলিত উপায় আছে:

একটি মজার তথ্য: “array-এর আকার বাড়ানো” আসলে Java-তে অসম্ভব। marks = Arrays.copyOf(marks, 10); লিখলে পুরোনো array বড় হয় না — নতুন ১০ ঘরের array তৈরি হয়, পুরোনো মানগুলো তাতে কপি হয়, আর ভ্যারিয়েবল নতুনটিকে দেখাতে শুরু করে। পুরোনোটি garbage collector-এর জন্য পড়ে থাকে। পর্ব ৩০-এর ArrayList ভেতরে ঠিক এই কাজটিই করে, আপনার হয়ে।

Method-এ array পাঠালে

পর্ব ১২-এ দেখেছেন, Java সবসময় pass-by-value — method পায় argument-এর একটি কপি। Array-এর ক্ষেত্রে কপি হয় reference-টি, array নয়। তাই method array-এর ভেতরের ঘর বদলালে সেই বদল ডাকা জায়গাতেও দেখা যায়; কিন্তু method যদি নিজের parameter-কে নতুন array দেয়, বাইরের ভ্যারিয়েবল তা টেরও পায় না — ঠিক উপরের stepper-এর ধাপ ৩ আর ধাপ ৫-এর পার্থক্য।

static void addGrace(int[] m) { for (int i = 0; i < m.length; i++) m[i] += 5; }  // বাইরে দেখা যাবে
static void reset(int[] m)    { m = new int[m.length]; }                          // বাইরে কোনো প্রভাব নেই

এটাও খেয়াল করুন: C-তে function-এ array পাঠালে দৈর্ঘ্য হারিয়ে যায়, তাই আলাদা n পাঠাতে হয়। Java-তে m.length সবসময় সঙ্গে যায়। আর পর্ব ১২-এর varargs (int... nums) আসলে ছদ্মবেশী array — method-এর ভেতরে nums একটি সাধারণ int[].

এবার এই অংশের সবকিছু একসাথে চালিয়ে দেখুন — চলমান max আর গড়, default value, aliasing আর সঠিক কপি, আর তুলনার সঠিক উপায়:

import java.util.Arrays;

class Main {
    public static void main(String[] args) {
        int[] marks = {78, 85, 91, 64, 85};
        int sum = 0, max = marks[0];
        for (int m : marks) {
            sum += m;
            if (m > max) max = m;
        }
        System.out.println("marks  = " + Arrays.toString(marks));
        System.out.println("length = " + marks.length + ", max = " + max);
        System.out.printf("avg    = %.1f%n", (double) sum / marks.length);

        int[] alias = marks;                              // একই array
        int[] copy = Arrays.copyOf(marks, marks.length);  // নতুন array
        alias[0] = 99;
        System.out.println("marks[0] = " + marks[0] + ", copy[0] = " + copy[0]);
        System.out.println("copy == marks : " + (copy == marks));
        System.out.println("Arrays.equals : " + Arrays.equals(copy, new int[]{78, 85, 91, 64, 85}));

        System.out.println(Arrays.toString(new boolean[3]) + " " + Arrays.toString(new String[2]));
    }
}

৬ · java.util.Arrays — array-এর সহকারী

Array নিজে খুব সরল object — তার কোনো দরকারি method নেই (না আছে sort, না সুন্দর করে ছাপা)। সেই কাজগুলো রাখা আছে java.util.Arrays নামের একটি class-এ, যার সব method static. ফাইলের শুরুতে import java.util.Arrays; লিখে ব্যবহার করুন।

প্রথম ফাঁদ: array সরাসরি ছাপা

System.out.println(marks); লিখলে কী ছাপবে বলে মনে হয়? [78, 85, 91]? না। আসবে এমন কিছু:

[I@1b6d3586

এটা কোনো ভুল নয়, কিন্তু কাজেরও নয়। Array-এর নিজস্ব toString নেই, তাই Object-এর ডিফল্টটি চলে: টাইপের ভেতরের নাম, @, আর একটি hexadecimal সংখ্যা। [ মানে “array”, I মানে int (double[] হলে [D, String[] হলে [Ljava.lang.String;). @-এর পরের সংখ্যাটি object-এর identity hash code — প্রতিবার চালালে বা প্রতিটি কম্পিউটারে আলাদা হতে পারে। এর ওপর কখনো নির্ভর করবেন না। সবসময় লিখুন Arrays.toString(marks); 2D array-এর জন্য Arrays.deepToString(table).

প্রয়োজনীয় method-গুলো এক নজরে

Binary search — প্রতিবার অর্ধেক বাদ

Linear search ১০ লাখ ঘরে সবচেয়ে খারাপ অবস্থায় ১০ লাখ ঘর দেখে। কিন্তু array যদি সাজানো থাকে, তাহলে অনেক চতুর কৌশল চলে — অভিধানে শব্দ খোঁজার মতো। মাঝখানের ঘর দেখুন; খোঁজা মান বড় হলে বাঁ দিকের অর্ধেক পুরো বাদ, ছোট হলে ডান দিক বাদ। প্রতি ধাপে বাকি জায়গা অর্ধেক হয়, তাই ১০ লাখ ঘরেও ২০টির মতো ধাপ যথেষ্ট। একে বলে binary search. দশজনের সাজানো নম্বর থেকে ৯১ খুঁজে দেখি:

1int lo = 0, hi = a.length - 1;2int mid = (lo + hi) >>> 1;3if (a[mid] < key) lo = mid + 1;4else if (a[mid] > key) hi = mid - 1;5else return mid;   // পাওয়া গেছে

৭ · 2D array — array-এর array

৫ জন শিক্ষার্থীর ৩টি বিষয়ের নম্বর — এটি একটি টেবিল: সারি মানে শিক্ষার্থী, কলাম মানে বিষয়। Java-তে লিখবেন int[][] marks = new int[5][3]; আর তৃতীয় শিক্ষার্থীর দ্বিতীয় বিষয় পড়বেন marks[2][1] দিয়ে — আগে সারি, তারপর কলাম।

কিন্তু ভেতরের ছবিটি C-র মতো একটি বড় আয়তক্ষেত্র নয়। Java-তে আসলে আলাদা কোনো “2D array” নেই। int[][] মানে “int[]-এর array” — একটি বাইরের array, যার প্রতিটি ঘরে একটি সারির reference, আর প্রতিটি সারি heap-এ আলাদা একটি int[] object. এই ছবি থেকেই একটি সুবিধা আসে: সারিগুলোর দৈর্ঘ্য আলাদা হতে পারে। একে বলে jagged array. ধরুন একটি বাসের সিট-প্ল্যান — সামনের সারিগুলোতে ৪টি করে সিট, পেছনের শেষ সারিতে ৫টি:

1int[][] seats = new int[3][];2seats[0] = new int[4];3seats[1] = new int[4];4seats[2] = new int[5];5seats[2][4] = 1;   // শেষ সিট বুকড

এবার ঢাকার এক সপ্তাহের তাপমাত্রা সাজিয়ে binary search, আর বাসের সিট-প্ল্যান চালিয়ে দেখুন:

import java.util.Arrays;

class Main {
    public static void main(String[] args) {
        // ঢাকার ৭ দিনের সর্বোচ্চ তাপমাত্রা (°C)
        int[] temps = {33, 35, 31, 36, 34, 32, 35};
        int[] sorted = temps.clone();          // আসল ক্রম রেখে দিলাম
        Arrays.sort(sorted);
        System.out.println("sorted = " + Arrays.toString(sorted));
        System.out.println("34 at index " + Arrays.binarySearch(sorted, 34));
        System.out.println("30 -> " + Arrays.binarySearch(sorted, 30));
        System.out.println("temps  = " + Arrays.toString(temps));

        // বাসের সিট: দুই সারিতে ৪টি, শেষ সারিতে ৫টি (jagged)
        char[][] seats = {new char[4], new char[4], new char[5]};
        for (char[] row : seats) Arrays.fill(row, '.');
        seats[0][1] = 'X';
        seats[2][4] = 'X';
        for (char[] row : seats) System.out.println(new String(row));

        int[][] table = {{78, 85, 91}, {64, 70}};
        System.out.println(Arrays.deepToString(table));
    }
}

৮ · Array নাকি ArrayList — আর main-এর String[] args

Array-এর সবচেয়ে বড় সীমা তার স্থির আকার। একটি অনলাইন দোকানের অর্ডার, একটি চ্যাট অ্যাপের মেসেজ, ফাইল থেকে পড়া লাইন — এগুলো কয়টি হবে আগে জানা যায় না। এমন জায়গার জন্য Java-র Collections-এ আছে ArrayList, যা প্রয়োজন মতো বড় হয় (পর্ব ৩০-এ বিস্তারিত)। ভেতরে সে একটি array-ই রাখে; জায়গা ফুরালে বড় একটি নতুন array বানিয়ে সব কপি করে — উপরে Arrays.copyOf-এর যে কৌশল দেখলেন।

Primitive-এর ব্যাপারটি একটু খুলে বলি। int[]-এর প্রতিটি ঘরে সরাসরি একটি ৪ byte-এর সংখ্যা, পাশাপাশি সাজানো। কিন্তু ArrayList<Integer> primitive রাখতে পারে না; প্রতিটি সংখ্যা একটি আলাদা Integer object হয়ে heap-এ থাকে, আর list-এ থাকে তাদের reference. ফলে ১০ লাখ সংখ্যায় ArrayList কয়েক গুণ বেশি মেমরি নেয়, আর প্রতিটি মান পড়তে একটি বাড়তি লাফ লাগে। দৈনন্দিন কোডে এই পার্থক্য চোখে পড়ে না; বিপুল ডেটায় পড়ে।

প্রথম দিন থেকে দেখা array — String[] args

পর্ব ০৪ থেকে প্রতিটি প্রোগ্রামে লিখে আসছেন public static void main(String[] args). এখন বুঝতে পারছেন args কী: String-এর একটি array. Terminal-এ java Main Dhaka 42 চালালে JVM args-এ দেয় ["Dhaka", "42"] — দুটিই লেখা, ৪২-ও; সংখ্যা চাইলে Integer.parseInt(args[1]). কিছু না দিলে args null নয়, বরং ০ দৈর্ঘ্যের একটি খালি array. তাই args[0] পড়ার আগে args.length যাচাই করা ভালো অভ্যাস; নইলে সেই পরিচিত বার্তা: Index 0 out of bounds for length 0. এই কমান্ড-লাইন argument-ই (command-line argument) git, javac-এর মতো টুলগুলোকে নির্দেশ দেয়।

৯ · AI-এর যুগে — AI-এর লেখা array কোড যাচাই

Array নিয়ে AI-এর কোড সাধারণত compile হয়, আর ছোট পরীক্ষায় ঠিকঠাক চলে। ভুলগুলো লুকিয়ে থাকে সীমায়, reference-এ আর ছাপার লাইনে — ঠিক যে জায়গাগুলো এই পর্বে দেখলেন। নিচের টেবিলটি AI-এর উত্তরে বারবার দেখা ভুলের তালিকা:

উল্টো ভুলটিও দেখা যায়: ১০ লাখ int নিয়ে গাণিতিক হিসাবের কোডে AI ArrayList<Integer> বসিয়ে দেয়, যেখানে সাধারণ int[] অনেক দ্রুত আর হালকা হতো। AI-কে প্রসঙ্গ না দিলে সে “সাধারণত যা লেখা হয়” সেটাই লেখে, আপনার সমস্যার জন্য যা সেরা সেটা নয়।

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

• কোথাও array সরাসরি println বা + দিয়ে ছাপা হচ্ছে কি না খুঁজেছি
• প্রতিটি লুপের শর্তে < আর .length আছে, <= বা হাতে লেখা সংখ্যা নেই — দেখেছি
• Array তুলনায় == নয়, Arrays.equals (2D হলে deepEquals) ব্যবহার হয়েছে
• b = a ধরনের লাইনে বুঝেছি এটা কপি নাকি একই array — আর method আসল array বদলে দিচ্ছে কি না
• খালি array (length == 0) আর এক উপাদানের array দিয়ে কোডটি নিজে চালিয়ে দেখেছি
• আকার স্থির না হলে array-এর বদলে ArrayList, আর বিপুল primitive হলে উল্টোটা — বিবেচনা করেছি