מחרוזת ב-Java

מדריכים
Java

מחרוזת Java

  • מהכל, מחרוזת היא סדרה של תווים אך אינה סוג יסודי.
  • כאשר אנו יוצרים מחרוזת ב-Java, זה מציר בעצם אובייקט מסוג String.
  • מחרוזת היא אובייקט לא ניתן לשנות אותו לאחר שנוצר.
  • מחרוזת היא היחידה בה נתמך Overloading של אופרטורים ב-Java. ניתן לחבר שני מחרוזות באמצעות אופרטור +. לדוגמה, "a" + "b" = "ab".
  • Java מספקת שני כיתות שימושיות לניהול מחרוזות – StringBuffer ו־StringBuilder.

בואו נמשיך ונלמד עוד על מחלקת מחרוזת ב-Java.

דרכים שונות ליצירת מחרוזת

ישנן הרבה דרכים ליצירת אובייקט מחרוזת ב-Java, ולהלן כמה מהדרכים הפופולריות.

  1. שימוש בליטרל מחרוזת

    זו הדרך הנפוצה ביותר ליצירת מחרוזת. במקרה זה, ליטרל מחרוזת מסונגרת בגרשיים כפולים.

    String str = "abc";

    כאשר אנו יוצרים מחרוזת באמצעות גרשיים כפולים, ה-JVM מחפשת ב בריכת המחרוזות כדי לראות האם כבר קיימת מחרוזת אחרת עם אותו הערך. אם נמצא, הוא פשוט מחזיר את ההפניה לאותו אובייקט מחרוזת, אחרת הוא יוצר אובייקט מחרוזת חדש עם הערך הנתון ומאחסן אותו בבריכת המחרוזות.

  2. שימוש במילת המפתח החדשה

    ניתן ליצור אובייקט String באמצעות אופרטור ה-new, בדומה לכל מחלקה רגילה ב-Java. קיימים מספר בנאיים זמינים במחלקת String לקבלת מחרוזת ממערך char, ממערך byte, מ-StringBuffer ומ-StringBuilder.

    String str  =  new String("abc");
char[] a = {'a', 'b', 'c'};
String str2  =  new String(a);

השוואת מחרוזות ב-Java

מחלקת String מספקת את השיטות equals() ו־equalsIgnoreCase() להשוואת שתי מחרוזות. שיטות אלו משוותות את ערך המחרוזת כדי לבדוק האם שתי מחרוזות זהות או לא. הן מחזירות true אם שתי המחרוזות זהות ו־false אם לא.

package com.journaldev.string.examples;

/**
 * Java String Example
 * 
 * @author pankaj
 *
 */
public class StringEqualExample {

	public static void main(String[] args) {
		//יצירת שני אובייקטי מחרוזת
		String s1 = "abc";
		String s2 = "abc";
		String s3 = "def";
		String s4 = "ABC";
		
		System.out.println(s1.equals(s2));//true
		System.out.println(s2.equals(s3));//false
		
		System.out.println(s1.equals(s4));//false;
		System.out.println(s1.equalsIgnoreCase(s4));//true
	}

}

פלט של התוכנית למעלה הוא:

true
false
false
true

המחלקה String מיישמת את הממשק Comparable, שספקת את השיטות compareTo() ו- compareToIgnoreCase(). המחלקה משווה בין שני מחרוזות לפי סדר לקסיקוגרפי. שתי המחרוזות מומרות לערכי Unicode לצורך השוואה ומחזירות ערך שהוא מספר שלם, שיכול להיות גדול מ-0, קטן מ-0, או שווה ל-0. אם המחרוזות זהות, היא מחזירה 0, אחרת היא מחזירה ערך שלם הגדול או קטן מ-0.

package com.journaldev.examples;

/**
 * Java String compareTo Example
 * 
 * @author pankaj
 *
 */
public class StringCompareToExample {

	public static void main(String[] args) {
		
		String a1 = "abc";
		String a2 = "abc";
		String a3 = "def";
		String a4 = "ABC";
		
		System.out.println(a1.compareTo(a2));//0
		System.out.println(a2.compareTo(a3));//less than 0
		System.out.println(a1.compareTo(a4));//greater than 0
		System.out.println(a1.compareToIgnoreCase(a4));//0
	}

}

פלט של התוכנית הנלמדת הוא:

0
-3
32
0

נא לקרוא עוד בפרטים בדוגמא בקישור String compareTo example.

שיטות String ב-Java

