כיתת מחרוזת ב-Java

המחלקה String ב-Java מיועדת לעבוד עם מחרוזות ב-Java. כל מילות המחרוזת המוגדרות בתוכנית Java (לדוגמה, "abc") הם מופעים של המחלקה String. בואו נסתכל על המאפיינים העיקריים שלו:

1. הכיתה מיישמת את ה- Serializableand ממשקים CharSequence. מכיוון שהוא כלול בחבילה java.lang, אין צורך לייבא אותו.
2. כיתת ה-String ב-Java היא כיתה אחרונה ואינה יכולה להביא ילדים.
3. המחלקה String היא מחלקה בלתי ניתנת לשינוי, כלומר לא ניתן לשנות את האובייקטים שלה לאחר יצירתם. כל פעולה על אובייקט String שתגרום לאובייקט של המחלקה String תגרום ליצירת אובייקט חדש.
4. בשל חוסר השינוי שלהם, אובייקטים בכיתה String הם בטוחים בשרשרת וניתן להשתמש בהם בסביבה מרובה הליכי.
5. ניתן להמיר כל אובייקט ב-Java למחרוזת באמצעות שיטה toStringשכל מחלקות Java יורשות מהמחלקה Object.

עבודה עם Java String

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

יצירת מחרוזות

הדרך הקלה ביותר ליצור מופע של המחלקה String היא להקצות לו את הערך של מחרוזת מילולית:

String s = "I love movies";

עם זאת, למחלקה String יש בנאים רבים המאפשרים לך:

• ליצור אובייקט המכיל מחרוזת ריקה
• ליצור עותק של משתנה מחרוזת
• ליצור מחרוזת המבוססת על מערך תווים
• צור מחרוזת המבוססת על מערך בתים (בהתחשב בקידודים)
• וכו '

תוספת מחרוזת

הוספת שתי מחרוזות ב-Java היא די פשוטה באמצעות ה- +. ג'אווה מאפשרת לך להוסיף גם משתנים וגם מילולי מחרוזת זה לזה:

public static void main(String[] args) {
    String day = "Day";
    String and = "And";
    String night = "Night";

    String dayAndNight = day + " " + and + " " + night;
}

על ידי הוספת אובייקטים של המחלקה String עם אובייקטים של מחלקות אחרות, אנו מצמצמים את האחרון לצורת מחרוזת. המרה של אובייקטים של מחלקות אחרות לייצוג מחרוזת מתבצעת באמצעות קריאת מתודה מרומזת toStringעל האובייקט. בואו נדגים זאת בעזרת הדוגמה הבאה:

public class StringExamples {
    public static void main(String[] args) {
        Human max = new Human("Max");
        String out = "java object: " + max;
        System.out.println(out);
        // Output: Java object: Person named Max
    }

    static class Human {
        private String name;

        public Human(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "The Man with the Name" + name;
        }
    }
}

השוואת מחרוזות

כדי להשוות מחרוזות, אתה יכול להשתמש בשיטה equals():

public static void main(String[] args) {
    String x = "Test String";
    System.out.println("Test String".equals(x)); // true
}

כאשר המקרה אינו חשוב לנו בעת השוואת מחרוזות, עלינו להשתמש בשיטה equalsIgnoreCase():

public static void main(String[] args) {
       String x = "Test String";
       System.out.println("test string".equalsIgnoreCase(x)); // true
}

המרת אובייקט/פרימיטיבי למחרוזת

כדי להמיר מופע של כל מחלקת Java או כל סוג נתונים פרימיטיבי לייצוג מחרוזת, אתה יכול להשתמש בשיטה String.valueOf():

public class StringExamples {
    public static void main(String[] args) {
        String a = String.valueOf(1);
        String b = String.valueOf(12.0D);
        String c = String.valueOf(123.4F);
        String d = String.valueOf(123456L);
        String s = String.valueOf(true);
        String human = String.valueOf(new Human("Alex"));

        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
        System.out.println(s);
        System.out.println(human);
        /*
        Output:
        1
        12.0
        123.4
        123456
        true
        Person named Alex
         */
    }

    static class Human {
        private String name;

        public Human(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "The Man with the Name" + name;
        }
    }
}

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

לעתים קרובות אתה צריך להמיר מחרוזת למספר. לשיעורי עטיפת סוג פרימיטיבי יש שיטות המשרתות בדיוק את המטרה הזו. כל השיטות הללו מתחילות במילה ניתוח. שקול את התרגום של מחרוזת למספרים שלמים ( Integer) ושברים ( Double) להלן:

public static void main(String[] args) {
    Integer i = Integer.parseInt("12");
    Double d = Double.parseDouble("12.65D");

    System.out.println(i); // 12
    System.out.println(d); // 12.65
}

המרת אוסף של מחרוזות לייצוג מחרוזות

אם אתה צריך להמיר את כל האלמנטים של אוסף מחרוזות כלשהו לייצוג מחרוזת באמצעות מפריד שרירותי, אתה יכול להשתמש בשיטות הבאות של המחלקה Java String:

• join(CharSequence delimiter, CharSequence... elements)
• join(CharSequence delimiter, Iterable<? extends CharSequence> elements)

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

