String, StringBuilder আর immutability — Java-তে লেখা নিয়ে কাজ

১ · String আসলে কী — একবার লেখা হলে আর বদলায় না

পর্ব ০৪ থেকেই আপনি "Hello, Dhaka!" লিখছেন। পর্ব ০৬-এ দেখেছেন, Java-র টাইপ দুই রকম — primitive (int, double, char…) আর reference. String দ্বিতীয় দলের: এটি একটি object, যার ভেতরে থাকে অক্ষরের একটি সারি। আরও নির্দিষ্ট করে বললে, সারিটি UTF-16 code unit-এর — প্রতিটি টুকরো একটি char. এই খুঁটিনাটি অংশ ৬-এ বাংলা লেখার সময় খুব কাজে লাগবে।

কিন্তু String-এর সবচেয়ে গুরুত্বপূর্ণ বৈশিষ্ট্য অন্য জায়গায়: একবার তৈরি হলে কোনো String-এর ভেতরের লেখা আর বদলানো যায় না। একে বলে immutable. String class-এ এমন কোনো method নেই যা নিজের অক্ষর বদলে দেয়। যেগুলো দেখে মনে হয় বদলাচ্ছে — toUpperCase(), replace(), strip() — তারা আসলে একটি নতুন String বানিয়ে ফেরত দেয়।

নতুনদের সবচেয়ে প্রচলিত ভুলগুলোর একটি হলো name.trim(); লিখে ভাবা যে name পরিষ্কার হয়ে গেছে। নিচের ডায়াগ্রামে দেখুন, প্রতিটি লাইনে variable কোন object-কে দেখাচ্ছে আর heap-এ কী কী object আছে:

1String s = "cha";2s.toUpperCase();          // ফল কেউ ধরল না3System.out.println(s);4s = s.toUpperCase();      // ফল s-এ রাখা হলো5System.out.println(s);

String তৈরির দুই উপায় — আর কেন new String এড়াবেন

String a = "Dhaka";               // literal — এভাবেই লিখুন
String b = new String("Dhaka");   // প্রায় কখনো দরকার হয় না

দুটি লাইনেই লেখা একই, কিন্তু দ্বিতীয়টি অপ্রয়োজনে একটি বাড়তি object বানায়: "Dhaka" literal তো আছেই, new তার একটি কপি করে heap-এ আরেকটি আলাদা object তৈরি করে। যেহেতু String বদলায় না, একই লেখার দুটি কপির কোনো লাভ নেই — শুধু মেমরি খরচ আর ==-এর বিভ্রান্তি (পরের অংশ)। নিয়ম: literal লিখুন, new String("…") নয়। char-এর array বা byte থেকে String বানাতে হলে অবশ্য constructor বা String.valueOf লাগে — সেটি আলাদা ব্যাপার।

২ · String pool আর == বনাম equals — সবচেয়ে পুরোনো ফাঁদ

একটি বড় প্রোগ্রামে "OK", "Dhaka", "error"-এর মতো লেখা হাজারবার আসে। প্রতিবার আলাদা object বানালে মেমরি নষ্ট। তাই JVM একটি তালিকা রাখে — string pool. কোডের প্রতিটি literal এই pool থেকে আসে, আর একই লেখার literal সবসময় একই object. এটা নিরাপদ, কারণ String বদলায় না — একজন বদলে দিলে অন্যজনের লেখাও বদলে যাবে, এমন ভয় নেই।

এখান থেকেই আসে Java-র সবচেয়ে বিখ্যাত বাগ। == অপারেটর (পর্ব ০৭) reference-এর ক্ষেত্রে লেখা মেলায় না — দেখে দুটি তীর একই object-এর দিকে কি না। লেখা মেলায় equals method. দুটি literal একই object বলে == কাকতালীয়ভাবে true দেয়, আর প্রোগ্রামার ভাবেন কোড ঠিক আছে। তারপর ব্যবহারকারীর ইনপুট বা জোড়া লাগানো লেখা আসে — যা চলার সময়ে তৈরি নতুন object — আর == হঠাৎ false. ধাপে ধাপে দেখুন:

1String part = "Dha";2String a = "Dhaka";3String b = "Dhaka";4String c = new String("Dhaka");5String d = part + "ka";6print(a == b, a == c, a == d);7print(a.equals(d), a == d.intern());

এবার নিজে চালিয়ে দেখুন। সাথে আরও দুটি তুলনা আছে: বড়-ছোট হাতের পার্থক্য উপেক্ষা করে মেলানো (equalsIgnoreCase), আর অভিধানের মতো ক্রম বলা (compareTo):

