Arrays & java.util.Arrays — The Fixed-Size Backbone

অ্যারে ও Arrays utility — Java-র সবচেয়ে পুরনো ও দ্রুততম collection

Read: ~30 min Intermediate 5 practice problems Live code runner

1. What Is an Array in Java?

A Java array is a fixed-size, contiguous block of memory that holds a fixed number of values of the same type. Once you create an array of length 10, that length never changes. Arrays are the lowest-level collection Java offers — ArrayList, HashMap, and every other collection is built on top of them.

Java-তে array হলো একটি fixed-size, ধারাবাহিক memory block, যেখানে একই type-এর কিছু মান রাখা হয়। একবার length 10 দিয়ে তৈরি করলে সেটি আর বদলানো যায় না। Array হলো Java-র সবচেয়ে নিচের স্তরের collection — ArrayList, HashMap, সব higher-level collection ভিতরে array-ই ব্যবহার করে।

Because they are native to the JVM, arrays are extremely fast — random access is O(1), iteration is cache-friendly, and there is no boxing overhead for int[], double[], etc.

2. Declaring & Creating Arrays

Java gives you three common ways to create an array: new with length, literal initializer, and for-loop fill.

Array বানানোর তিনটি পথ — new দিয়ে size, literal initializer ({...}), অথবা loop দিয়ে পূরণ। তিনটিই বৈধ; পরিস্থিতি অনুযায়ী বেছে নিন।
Main.java
import java.util.*;

class Main {
    public static void main(String[] args) {
        // 1) new with length — zero-filled
        int[] a = new int[5];
        a[0] = 10; a[1] = 20;

        // 2) literal initializer
        int[] b = { 1, 2, 3, 4, 5 };

        // 3) loop-fill
        String[] names = new String[3];
        for (int i = 0; i < names.length; i++) {
            names[i] = "User-" + i;
        }

        System.out.println("a = " + Arrays.toString(a));
        System.out.println("b = " + Arrays.toString(b));
        System.out.println("names = " + Arrays.toString(names));
    }
}
int[] b = {1, 2, 3, 4, 5}; — contiguous in memory 1 2 3 4 5 [0] [1] [2] [3] [4] b.length = 5 · access b[i] in O(1) · cache-friendly Figure 22.1 — Array ধারাবাহিক memory-তে রাখা হয়, তাই random access O(1)।

3. Two-Dimensional Arrays

A 2D array in Java is really an array of arrays. Each row can technically have a different length — these are called jagged arrays. For most tabular data you'll use a rectangular grid, but knowing the truth helps when you debug.

Java-তে 2D array আসলে array of arrays। প্রতিটি row-এর length আলাদা হতে পারে — এগুলোকে jagged array বলে। সাধারণ কাজে rectangle grid-ই ব্যবহার করবেন, কিন্তু ভেতরের সত্যটা জানলে debug সহজ।
Main.java
import java.util.*;

class Main {
    public static void main(String[] args) {
        int[][] grid = {
            { 1, 2, 3 },
            { 4, 5, 6 },
            { 7, 8, 9 }
        };

        for (int r = 0; r < grid.length; r++) {
            for (int c = 0; c < grid[r].length; c++) {
                System.out.print(grid[r][c] + " ");
            }
            System.out.println();
        }

        System.out.println("As text: " + Arrays.deepToString(grid));
    }
}
Tip: Arrays.toString(grid) prints only the outer references — use Arrays.deepToString(grid) for nested arrays.