public static void main(String[] args) {
    List<String> people = Arrays.asList(
            "Philip J. Fry",
            "Turanga Leela",
            "Bender Bending Rodriguez",
            "Hubert Farnsworth",
            "Hermes Conrad",
            "John D. Zoidberg",
            "Amy Wong"
    );

    String peopleString = String.join("; ", people);
    System.out.println(peopleString);
    /*
    Output:
    Philip J. Fry; Turanga Leela; Bender Bending Rodriguez; Hubert Farnsworth; Hermes Conrad; John D. Zoidberg; Amy Wong
     */
}

פיצול מיתר למערך של מיתרים

פעולה זו מבוצעת בשיטה split(String regex) המפריד הוא ביטוי רגולרי מחרוזת regex. בדוגמה למטה, נבצע פעולה הפוכה מזו שביצענו בדוגמה הקודמת:

public static void main(String[] args) {
    String people = "Philip J. Fry; Turanga Leela; Bender Bending Rodriguez; Hubert Farnsworth; Hermes Conrad; John D. Zoidberg; Amy Wong";

    String[] peopleArray = people.split("; ");
    for (String human : peopleArray) {
        System.out.println(human);
    }
    /*
    Output:
    Philip J. Fry
    Turanga Leela
    Bender Bending Rodriguez
    Hubert Farnsworth
    Hermes Conrad
    John D. Zoidberg
    Amy Wong
     */
}

קביעת מיקומו של אלמנט בקו

בשפת Java, String מספק קבוצה של שיטות לקביעת המיקום של תו/מחרוזת משנה במחרוזת:

1. indexOf(int ch)
2. indexOf(int ch, int fromIndex)
3. indexOf(String str)
4. indexOf(String str, int fromIndex)
5. lastIndexOf(int ch)
6. lastIndexOf(int ch, int fromIndex)
7. lastIndexOf(String str)
8. lastIndexOf(String str, int fromIndex)

איפה:

1. ch- הסמל שאתה מחפש ( char)
2. str- מחרוזת חיפוש
3. fromIndex- המיקום שממנו לחפש את האלמנט
4. שיטות indexOf- החזר את המיקום של האלמנט הראשון שנמצא
5. שיטות lastIndexOf- החזר את המיקום של האלמנט האחרון שנמצא

אם האלמנט שאתה מחפש לא נמצא, השיטות יחזירו את שורה -1. בואו ננסה למצוא את המספר הסידורי של האותיות A, K, Z, Яבאלפבית האנגלי, אך זכור שהאינדקס של תווים במחרוזת ב-Java מתחיל מאפס:

public static void main(String[] args) {
    String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    System.out.println(alphabet.indexOf('A')); // 0
    System.out.println(alphabet.indexOf('K')); // 10
    System.out.println(alphabet.indexOf('Z')); // 25
    System.out.println(alphabet.indexOf('Я')); // -1
}

חילוץ מחרוזת משנה ממחרוזת

כדי לחלץ מחרוזת משנה ממחרוזת, המחלקה String ב-Java מספקת שיטות:

• substring(int beginIndex)
• substring(int beginIndex, int endIndex)

בואו נסתכל כיצד נוכל להשתמש בשיטות מיצוב האלמנטים וחילוץ המחרוזות כדי לקבל את שם הקובץ מהנתיב שלו:

public static void main(String[] args) {
    String filePath = "D:\\Movies\\Futurama.mp4";
    int lastFileSeparatorIndex = filePath.lastIndexOf('\\');
    String fileName = filePath.substring(lastFileSeparatorIndex + 1);
    System.out.println(fileName); //9
}

המרת מחרוזת לאותיות גדולות/קטנות:

המחלקה String מספקת שיטות להמרת מחרוזת לאותיות גדולות וקטנות:

• toLowerCase()
• toUpperCase()

הבה נבחן כיצד פועלות השיטות הללו באמצעות דוגמה:

public static void main(String[] args) {
    String fry = "Philip J. Fry";

    String lowerCaseFry = fry.toLowerCase();
    String upperCaseFry = fry.toUpperCase();

    System.out.println(lowerCaseFry); // philip j. fry
    System.out.println(upperCaseFry); // PHILIP J. FRY
}

העבודה עם שיעור Java זה נלמד ברמות הראשוניות של הקורס המקוון JavaRush:

• מבוא למחרוזת ניתן ברמה 1, הרצאה 4 של קווסט Java Syntax
• המבנה הפנימי של String, שיטת המשנה נלמדת ברמה 2, הרצאה 3 של קווסט Java Multithreading
• מציאת, השגת, מחיקת מחרוזת משנה במחרוזת נלמדת ברמה 2, הרצאה רביעית של קווסט Java Multithreading
• שיטת String.format מכוסה ברמה 2, הרצאה 6 של קווסט Java Multithreading

מקורות נוספים

מידע על המחלקה String מסופק גם במאמרים אחרים בקהילת JavaRush:

1. מחרוזות ב-Java - מאמר זה מכסה כמה יסודות על עבודה עם מחרוזות ב-Java.
2. מחרוזת ג'אווה. שאלות ותשובות לראיון, חלק 1 - מאמר זה דן בשאלות ראיון בנושא String, וכן מספק תשובות לשאלות עם הסברים ודוגמאות קוד.
3. מחרוזות ב-Java (class java.lang.String) - מאמר זה מספק ניתוח מעמיק יותר של המחלקה String, וכן דן במורכבויות העבודה עם המחלקה הזו.