בואו נסתכל על חלק מהשיטות הפופולריות של מחלקת String, עם דוגמה לתוכנית.

  1. split()

    שיטת split() ב־Java String משמשת לפיצול המחרוזת באמצעות הביטוי הנתון. ישנם שני גרסאות של שיטת split().

    • split(String regex): שיטה זו פוצלת את המחרוזת באמצעות ביטוי הרגולרי הנתון ומחזירה מערך של מחרוזות.
    • split(String regex, int limit): שיטה זו פוצלת את המחרוזת באמצעות ביטוי הרגולרי הנתון ומחזירה מערך של מחרוזות, אך גודל האיבר במערך מוגבל על ידי המגבלה המצויה. אם המגבלה המצויה היא 2, אז השיטה מחזירה מערך בגודל 2.
    package com.journaldev.examples;

/**
 * דוגמא ל־Java String split
 * 
 * @author pankaj
 *
 */
public class StringSplitExample {

	public static void main(String[] args) {
		
		String s = "a/b/c/d";
		String[] a1 = s.split("/");
		System.out.println("פיצול המחרוזת באמצעות ביטוי רגולרי בלבד:");
		for (String string : a1) {
			System.out.println(string);
		}
		System.out.println("פיצול המחרוזת באמצעות ביטוי רגולרי עם מגבלה:");
		String[] a2 = s.split("/", 2);
		for (String string : a2) {
			System.out.println(string);
		}
	}

}

    הפלט של התוכנית לעיל הוא:

    פיצול המחרוזת באמצעות ביטוי רגולרי בלבד:
a
b
c
d
פיצול המחרוזת באמצעות ביטוי רגולרי עם מגבלה:
a
b/c/d

  2. contains(CharSequence s)

    שיטות contains ב־Java String בודקות אם המחרוזת מכילה סדרת תווים מסוימת או לא. שיטה זו מחזירה true אם המחרוזת מכילה את הסדרה המצויה, אחרת היא מחזירה false.

    package com.journaldev.examples;

/**
 * Java String contains() Example
 * 
 * @author pankaj
 *
 */
public class StringContainsExample {

	public static void main(String[] args) {
		String s = "Hello World";
		
		System.out.println(s.contains("W"));//true
		System.out.println(s.contains("X"));//false
	}

}

    פלט התוכנית למעלה הוא:

    true
false

  3. אורך()

    שיטת length() של מחרוזת ב-Java מחזירה את אורך המחרוזת.

    package com.journaldev.examples;

/**
 * אורך מחרוזת ב-Java
 * 
 * @author pankaj
 *
 */
public class StringLengthExample {

	public static void main(String[] args) {
		
		String s1 = "abc";
		String s2 = "abcdef";
		String s3 = "abcdefghi";
		
		System.out.println(s1.length());//3
		System.out.println(s2.length());//6
		System.out.println(s3.length());//9

	}

}

  4. replace()

    שיטת replace() ב־Java String משמשת להחלפת חלק מסויים של מחרוזת עם מחרוזת אחרת. יש ארבעה גרסאות של שיטת replace().

    • replace(char oldChar, char newChar): שיטה זו מחליפה את כל ההופעות של oldChar ב־newChar במחרוזת.
    • replace(CharSequence target, CharSequence replacement): שיטה זו מחליפה כל אחת מההופעות של המחרוזת target במחרוזת replacement במחרוזת.
    • replaceAll(String regex, String replacement): שיטה זו מחליפה את כל ההופעות של מחרוזת משתנה שתואמת את regex הספציפי עם המחרוזת replacement הספציפית במחרוזת.
    • replaceFirst(String regex, String replacement): שיטה זו מחליפה את ההופעה הראשונה של מחרוזת משתנה שתואמת את regex הספציפי עם המחרוזת replacement הספציפית במחרוזת.
    package com.journaldev.examples;

/**
 * Java String replace
 * 
 * @author pankaj
 *
 */
public class StringReplaceExample {

	public static void main(String[] args) {
		
		//replace(char oldChar,  char newChar)
		String s = "Hello World";
		s = s.replace('l', 'm');
		System.out.println("After Replacing l with m :");
		System.out.println(s);
		
		//replaceAll(String regex, String replacement)
		String s1 = "Hello journaldev, Hello pankaj";
		s1 = s1.replaceAll("Hello", "Hi");
		System.out.println("After Replacing :");
		System.out.println(s1);
		
		//replaceFirst(String regex, String replacement) 
		String s2 = "Hello guys, Hello world";
		s2 = s2.replaceFirst("Hello", "Hi");
		System.out.println("After Replacing :");
		System.out.println(s2);

	}

}

    פלט התוכנית לעיל הוא:

    After Replacing l with m :
