Department of Mathematics | University of Haifa – החוג ...



פעולות על מחרזות String

שפת Java תומכת בסדרה של אמצעי תכנות על המחלקה String.

להלן תאור מסוים עליהם.

אופרטורים

שפת Java תומכת באופרטורים "==" של השוואת תוכן משתנה היחס ואופרטור "+" שמשמעותו שרשור מחרוזות, ו-"=+" שרשור מחרוזת קיימת.

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

ניתן להמיר מחרוזת מסוג StringBuffer למחרוזת מסוג String דרך הבנאי של String:

משהו כמו

StringBuffer strb1;

String str1;

…….

str1 = new String(strb1);

אפשר גם בכיוון ההפוך באמצעות הבנאי של StringBuffer:

strb1 = new StringBuffer(str1);

אפשר גם באמצעות שיטה toString של StringBuffer:

str1 = “abc” + strb1.toString();

להלן רשימה של חלק מהשיטות המובנות בשפה עבור String:

1. int compareTo(String anotherString)

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

2. char charAt(int index)

מחזיר את התו במיקום index.

3. void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

מחזיר מערך תווים שהם התווים במחרוזת מ- srcBegin עד srcEnd לתוך dst החל מ- dstBegin.

4. int length()

מחזיר את אורך הלוגי של המחרוזת.

5. boolean equals(String anotherString)

בודק אם התוכן זהה.

6. boolean equalsIgnoreCase(String anotherString)

בודק השוואת תכנים תוך התעלמות מההבדל בין תווים שהם אותיות קטנות וגדולות.

7. String toUpperCase()

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

8. String toLowerCase()

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

9. String concat(String str)

מחזיר מחרוזת המתקבלת לשרשור הערך הפנימי הנוכחי.

10. int indexOf(int ch)

מחזיר את האינדקס של המופע הראשון של התו ch בתוכן של המחרוזת.

11.int indexOf(int ch, int fromIndex)

כמו 10, רק שהחיפוש החל מאינדקס נתון.

12. int indexOf(String str)

מחזיר את האינדקס של המופע הראשון של המחרוזת str בתוכן של המחרוזת הפנימית.

13. int indexOf(String str, int fromIndex)

כמו 12, רק שהחיפוש החל מאינדקס נתון.

14. int lastIndexOf(int ch)

מחזיר את האינדקס של המופע האחרון של התו ch בתוכן של המחרוזת.

15. int lastIndexOf(int ch, int fromIndex)

כמו 14, רק שהחיפוש החל מאינדקס נתון.

16. int lastIndexOf(String str)

מחזיר את האינדקס של המופע האחרון של המחרוזת str בתוכן של המחרוזת הפנימית.

17. int lastIndexOf(String str, int fromIndex)

כמו 16, רק שהחיפוש החל מאינדקס נתון.

18. String substring(int beginIndex)

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

19. String substring(int beginIndex, int endIndex)

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

20. String replace(char oldChar, char newChar)

מחזירה מחרוזת חדשה המתקבלת מהחלפת כל המופעים של התו oldChar ב- newChar.

21. String trim()

מחזיר מחרוזת המתקבלת מקיצוץ "תווים לבנים" מהסוף וההתחלה.

22. String toString()

מחזירה עותק מעצמה.

תוכניות דוגמא:

התוכנית הבאה ממחישה התמרות ל-String:

// StringsDemo2.java

public class StringsDemo2 {

public static void main(String[] args) {

byte[] bytes = {2, 4, 6, 8};

char[] characters = {'a', 'b', 'C', 'D'};

StringBuffer strBuffer = new StringBuffer("abcde");

// Examples of Creation of Strings

String byteStr = new String(bytes);

String charStr = new String(characters);

String buffStr = new String(strBuffer);

System.out.println("byteStr : "+byteStr);

System.out.println("charStr : "+charStr);

System.out.println("buffStr : "+buffStr);

} // main

}// StringsDemo2

פלט ריצה:

D:\>javac StringsDemo2.java

D:\>java StringsDemo2

byteStr :