class Main {
    public static void main(String[] args) {
        String a = "Dhaka";               // literal: pool থেকে
        String b = "Dhaka";               // একই literal, একই object
        String part = "Dha";
        String d = part + "ka";           // চলার সময়ে তৈরি: নতুন object

        System.out.println("a == b          : " + (a == b));
        System.out.println("a == d          : " + (a == d));
        System.out.println("a.equals(d)     : " + a.equals(d));
        System.out.println("a == d.intern() : " + (a == d.intern()));

        String typed = "DHAKA";           // ব্যবহারকারী বড় হাতে লিখেছেন
        System.out.println("equals           : " + a.equals(typed));
        System.out.println("equalsIgnoreCase : " + a.equalsIgnoreCase(typed));

        // compareTo: ঋণাত্মক = আগে, 0 = সমান, ধনাত্মক = পরে
        System.out.println("Barishal vs Dhaka : " + "Barishal".compareTo("Dhaka"));
        System.out.println("Dhaka vs dhaka    : " + "Dhaka".compareTo("dhaka"));
        System.out.println("Dhaka vs Dhaka    : " + "Dhaka".compareTo("Dhaka"));
    }
}

৩ · দরকারি method — খোঁজা, কাটা, পরিষ্কার করা

String class-এ একশোর বেশি method আছে, কিন্তু প্রতিদিনের কাজের জন্য গোটা পনেরো জানলেই চলে। একটি কথা আগে মনে রাখুন: অক্ষরের অবস্থান (index) গোনা শুরু হয় ০ থেকে, আর অংশ ১-এর নিয়ম মেনে কোনো method মূল String বদলায় না।

substring — শুরু ধরা হয়, শেষ বাদ যায়

substring(begin, end) লেখার একটি টুকরো ফেরত দেয় — begin থেকে শুরু করে end-এর ঠিক আগ পর্যন্ত। শেষ index বাদ যায় বলে টুকরোর দৈর্ঘ্য সবসময় end - begin. নিচে “Bangladesh” শব্দের ১০টি ঘরে হাঁটুন:

1String w = "Bangladesh";2w.charAt(0)3w.substring(0, 6)4w.substring(6)5w.indexOf("desh")6w.substring(6, 11)

trim বনাম strip — কোন “ফাঁকা” মুছবে

ফর্মে মানুষ প্রায়ই নামের আগে-পরে ফাঁকা জায়গা দেন। পুরোনো trim() শুধু সেই অক্ষরগুলো মোছে যাদের নম্বর U+0020 (সাধারণ space) বা তার কম। Java 11-এ আসা strip() Unicode-এর সব রকম ফাঁকা অক্ষর চেনে (যেটিকে Character.isWhitespace ফাঁকা বলে)। যেমন কপি-পেস্টে প্রায়ই আসা em space (U+2003): "\u2003hi\u2003"-এ trim()-এর পরেও দৈর্ঘ্য 4, strip()-এর পরে 2. সাথে আছে stripLeading() আর stripTrailing(). নতুন কোডে strip() ব্যবহার করুন, আর “কিছু লেখা হয়েছে কি না” যাচাইয়ে isBlank() (Java 11) — এটি শুধু ফাঁকা জায়গা থাকলেও true দেয়, যেখানে isEmpty() দেখে শুধু দৈর্ঘ্য শূন্য কি না।

split আর replaceAll — ভেতরে লুকানো regex

split, replaceAll আর matches যে লেখা নেয়, সেটি সাধারণ লেখা নয় — একটি regex, অর্থাৎ নকশার ভাষা। সেখানে কয়েকটি চিহ্নের বিশেষ মানে: . মানে “যেকোনো একটি অক্ষর”, | মানে “অথবা”। ফলাফল চমকে দেওয়ার মতো (Wandbox-এ যাচাই করা):

"a.b.c".split(".").length       // 0  — প্রতিটি অক্ষরই "বিভাজক"!
"a.b.c".split("\\.").length     // 3  — \\. মানে আসল ডট
"a|b|c".split("|").length       // 5  — ফাঁকা নকশা, প্রতিটি অক্ষর আলাদা
"a|b|c".split("\\|").length     // 3
"a.b".replace(".", "-")         // "a-b" — replace সাধারণ লেখা নেয়
"a.b".replaceAll(".", "-")      // "---" — replaceAll regex নেয়
"a,b,,c,,".split(",").length    // 4  — শেষের ফাঁকা টুকরো বাদ পড়ে