Hemmo Wormd
After Replacing :
Hi journaldev, Hi pankaj
After Replacing :
Hi guys, Hello world

  5. format()

    שיטת format() ב-Java משמשת לעיצוב המחרוזת. ישנם שני וריאנטים לשיטת format() ב-Java.

    • format(Locale l, String format, Object… args): שיטה זו מעצבת את המחרוזת באמצעות הלוקאל, פורמט המחרוזת והארגומנטים הנתונים.
    • format(String format, Object… args): שיטה זו מעצבת את המחרוזת באמצעות פורמט המחרוזת והארגומנטים הנתונים.
    package com.journaldev.examples;

import java.util.Locale;

/**
 * עיצוב מחרוזת ב-Java
 * 
 * @author pankaj
 *
 */
public class StringFormatExample {

	public static void main(String[] args) {
		
		String s = "journaldev.com";
		// %s משמש להוספת המחרוזת
		System.out.println(String.format("זוהי %s", s));
		
		//שימוש בלוקאל כמו Locale.US
		System.out.println(String.format(Locale.US, "%f", 3.14));
	}
}

    הפלט של התוכנית לעיל הוא:

    זוהי journaldev.com
3.140000

  6. substring()

    שיטה זו מחזירה חלק מהמחרוזת על פי אינדקסים מסוימים.

    package com.journaldev.examples;

/**
 * Java String substring
 *
 */
public class StringSubStringExample {

	public static void main(String[] args) {
		
		String s = "זוהי דוגמה ל-journaldev.com";
		s = s.substring(8,18);
		System.out.println(s);
	}
}

איחוד מחרוזות

איחוד מחרוזות הוא פעולה בסיסית מאוד ב-Java. ניתן לאחד מחרוזות על ידי השימוש באופרטור "+" או באמצעות שימוש במתודה concat().

package com.journaldev.examples;

/**
 * Java String concatenation
 * 
 * @author pankaj
 *
 */
public class StringConcatExample {

	public static void main(String[] args) {
		
		String s1 = "Hello";
		String s2 = "World";
		String s3 = s1 + s2;
		//שימוש באופרטור +
		System.out.println("Using + operator: ");
		System.out.println(s3);
		
		//שימוש במתודת concat
		System.out.println("Using concat method: ");
		System.out.println(s1.concat(s2));

	}

}

הפלט של התוכנית לעיל הוא:

Using + operator: 
HelloWorld
Using concat method: 
HelloWorld

בדוק פוסט זה לקבלת מידע נוסף על איחוד מחרוזות ב-Java.

בריכת המחרוזות של Java

ניהול זיכרון הוא הנושא החשוב ביותר בכל שפת תכנות. ניהול זיכרון במקרה של מחרוזת ב-Java מעט שונה מכל קלאס אחר. כדי לשפר את יעילות הזיכרון ב-Java, ה-JVM הציבה אזור זיכרון מיוחד עבור המחרוזת הנקרא String Constant Pool. כאשר אנו יוצרים מחרוזת ליטרלית, היא בודקת האם כבר קיימת מחרוזת זהה בבריכת המחרוזת או לא. אם היא כבר קיימת, היא תחזיר את ההפניה למחרוזת הקיימת בבריכת המחרוזת. בואו נסתכל על דוגמה לתוכנית למטה.

package com.journaldev.examples;

/**
 * Java String Pool Example
 * 
 */
public class StringPoolExample {

	public static void main(String[] args) {
		
		String a = "abc";
		String b = "abc";
		String c = "def";
		
		//הפניה זוהה
		if (a==b) {
			System.out.println("Both string refer to the same object");
		}
		
		//הפניה שונה
		if (a==c) {
			System.out.println("Both strings refer to the same object");
		}else {
			System.out.println("Both strings refer to the different object");
		}

	}

}

הפלט של התוכנית למעלה הוא:

Both string refer to the same object
Both strings refer to the different object

בדוק פוסט זה למידע נוסף על בריכת המחרוזת של Java.

שיטת intern() של String

כאשר אנו יוצרים מחרוזת באמצעות ליטרל מחרוזת, היא תיווצר בבריכת המחרוזת, אך מה קורה אם ניצור מחרוזת באמצעות המילה המפתח new עם אותו ערך שכבר קיים בבריכת המחרוזת? האם אנו יכולים להעביר את המחרוזת מזיכרון ההשקעה לבריכת המחרוזת? לכך משמשת שיטת intern() והיא מחזירה תיאור קנוני של אובייקט מחרוזת. כאשר אנו קוראים לשיטת intern() על אובייקט מחרוזת שנוצר באמצעות המילה המפתח new, היא בודקת האם כבר קיימת מחרוזת עם אותו ערך בבריכה? אם כן, אז היא מחזירה את ההפניה לאותו אובייקט מחרוזת מהבריכה. אם לא, אז היא יוצרת מחדש מחרוזת עם התוכן הזהה בבריכה ומחזירה את ההפניה.