charStr : abCD

buffStr : abcde

D:\>

התוכנית הבאה ממחישה שימושים בשיטות ובאופרטורים:

// StringsDemo3.java

public class StringsDemo3

{

public static void main(String[] args) {

String str1 = "My name is bob";

char str2[] = new char[str1.length()];

String str3 = "bob";

String str4 = "cob";

String str5 = "BoB";

String str6 = "bob";

System.out.println("Length of the String str1 : " + str1.length());

System.out.println("Character at position 3 is : "

+ str1.charAt(3));

str1.getChars(0, str1.length(), str2, 0);

System.out.print("The String str2 is : ");

for (int i = 0; i < str2.length; i++) {

System.out.print(str2[i]);

} // for

System.out.println();

System.out.print("Comparision Test : ");

if (pareTo(str4) < 0) {

System.out.print(str3 + " < " + str4);

} else if (pareTo(str4) > 0) {

System.out.print(str3 + " > " + str4);

} else {

System.out.print(str3 + " equals " + str4);

}

System.out.println();

System.out.print("Equals Test");

System.out.println("str3.equalsIgnoreCase(5) : "

+ str3.equalsIgnoreCase(str5));

System.out.println("str3.equals(6) : " + str3.equals(str6));

System.out.println("str1.equals(3) : " + str1.equals(str3));

str5.toUpperCase(); //Strings are immutable

System.out.println("str5 : " + str5);

String temp = str5.toUpperCase();

System.out.println("str5 Uppercase: " + temp);

temp = str1.toLowerCase();

System.out.println("str1 Lowercase: " + str1);

System.out.println("str1.concat(str4): " + str1.concat(str4));

String str7temp =

" \t\n Now for some Search and Replace Examples ";

String str7 = str7temp.trim();

System.out.println("str7 : " + str7);

String newStr = str7.replace('s', 'T');

System.out.println("newStr : " + newStr);

System.out.println("indexof Operations on Strings");

System.out.println("Index of p in " + str7 + " : "

+ str7.indexOf('p'));

System.out.println("Index of for in " + str7 + " : "

+ str7.indexOf("for"));

System.out.println("str7.indexOf(for, 30) : "

+ str7.indexOf("for", 30));

System.out.println("str7.indexOf('p', 30) : "

+ str7.indexOf('p', 30));

System.out.println("str7.lastIndexOf('p') : "

+ str7.lastIndexOf('p'));

System.out.println("str7.lastIndexOf('p', 4) : "

+ str7.lastIndexOf('p', 4));

System.out.print("SubString Operations on Strings");

String str8 = "SubString Example";

String sub5 = str8.substring(5); // "ring Example"

String sub3_6 = str8.substring(3, 6); // "Str"

System.out.println("str8 : " + str8);

System.out.println("str8.substring(5) : " + sub5);

System.out.println("str8.substring(3,6) : " + sub3_6);

}// main

} // StringsDemo3.java

פלט ריצה:

D:\>javac StringsDemo3.java

D:\>java StringsDemo3

Length of the String str1 : 14

Character at position 3 is : n

The String str2 is : My name is bob

Comparision Test : bob < cob

Equals Teststr3.equalsIgnoreCase(5) : true

str3.equals(6) : true

str1.equals(3) : false

str5 : BoB

str5 Uppercase: BOB

str1 Lowercase: My name is bob

str1.concat(str4): My name is bobcob

str7 : Now for some Search and Replace Examples

newStr : Now for Tome Search and Replace ExampleT

indexof Operations on Strings

Index of p in Now for some Search and Replace Examples : 26

Index of for in Now for some Search and Replace Examples : 4

str7.indexOf(for, 30) : -1

str7.indexOf('p', 30) : 36

str7.lastIndexOf('p') : 36

str7.lastIndexOf('p', 4) : -1

SubString Operations on Stringsstr8 : SubString Example

str8.substring(5) : ring Example

str8.substring(3,6) : Str

D:\>

................
................

In order to avoid copyright disputes, this page is only a partial summary.

Google Online Preview   Download