প্রথম লাইনে . প্রতিটি অক্ষরের সাথে মেলে, তাই সব অক্ষরই বিভাজক হয়ে যায়, টুকরোগুলো সব ফাঁকা — আর split শেষের ফাঁকা টুকরো ফেলে দেয় বলে ফল শূন্য-দৈর্ঘ্যের array. Java String-এ \ নিজেই escape অক্ষর (পর্ব ০৪), তাই regex-এর \. লিখতে হয় "\\.". শেষ লাইনটিও মনে রাখুন: CSV-র শেষে ফাঁকা ঘর থাকলে সেগুলো হারিয়ে যায়; রাখতে চাইলে split(",", -1). সন্দেহ হলে Pattern.quote(".") দিয়ে লেখাটিকে হুবহু অর্থে নিতে বলুন।

৪ · লেখা জোড়া — কখন +, কখন StringBuilder

পর্ব ০৪-এ দেখেছেন + দিয়ে লেখা জোড়া লাগে (string concatenation). এক লাইনের জোড়ায় + একদম ঠিক আছে — "Name: " + name + ", Age: " + age লিখতে দ্বিধা করবেন না। Java 9 থেকে javac এমন একটি পুরো expression-কে একটিমাত্র invokedynamic নির্দেশে compile করে (JEP 280); কোন উপায়ে জোড়া লাগবে তা JVM চলার সময় ঠিক করে, আর মাঝপথের অস্থায়ী String বানায় না। Java 8 পর্যন্ত javac একই কাজ করত পেছনে একটি StringBuilder বানিয়ে।

সমস্যা হয় লুপের ভেতরে s = s + x লিখলে। String বদলায় না, তাই প্রতিবার পুরো পুরোনো লেখা কপি করে তার সাথে নতুন টুকরো জুড়ে একটি নতুন object বানাতে হয়। দেখুন কপির হিসাব কীভাবে বাড়ে:

heap:  ""   "1"

নতুন object: ১টি     কপি হলো: ১টি অক্ষর

heap:  ""   "1" (আবর্জনা)   "12"

নতুন object: ২টি     মোট কপি: 1 + 2 = ৩টি অক্ষর

heap:  ""  "1"  "12"  "123"  "1234"

নতুন object: ৪টি     মোট কপি: 1 + 2 + 3 + 4 = ১০টি অক্ষর
n বার ঘুরলে কপি ≈ n × n ÷ 2
n = 10,000 হলে ≈ ৫ কোটি অক্ষর কপি

sb ──► [ 1 | 2 | 3 | 4 | _ | _ | _ | _ | _ | _ | _ | _ | _ | _ | _ | _ ]
         ভরা: 4              ধারণক্ষমতা (capacity): 16

প্রতিটি append শুধু খালি ঘরে লেখে — পুরোনো অক্ষর কপি হয় না

১৭তম অক্ষর এলে:  capacity 16 → 34  (একবার কপি, তারপর আবার জায়গা)
আবার ফুরোলে:    34 → 70 …   (প্রতিবার প্রায় দ্বিগুণ)

String t = sb.toString();   → একটিমাত্র নতুন String "1234…"
n বার ঘুরলে মোট কপি ≈ কয়েক × n

StringBuilder-এর প্রচলিত method-গুলো একই object বদলায় আর সেই object-ই ফেরত দেয়, তাই পরপর শিকলের মতো লেখা যায়। ফলগুলো Wandbox-এ যাচাই করা:

// CSV লাইন বানানো — কমা শুধু মাঝখানে
String[] fields = {"Rahim", "Dhaka", "25"};
StringBuilder line = new StringBuilder();
for (String f : fields) {
    if (!line.isEmpty()) line.append(',');
    line.append(f);
}
System.out.println(line);          // Rahim,Dhaka,25
// এক লাইনেই: String.join(",", fields) → একই ফল

// একটি শব্দ উল্টানো, তারপর আরও কিছু বদল
var sb = new StringBuilder("Dhaka");
sb.reverse();                      // akahD
sb.insert(0, "[").append("]");     // [akahD]
sb.deleteCharAt(1);                // [kahD]

StringBuffer নতুন কোডে প্রায় লাগে না — একটি লেখা সাধারণত একটি thread-ই বানায়, আর সত্যিই একাধিক thread-এর মধ্যে ভাগ করতে হলে পর্ব ৪০-এর পদ্ধতিগুলো বেশি পরিষ্কার। পুরোনো library আর বইয়ে StringBuffer প্রচুর দেখবেন, তাই নামটি চিনে রাখুন।

