מחרוזות (String)

מהי String?

String היא מחלקה ב-Java שמייצגת טקסט - רצף של תווים. בניגוד לטיפוסים הפרימיטיביים, String היא אובייקט, לא פרימיטיב.

יצירה

דרך ליטרל (הנפוצה)

String name = "נפתלי";
String greeting = "שלום עולם";

דרך new

String name = new String("נפתלי");

בדרך כלל מעדיפים את הדרך הראשונה - היא יעילה יותר.

תכונה קריטית: אי-שינוי (Immutable)

String ב-Java היא מחלקה immutable - אחרי שיצרת אותה, אי אפשר לשנות אותה. כל פעולה שנראית כמו "שינוי" - באמת יוצרת מחרוזת חדשה.

String s = "hello";
s.toUpperCase();              // לא משנה את s!
System.out.println(s);        // "hello"

s = s.toUpperCase();          // עכשיו s = "HELLO"

מתודות שימושיות

אורך

String text = "שלום";
int length = text.length();   // 4

תו במיקום

char ch = text.charAt(0);     // 'ש'

אותיות גדולות/קטנות

"Hello".toUpperCase();   // "HELLO"
"Hello".toLowerCase();   // "hello"

חיתוך מחרוזת

String s = "Hello World";
s.substring(6);        // "World" (מ-6 עד הסוף)
s.substring(0, 5);     // "Hello" (מ-0 עד 5, לא כולל)

חיפוש

String s = "Hello World";
s.indexOf('o');          // 4 (המופע הראשון)
s.indexOf("World");      // 6
s.lastIndexOf('o');      // 7
s.contains("World");     // true

החלפה

"Hello World".replace('l', 'L');      // "HeLLo WorLd"
"Hello World".replace("World", "Java"); // "Hello Java"

הסרת רווחים מההתחלה והסוף

"  hello  ".trim();    // "hello"

פיצול

String csv = "apple,banana,cherry";
String[] parts = csv.split(",");
// parts[0] = "apple", parts[1] = "banana", parts[2] = "cherry"

השוואה

String a = "hello";
String b = "hello";

a == b              // לא בטוח! זה משווה הפניות
a.equals(b)         // true - הדרך הנכונה
a.equalsIgnoreCase("HELLO")  // true

חוק: לעולם אל תשתמשו ב-== להשוואת מחרוזות. תמיד השתמשו ב-.equals().

שרשור (Concatenation)

עם +

String name = "נפתלי";
int age = 30;
String result = "שם: " + name + ", גיל: " + age;

עם concat

String a = "Hello";
String b = " World";
String c = a.concat(b);   // "Hello World"

עם StringBuilder (ליעילות)

כשיש הרבה שרשורים בלולאה:

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++) {
    sb.append(i).append(",");
}
String result = sb.toString();

למה StringBuilder? כי כל שרשור עם + יוצר מחרוזת חדשה. בלולאה זה הרבה זבל לזיכרון. StringBuilder בונה מחרוזת אחת ביעילות.

תווים מיוחדים

String tab = "עמודה1\tעמודה2";       // טאב
String newline = "שורה1\nשורה2";     // ירידת שורה
String quote = "הוא אמר \"שלום\"";    // גרשיים כפולים
String backslash = "C:\\folder";      // backslash

בדיקות שימושיות

"".isEmpty();            // true - מחרוזת ריקה
"  ".isBlank();          // true - רק רווחים
"hello".startsWith("he"); // true
"hello".endsWith("lo");   // true

המרה ממחרוזת למספר

int n = Integer.parseInt("42");
double d = Double.parseDouble("3.14");
long l = Long.parseLong("9999999999");

המרה ממספר למחרוזת

String s1 = String.valueOf(42);
String s2 = Integer.toString(42);
String s3 = "" + 42;               // טריק עצלני, עובד

פורמוט

String formatted = String.format("שם: %s, גיל: %d", "נפתלי", 30);

בדקו את עצמכם

נסו לענות לבד לפני שאתם פותחים את התשובה.

  1. איך משווים תוכן של שתי מחרוזות ב-Java?

    1. a = b
    2. a == b
    3. a.equals(b)
    4. compare(a, b)
    הצגת התשובה

    תשובה ג. == משווה אם זה אותו אובייקט בזיכרון, ו-equals() משווה את התוכן עצמו.

  2. מה המשמעות של "String היא immutable"?

    1. אי אפשר ליצור מחרוזת חדשה
    2. אחרי שנוצרה אי אפשר לשנות אותה, וכל "שינוי" יוצר מחרוזת חדשה
    3. String היא טיפוס פרימיטיבי
    4. אפשר לשנות רק את האות הראשונה
    הצגת התשובה

    תשובה ב. פעולות כמו toUpperCase או replace מחזירות מחרוזת חדשה, והמקורית לא משתנה.

  3. למה משתמשים ב-StringBuilder בלולאה?

    1. כי + לא עובד בלולאות
    2. כי הוא מקצר את הקוד
    3. כי StringBuilder מדפיס אוטומטית
    4. כי שרשור עם + יוצר מחרוזת חדשה בכל סיבוב, ו-StringBuilder בונה אחת ביעילות
    הצגת התשובה

    תשובה ד. הרבה שרשורים עם + מייצרים הרבה אובייקטים זמניים. StringBuilder משנה חוצץ אחד.