2D array print করতে deepToString ব্যবহার করুন; নয়তো আপনি পাবেন [I@1b6d3586 জাতীয় হেশ।

4. The java.util.Arrays Utility Class

Arrays is a static utility class full of helpers: sort, binary search, fill, copy, equals, hashCode, toString, and stream conversion. Memorize these — they save a lot of boilerplate.

Arrays একটি static utility class — sort, binary search, fill, copy, equals, hashCode, toString, stream — সব এখানে। এগুলো মনে রাখলে অনেক boilerplate থেকে বাঁচবেন।
Main.java
import java.util.*;

class Main {
    public static void main(String[] args) {
        int[] a = { 5, 3, 8, 1, 9, 2 };

        Arrays.sort(a);                 // in-place sort
        System.out.println("sorted: " + Arrays.toString(a));

        int idx = Arrays.binarySearch(a, 8);
        System.out.println("index of 8: " + idx);

        int[] copy = Arrays.copyOfRange(a, 1, 4);
        System.out.println("copy[1..4) = " + Arrays.toString(copy));

        int[] zeros = new int[5];
        Arrays.fill(zeros, -1);
        System.out.println("filled: " + Arrays.toString(zeros));

        int sum = Arrays.stream(a).sum();
        System.out.println("sum = " + sum);
    }
}

5. The Arrays.asList Pitfall

Arrays.asList(...) takes vararg objects. If you pass a primitive array like new int[]{1,2,3}, Java treats the entire array as a single Object element — not three elements! The returned list has size 1, not 3.

Arrays.asList(new int[]{1,2,3}) → size 1-এর একটি List, কারণ primitive array নিজেই একটি Object হিসেবে ঢোকে। Integer[] দিন, নয়তো IntStream.of(...) ব্যবহার করুন।
Main.java
import java.util.*;
import java.util.stream.*;

class Main {
    public static void main(String[] args) {
        int[] primitive = { 1, 2, 3 };
        List<Object> wrong = Arrays.asList((Object) primitive);
        System.out.println("wrong.size() = " + wrong.size());   // 1 !!

        Integer[] boxed = { 1, 2, 3 };
        List<Integer> right = Arrays.asList(boxed);
        System.out.println("right.size() = " + right.size());   // 3

        // For primitive arrays use IntStream
        List<Integer> viaStream = IntStream.of(primitive).boxed().toList();
        System.out.println("viaStream = " + viaStream);
    }
}

6. Vocabulary (শব্দভাণ্ডার)

TermMeaningবাংলায়
lengthA field on every array (not a method).Array-র field — method নয়, তাই বন্ধনী লাগে না।
Jagged array2D array where rows can have different lengths.ভিন্ন-length-এর row-সহ 2D array।
Arrays.sortDual-pivot Quicksort for primitives, TimSort for objects.Primitive-এ Dual-pivot Quicksort, object-এ TimSort।
Arrays.streamConvert a primitive array to IntStream/DoubleStream/LongStream.Primitive array-কে stream-এ রূপান্তর।
deepToStringRecursive toString — use for 2D+ arrays.Nested array-এর জন্য recursive toString।
binarySearchRequires a sorted array; returns -(insertion)-1 if not found.Sorted array লাগে; না পেলে negative index ফেরত।

7. Practice Problems

Try each one yourself first, then expand the answer.

প্রথমে নিজে চেষ্টা করুন, তারপর উত্তর মিলিয়ে নিন।
  1. Create an int[] of size 10, fill with squares 0²..9², and print the sum.
    10 size-এর একটি int[] বানিয়ে তাতে 0² থেকে 9² রাখুন এবং যোগফল প্রিন্ট করুন।
    ✨ Show Answer (উত্তর দেখুন)
    Main.java
    import java.util.*;
class Main {
    public static void main(String[] args) {
        int[] sq = new int[10];
        int sum = 0;
        for (int i = 0; i < sq.length; i++) { sq[i] = i * i; sum += sq[i]; }
        System.out.println(Arrays.toString(sq));
        System.out.println("sum = " + sum);
    }
}
  2. Sort {5,3,8,1,9,2} and return its median using Arrays.sort.
    {5,3,8,1,9,2} sort করে median বের করুন।
    ✨ Show Answer (উত্তর দেখুন)
    Main.java
    import java.util.*;
class Main {
    public static void main(String[] args) {
        int[] a = { 5, 3, 8, 1, 9, 2 };
        Arrays.sort(a);
        double median = (a.length % 2 == 0)
            ? (a[a.length / 2 - 1] + a[a.length / 2]) / 2.0
            : a[a.length / 2];
        System.out.println("sorted = " + Arrays.toString(a));
        System.out.println("median = " + median);
    }
}
  3. Given a 3x3 integer grid, compute the sum of the main diagonal.
    3x3 integer grid-এর main diagonal-এর যোগফল বের করুন।
    ✨ Show Answer (উত্তর দেখুন)
    Main.java
    class Main {
    public static void main(String[] args) {
        int[][] g = { {1,2,3}, {4,5,6}, {7,8,9} };
        int d = 0;
        for (int i = 0; i < g.length; i++) d += g[i][i];
        System.out.println("diagonal sum = " + d);
    }
}
  4. Explain why Arrays.asList(new int[]{1,2,3}).size() returns 1.
    Arrays.asList(new int[]{1,2,3}).size() কেন 1 দেয় — ব্যাখ্যা করুন।
    ✨ Show Answer (উত্তর দেখুন)

    Answer: Arrays.asList is a varargs method taking T.... Primitive int[] is itself an Object, so it is treated as a single element of type int[] inside a List<int[]> — hence size 1. To wrap the ints individually, use Integer[] or IntStream.of(arr).boxed().toList().

    Varargs T...-এ primitive int[] নিজেই একটি Object হিসেবে ঢোকে, তাই List-এর একটি element হয় — size 1। ঠিকভাবে wrap করতে Integer[] দিন অথবা IntStream.of(arr).boxed().toList() ব্যবহার করুন।

  5. Use Arrays.stream to compute the average of {10, 20, 30, 40, 50}.
    Arrays.stream ব্যবহার করে {10,20,30,40,50}-এর গড় বের করুন।
    ✨ Show Answer (উত্তর দেখুন)
    Main.java
    import java.util.*;
class Main {
    public static void main(String[] args) {
        int[] a = { 10, 20, 30, 40, 50 };
        double avg = Arrays.stream(a).average().orElse(0);
        System.out.println("average = " + avg);
    }
}

Summary — Module 22

Java arrays are fixed-size, typed, contiguous memory blocks with O(1) access. The java.util.Arrays utility class gives you sort, binarySearch, copyOfRange, fill, stream, and the all-important deepToString. Beware Arrays.asList with primitive arrays — it always wraps them as a single Object element.

Java array fixed-size, typed, ধারাবাহিক memory — O(1) access। java.util.Arrays দিচ্ছে sort, binarySearch, copyOfRange, fill, stream, deepToString। Primitive array-এ Arrays.asList-এর ফাঁদ মনে রাখুন — ওটি সব সময় single Object হিসেবে wrap করে।

Next Module → List: ArrayList ও LinkedList — কবে কোনটি ব্যবহার করবেন, এবং আরও জরুরি — কবে করবেন না।

Prev: Generics Next: ArrayList & LinkedList