৫ · লেখা থেকে সংখ্যা, সংখ্যা থেকে লেখা

কীবোর্ড, ফাইল, ওয়েব ফর্ম — বাইরে থেকে যা আসে সবই লেখা। "500" আর 500 এক জিনিস নয়: প্রথমটির সাথে + 1 করলে আসে "5001". তাই রূপান্তর লাগে দুই দিকেই।

লেখাটি সংখ্যা না হলে parseInt একটি NumberFormatException ছোড়ে। Wandbox-এ Integer.parseInt("12a") চালালে আসে:

Exception in thread "main" java.lang.NumberFormatException: For input string: "12a"

মেসেজটি কোট চিহ্নের ভেতরে হুবহু লেখাটি দেখায় — এটি খুব কাজের। For input string: " 12" দেখলে বুঝবেন সামনে একটি ফাঁকা জায়গা ছিল (parseInt ফাঁকা জায়গা মেনে নেয় না — আগে strip() করুন); For input string: "" মানে ঘরটি খালি ছিল। Exception ধরে সামলানো শিখবেন পর্ব ২৯-এ; আপাতত নিয়ম — বাইরের লেখা সংখ্যায় রূপ দেওয়ার আগে পরিষ্কার আর যাচাই করুন।

বাংলা অঙ্ক — parseInt চেনে, কিন্তু regex-এর \d চেনে না

বাংলাদেশি অ্যাপে ব্যবহারকারী প্রায়ই বাংলা অঙ্কে লেখেন: "১২৩". মজার খবর হলো, Java-র Integer.parseInt প্রতিটি অক্ষরকে Character.digit দিয়ে পড়ে, যা Unicode-এর যেকোনো দশমিক অঙ্ক চেনে। Wandbox-এ (OpenJDK 21) যাচাই করা ফল:

Integer.parseInt("১২৩")            // 123
Integer.parseInt("1২3")            // 123 — মেশানো অঙ্কও চলে!
Character.isDigit('১')             // true
Character.digit('৭', 10)           // 7
"০১৭১২".matches("\\d+")            // false — regex-এর \d মানে শুধু 0-9
"01712".matches("\\d+")            // true

অর্থাৎ একই প্রোগ্রামের দুই জায়গায় দুই রকম আচরণ: regex দিয়ে “শুধু অঙ্ক কি না” যাচাই করলে বাংলা অঙ্কের নম্বর বাতিল হয়ে যাবে, অথচ parseInt সেটিকে দিব্যি পড়তে পারত। আবার উল্টো বিপদ: "1২3"-এর মতো মেশানো লেখাও গৃহীত হয়, যা হয়তো আপনি চান না। কোন অঙ্ক মানবেন, সেটি আপনার সিদ্ধান্ত — কিন্তু যাচাই আর রূপান্তর একই নিয়মে চলছে কি না, তা পরীক্ষা করে নিন।

৬ · বাংলা আর Unicode — length() আসলে কী গোনে

পর্ব ০৪-এ দেখেছেন Java শুরু থেকেই Unicode বোঝে, তাই বাংলা String-এ রাখতে কোনো ঝামেলা নেই। ঝামেলা শুরু হয় গোনার সময়। প্রশ্ন: "বাংলা".length() কত? চোখে তিনটি “অক্ষর” — বা, ং, লা। Java বলে 5.

কারণটি তিন স্তরে বোঝা যায়:

বাংলায় কার-চিহ্ন (া, ি, ু…) আর হসন্ত (্) আলাদা code point. তাই "ক্ষমা".length() হলো 5 (ক, ্, ষ, ম, া), যদিও চোখে দুটি অক্ষর — ক্ষ আর মা। বাংলার সব code point Unicode-এর প্রথম ৬৫,৫৩৬টি নম্বরের মধ্যে পড়ে, তাই বাংলায় code unit আর code point-এর সংখ্যা সমান। কিন্তু emoji-র মতো অক্ষরের নম্বর এর চেয়ে বড়; UTF-16-এ সেগুলো লিখতে দুটি code unit-এর জোড়া লাগে, যাকে বলে surrogate pair. ফলে "😀".length() হলো 2, যদিও codePointCount বলে 1.