package com.journaldev.examples;

/**
 * Java String intern
 * 
 * @author pankaj
 *
 */
public class StringInternExample {

	public static void main(String[] args) {
		
		String s1 = "pankaj";
		String s2 = "pankaj";
		String s3 = new String("pankaj");
		
		System.out.println(s1==s2);//true
		System.out.println(s2==s3);//false
		
		String s4 = s3.intern();
		System.out.println(s1==s4);//true

	}

}

בדוק את הפוסט הזה כדי ללמוד עוד על שיטת intern של מחרוזת ב־Java.

יתרונות העצמיות של מחרוזת

חלק מהיתרונות של היותה של מחרוזת מחלקת עצמים הם:

  1. בריכת קבועי המחרוזות, ולכן חוסך בזיכרון.
  2. ביטחון מתוך שאי אפשר לשנות אותה.
  3. בטוח לפני תהליכי תקינה
  4. אבטחת טעינת מחלקות

בדוק את הפוסט הזה למידע נוסף על יתרונות עצמיות של מחרוזת.

שיטת join() ב־Java 8

A new static method join() has been added in String class in Java 8. This method returns a new String composed of copies of the CharSequence elements joined together with a copy of the specified delimiter. Let’s look at an example to understand it easily.

List<String> words = Arrays.asList(new String[]{"Hello", "World", "2019"});
String msg = String.join(" ", words);
System.out.println(msg);

פלט: Hello World 2019

שיטות מחרוזת ב־Java 9

קיימות שתי שיטות שנוספו למחלקת מחרוזת בגרסת Java 9. הן – codePoints() ו־chars(). שתי השיטות הללו מחזירות אובייקט IntStream עליו נוכל לבצע פעולות מסוימות. בואו נציץ מהיר על שתי השיטות האלו.

String s = "abc";

s.codePoints().forEach(x -> System.out.println(x));

s.chars().forEach(x -> System.out.println(x));

פלט:

97
98
99
97
98
99

מתודות חדשות במחלקת String של Java 11

קיימות מספר מתודות חדשות שנוספו למחלקת String בגרסת Java 11.

  • isBlank() – מחזירה true אם המחרוזת ריקה או מכילה רק נקודות קוד של רווחים, אחרת מחזירה false.
  • lines() – מחזירה זרם של שורות שנישקצו מהמחרוזת הזו, מופרדות על ידי מסיימי שורות.
  • strip(), stripLeading(), stripTrailing() – להסרת רווחים ראשיים וסופיים מהמחרוזת.
  • repeat() – מחזירה מחרוזת שערכה הוא החיבור של המחרוזת הזו שוב ושוב מספר הפעמים הנתון.

בואו נסתכל על דוגמה לתוכנית עבור מתודות אלו.

package com.journaldev.strings;

import java.util.List;
import java.util.stream.Collectors;

/**
 * JDK 11 New Functions in String class
 * 
 * @author pankaj
 *
 */
public class JDK11StringFunctions {

	public static void main(String[] args) {
		// isBlank()
		String s = "abc";
		System.out.println(s.isBlank());
		s = "";
		System.out.println(s.isBlank());

		// lines()
		String s1 = "Hi\nHello\rHowdy";
		System.out.println(s1);
		List lines = s1.lines().collect(Collectors.toList());
		System.out.println(lines);

		// strip(), stripLeading(), stripTrailing()
		String s2 = "  Java,  \tPython\t ";
		System.out.println("#" + s2 + "#");
		System.out.println("#" + s2.strip() + "#");
		System.out.println("#" + s2.stripLeading() + "#");
		System.out.println("#" + s2.stripTrailing() + "#");

		// repeat()
		String s3 = "Hello\n";
		System.out.println(s3.repeat(3));
		s3 = "Co";
		System.out.println(s3.repeat(2));

	}

}

פלט:

false
true
Hi
Hello
Howdy
[Hi, Hello, Howdy]
#  Java,  	Python	 #
#Java,  	Python#
#Java,  	Python	 #
#  Java,  	Python#
Hello
Hello
Hello

CoCo

זהו הכל על מחלקת String של Java, המתודות שלה ודוגמאות לעיבוד מחרוזות.

ניתן לבדוק דוגמאות נוספות של מחרוזות במאגר ה-GitHub שלנו.

הקישור: מסמך ה-API

Source:
https://www.digitalocean.com/community/tutorials/java-string