السلاسل النصية في Java: الإنشاء والدمج واستخدام دوال String

ما هي السلسلة النصية (String)

تحمل String سلسلة من الأحرف - نصًّا مثل اسم أو جملة أو سطر مقروء من ملف. رأيت String مدرجة ضمن الأنواع المرجعية في الصفحة السابقة؛ وهنا ستتعامل معها فعليًّا. تكتب السلسلة النصية الحرفية (literal) بعلامتي اقتباس مزدوجتين (علامتا الاقتباس المفردتان محجوزتان لحرف char واحد):

public class Main {
    public static void main(String[] args) {
        String greeting = "Hello, world";
        String empty = "";
        String name = "Ada";

        System.out.println(greeting);
        System.out.println("Name has " + name.length() + " characters");
    }
}

تُرجع name.length() عدد الأحرف - 3 بالنسبة إلى "Ada". إنها استدعاء لدالة، لذا تحتاج إلى الأقواس.

دمج السلاسل النصية

يلصق العامل + السلاسل النصية معًا. إذا كان أي من طرفي + سلسلة نصية، فإن الطرف الآخر يُحوَّل إلى نص تلقائيًّا، لذا يمكنك مزج الأرقام والقيم المنطقية (boolean) دون أي عمل إضافي:

public class Main {
    public static void main(String[] args) {
        String first = "Ada";
        String last = "Lovelace";

        String full = first + " " + last;
        System.out.println(full);

        int age = 36;
        System.out.println(full + " is " + age + " years old");
    }
}

انتبه إلى أمر مهم: لأن + يُقيَّم من البداية إلى النهاية، فإن "" + 1 + 2 يُنتج "12" (سلسلة نصية + int، ثم سلسلة نصية + int)، لكن 1 + 2 + "" يُنتج "3" (يُجمع العددان الصحيحان أولًا، ثم يتحوّلان إلى نص). عند الشك، ضع العمليات الحسابية بين قوسين.

السلاسل النصية غير قابلة للتغيير

هذا أهم ما يجب فهمه عن السلاسل النصية في Java: لا تتغير String أبدًا بعد إنشائها. كل دالة "تعدّل" سلسلة نصية تُرجع في الواقع سلسلة جديدة تمامًا وتترك الأصلية دون مساس. لذا إذا نسيت التقاط القيمة المُرجَعة، فلن يحدث شيء:

public class Main {
    public static void main(String[] args) {
        String s = "hello";

        s.toUpperCase();              // النتيجة مُهمَلة - خطأ برمجي!
        System.out.println(s);        // ما زالت "hello"

        s = s.toUpperCase();          // التقط السلسلة الجديدة
        System.out.println(s);        // الآن "HELLO"
    }
}

يحسب الاستدعاء الأول "HELLO" ثم يتخلص منها فورًا. السطر الثاني وحده، الذي يُسند القيمة من جديد إلى s، هو الذي يُحدث أثرًا ظاهرًا. يقع في هذا الفخ كل المبرمجين تقريبًا مرة واحدة على الأقل.

مقارنة السلاسل النصية

استخدم .equals() لمقارنة محتوى سلسلتين نصيتين. اللجوء إلى == هو الخطأ الكلاسيكي للمبتدئين: يسأل == "هل هما الكائن نفسه في الذاكرة؟"، وليس "هل يحملان النص نفسه؟":

public class Main {
    public static void main(String[] args) {
        String a = "code";
        String b = new String("code");

        System.out.println(a == b);            // false - different objects
        System.out.println(a.equals(b));       // true  - same characters

        System.out.println("Hi".equalsIgnoreCase("hi"));  // true
    }
}

تكون a == b هنا false لأن new String(...) يفرض إنشاء كائن منفصل. قارن دائمًا قيم السلاسل النصية باستخدام .equals() (أو .equalsIgnoreCase() لتجاهل حالة الأحرف). من الحيل المفيدة لتجنّب الانهيار عندما يكون أحد الطرفين قد يساوي null أن تستدعي .equals على السلسلة الحرفية: "yes".equals(input) لا ترمي استثناءً أبدًا حتى لو كانت input تساوي null.

دوال String اليومية

لأن السلاسل النصية غير قابلة للتغيير، فإن كلًّا من هذه الدوال يُرجع سلسلة جديدة (أو قيمة) بدلًا من تعديل الأصلية. هذه هي الدوال التي ستلجأ إليها باستمرار:

public class Main {
    public static void main(String[] args) {
        String s = "  Coddy Java  ";

        System.out.println(s.trim());              // "Coddy Java"
        System.out.println(s.trim().toUpperCase()); // "CODDY JAVA"
        System.out.println(s.contains("Java"));    // true
        System.out.println(s.indexOf("Java"));     // 8
        System.out.println("Coddy".charAt(0));     // 'C'
        System.out.println("a,b,c".split(",").length); // 3
        System.out.println("hello".replace("l", "L")); // "heLLo"
    }
}

لاحظ التسلسل (chaining): تعمل s.trim().toUpperCase() لأن trim() تُرجع سلسلة نصية، ثم تستدعي عليها toUpperCase(). وsubstring أداة أساسية أخرى - تأخذ فهرس البداية (شامل) وفهرس النهاية الاختياري (غير شامل):

public class Main {
    public static void main(String[] args) {
        String date = "2026-06-04";

        System.out.println(date.substring(0, 4));  // "2026"
        System.out.println(date.substring(5));     // "06-04"
    }
}

تبدأ الفهارس من الصفر، لذا تلتقط substring(0, 4) الأحرف من 0 إلى 3. طلب فهرس يتجاوز النهاية يرمي استثناء StringIndexOutOfBoundsException.

بناء السلاسل النصية داخل حلقة

الدمج باستخدام + لا بأس به لبضع قطع، لكن القيام به داخل حلقة كبيرة بطيء - فكل + يُنشئ سلسلة جديدة وينسخ كل شيء. عندما تجمّع نصًّا داخل حلقة، استخدم StringBuilder، الذي يُعدّل مخزنًا مؤقتًا في مكانه وينتج السلسلة النهائية مرة واحدة في النهاية:

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 5; i++) {
            sb.append(i).append(" ");
        }
        String result = sb.toString().trim();
        System.out.println(result);   // "1 2 3 4 5"
    }
}

تُرجع append الباني (builder) نفسه، فتتسلسل الاستدعاءات. استدعِ .toString() في النهاية للحصول على String عادية. للدمج لمرة واحدة، التزم بـ +؛ ولتجميع قطع كثيرة، يكون StringBuilder هو الأداة المناسبة.

التالي: تنسيق السلاسل النصية

يصبح الدمج فوضويًّا بمجرد أن تحتاج إلى أعمدة منتظمة المحاذاة، أو خانات عشرية ثابتة، أو أرقام محشوّة بأصفار. تستخدم دالتا Java String.format وprintf قالبًا يحتوي على عناصر نائبة % للتعامل مع كل ذلك بأناقة - وهذا موضوع الصفحة التالية.