তাহলে “দেখা অক্ষর” গুনবেন কীভাবে? JDK-তে java.text.BreakIterator আছে, যা অক্ষরের সীমা খোঁজে, আর Java 9 থেকে regex-এর \X একটি grapheme cluster ধরে। কিন্তু ফল দেখে চমকে যাবেন: OpenJDK 21-এ \X দিয়ে গুনলে "বাংলা" হয় ২ (বাং + লা — Unicode-এর নিয়মে ং আগের অক্ষরের সাথে জুড়ে যায়), আর "ক্ষমা" হয় ৩ (ক্ + ষ + মা — যুক্তাক্ষর ভেঙে যায়)। ২০২৩ সালে Unicode 15.1 ভারতীয় লিপির যুক্তাক্ষরের জন্য নতুন নিয়ম যোগ করেছে, তাই নতুন সংস্করণে এই সংখ্যা বদলাতে পারে। জটিল লিপির নিখুঁত হিসাবের জন্য পেশাদার প্রজেক্টে প্রায়ই ICU4J-এর মতো বাইরের library ব্যবহার হয়। এই কোর্সে মূল শিক্ষাটুকুই যথেষ্ট: length() মানে মেমরির টুকরো, মানুষের চোখের অক্ষর নয়।

৭ · বাস্তব কাজ — ফোন নম্বর, পাসওয়ার্ড, SMS আর বাংলা গোনা

এবার এ পর্যন্ত শেখা সব একসাথে। নিচের প্রোগ্রামে চারটি ছোট কাজ — বাংলাদেশি অ্যাপে প্রতিদিন যা লাগে:

class Main {
    public static void main(String[] args) {
        // ১. ফোন নম্বর পরিষ্কার: +, ফাঁকা আর - বাদ
        String raw = "+880 1712-345678";
        String phone = raw.replace("+", "").replace(" ", "").replace("-", "");
        System.out.println(phone + " valid? " + (phone.length() == 13 && phone.startsWith("8801")));

        // ২. পাসওয়ার্ড নীতি: আগে-পরের ফাঁকা বাদে ৮+ char, অন্তত একটি অঙ্ক
        String pass = "  dhaka2026 ";
        String p = pass.strip();
        boolean ok = p.length() >= 8 && p.chars().anyMatch(Character::isDigit);
        System.out.println("password ok? " + ok + " (" + p.length() + " chars)");

        // ৩. SMS-এ একটি অক্ষর কতবার আছে
        String sms = "Apnar bKash e 500 tk ese geche";
        long count = sms.chars().filter(ch -> ch == 'e').count();
        System.out.println("'e' count: " + count);

        // ৪. বাংলা আর emoji: length() গোনে UTF-16 code unit
        String[] words = {"বাংলা", "ক্ষমা", "😀"};
        for (String w : words) {
            System.out.println(w + " length=" + w.length() + " codePoints=" + w.codePoints().count());
        }
    }
}

আগাম দেখা — format আর text block (পর্ব ০৯)

অনেকগুলো + দিয়ে লেখা সাজানো ঝামেলার। পরের পর্বে শিখবেন ছাঁচ দিয়ে সাজানো: String.format("%-8s|%5.1f", "Rahim", 3.456), বা Java 15 থেকে একই কাজ "%-8s|%5.1f".formatted("Rahim", 3.456) — ফল Rahim | 3.5. আর কয়েক লাইনের লেখা (যেমন একটি JSON বা SQL) \n ছাড়া লেখার জন্য আছে text block — তিনটি ডাবল কোট """ দিয়ে শুরু ও শেষ, Java 15 থেকে স্থায়ী। দুটোই শেষ পর্যন্ত একটি সাধারণ immutable String বানায়। বিস্তারিত পর্ব ০৯-এ।

৮ · AI-এর যুগে — লেখা নিয়ে AI-এর কোড যাচাই

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

AI সাধারণত যে ভুলগুলো করে

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

• কোডে String-এর জন্য কোথাও == বা != নেই (null যাচাই ছাড়া)
• লুপের ভেতরে += দিয়ে লেখা বাড়ানো হচ্ছে না; বড় ইনপুটে (১ লাখ লাইন) চালিয়ে সময় দেখেছি
• প্রতিটি split / replaceAll-এর নকশা আমি বুঝি, আর . | $-এর মতো চিহ্ন escape করা আছে
• বাংলা লেখা, যুক্তাক্ষর আর একটি emoji দিয়ে চালিয়েছি — কোনো অক্ষর ভাঙেনি বা মুছে যায়নি
• “বদলানো” method-এর (strip, replace, toUpperCase) ফল কোনো variable-এ রাখা হয়েছে
• খালি লেখা, শুধু ফাঁকা জায়গা আর null দিয়ে পরীক্ষা করেছি — প্রোগ্রাম অকারণে থেমে যায়নি