השתלמות מדעי המחשב בשפות חדשות 21/03/07

1. השתלמות מדעי המחשב בשפות חדשות21/03/07 שימוש במחלקה Stringפעולות סטטיות ד''ר יבגני קנל

2. מחרוזת תווים ב-JAVA מאוחסנת בתוך אובייקט שיוצרים מהמחלקהjava.lang.String ד''ר יבגני קנל

3. יסודות 2 – תוכנית לימודים • פרק 3: תווים ומחרוזות6) שעות ( • התאמה ל-C# וג`אווה • מטרת הפרק • להקנותכלים לפתרון בעיות לעיבוד טקסט. • פירוט התכנים • מחרוזות; יחס סדר מילוני; ייצוג מחרוזות כמערכי תווים; בניית אלגוריתמיםעבור מחרוזות. • שימוש בפעולות פשוטות של המחלקה : String • אורך מחרוזת, השוואת מחרוזות, העתקת מחרוזות, מחיקת מחרוזות, שרשור מחרוזות, מציאת תת-מחרוזת. ד''ר יבגני קנל

4. מה שזה לא !! • הטיפוס String מוגדר מראש כטיפוס לכל דבר. • עצם מטיפוס String אינו מערך של תווים!! (ניתן להמיר מן האחד לשני.) • עצם מטיפוס String הוא קבוע שאי-אפשר לשנות על ידי פנייה לתווים בודדים!! • עיבוד מחרוזות מתבצע ע"י פירוק לתת-מחרוזות והרכבה בשרשור. • קיים טיפוס StringBuffer הדומה למחרוזות המוכרות מ-Pascal ו-C. לא נהוג להשתמש בו. ד''ר יבגני קנל

5. מחרוזות (1) • הטיפוס String הוא טיפוס בנוי בשפה. המחלקה מוגדרת כ-final זאת אומרת שאי-אפשר לבנות מחלקה ש"יורשת" מ-String ד''ר יבגני קנל

6. הצהרה ויצירה • הצהרה על משתנה מטיפוס String String s; • אתחול s=“Hello”; • הצהרה ואתחול String s=“Hello”; ד''ר יבגני קנל

7. שגיאה נפוצה – הצהרה ללא אתחול 95 40 int mark; mark=IO.readInt(); if(mark>90)IO.writeln("good"); if(mark<55)IO.writeln("bad"); good bad int mark; String s; mark=IO.readInt(); if(mark>90)s="good"; if(mark<55)s="bad"; IO.writeln(s); Error: variable s might not have been initialized ד''ר יבגני קנל

8. מחרוזות – פעולות בסיסיות • פלט IO.writeln(s); System.out.println(s); • הצבה String s1=“aa”; String s2=s1; • שרשור String s3=s1+s2; s1+=s2; כל פלט ב-JAVA הוא למעשה פלט של מחרוזת אחת! String s1="abc"; String s2=s1; String s3="ABC"; s1+=s3; System.out.println(s1); System.out.println(s2); System.out.println(s3); abcABC abc ABC ד''ר יבגני קנל

9. שרשור • פעולת השרשור מוגדרת על ידי האופרטור +. • שרשור מייצר עצם חדש: s = s + “***” + t + ‘\n’; • כל ערךעובר המרה אוטומטית למחרוזת כאשר +מופיע: int count = …; System.out.println(“Count is = “ + count); four=22 String s=“four=“+2+2; ד''ר יבגני קנל

10. שימוש בקלט/פלט סטנדרטי אין קלט מסוים לתווים!char c=input.next().charAt(0); ד''ר יבגני קנל

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

12. שיטות שימושיות ליצירת מחרוזת • יצירת מחרוזת ריקה String s=new String(); • יצירת מחרוזת זהה למחרוזת אחרת s1 String s=new String(s1); • יצירת מחרוזת ממערך תווים String s=new String(charArr); • יצירת מחרוזת מחלק של מערך תווים String s=new String(charArr, 3, 5); ד''ר יבגני קנל

13. ניהול הזיכרון עבור משתנים וקבועים String s0; s0="aaa"; String s1="aaa"; if(s1==s0)System.out.println("yes"); else System.out.println("no"); String s2="aaa"; if(s1==s2)System.out.println("yes"); else System.out.println("no"); String s3=new String(s1); if(s1==s3)System.out.println("yes"); else System.out.println("no"); String s4=IO.readString(); if(s1==s4)System.out.println("yes"); else System.out.println("no"); yes yes no “aaa” no ד''ר יבגני קנל

14. s1 s3 s4 s2 “aaa” ניהול הזיכרון עבור משתנים וקבועים- המשך String s0; s0="aaa"; String s1="aaa"; if(s1==s0)System.out.println("yes"); else System.out.println("no"); String s2="aaa"; if(s1==s2)System.out.println("yes"); else System.out.println("no"); String s3=new String(s1); if(s1==s3)System.out.println("yes"); else System.out.println("no"); String s4=IO.readString(); if(s1==s4)System.out.println("yes"); else System.out.println("no"); s0 yes “aaa” yes no “aaa” “aaa” no ד''ר יבגני קנל

15. מחרוזות • על עצמים מן הטיפוס String ניתן להפעיל פעולות המוגדרות בטיפוס. למשל: indexOf, substring, length, replace… ד''ר יבגני קנל

16. מחרוזות ומה עם פעולות? • מאחר ומחרוזות הן עצמים, כאשר מפעילים עליהן פעולות המוגדרות בטיפוס String, משתמשים בתחביר הפעלת פעולה על עצם. כלומר:על העצם ... הפעל את הפעולה ... רשימת פרמטרים ) ( שם העצם . שם הפעולה String s1 = “abcde”; int p = s1.indexOf(‘d’); ד''ר יבגני קנל

17. הפעולה int length() • לכל מחרוזת קיימת פעולה length(), המחזירה את האורך של המחרוזת. String s=“ABCD”; System.out.println(s.length()); 4 String s=“”; System.out.println(s.length()); 0 String s; System.out.println(s.length()); Error: variable s might not have been initialized String s=null; System.out.println(s.length()); NullPointerException ד''ר יבגני קנל

18. מחרוזת לעומת מערך (length) • שים לב!! • מחרוזת היא עצם שעליה מוגדרת פעולה ללא פרמטרים length(). if (s.length() > 0) …. • לכל מערך קיימת תכונהlength. int[] a = new int[10]; for (int i = 0; i < a.length; i++) ד''ר יבגני קנל

19. גישה לתווים בודדיםchar charAt(int index) • ניתן לקרוא תווים בודדים לפי מיקומם for (int i = 0; i < s.length(); i++) if (s.charAt(i) == ‘*’) count++; מספור מתחיל מ-0! String s=“aaa”; System.out.println(s.charAt(s.length())); StringIndexOutOfBoundsException: String index out of range: 3 • אך אי-אפשר לשנות אותם: String s="aaa"; s.charAt(1)='b'; Error: unexpected type required: variable found : value ד''ר יבגני קנל

20. שליפת קבוצת תווים • void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) String s="We love Java"; int start=3, end=7; char[] dst=new char[end-start]; s.getChars(start,end,dst,0); for(int i=0;i<dst.length;i++) System.out.println(dst[i]); l o v e String s="We love Java"; char[] ch=s.toCharArray(); • char[] toCharArray() s.length() == ch.length ד''ר יבגני קנל

21. ממערך תווים– למחרוזת • public staticString valueOf(char[] data, int start, int count) • public staticString valueOf(char[] data) char [] a={'W','e',' ','l','o','v','e',' ','J','a','v','a'}; String sd=String.valueOf(a); System.out.println(sd); We love Java פעולת מחלקה ד''ר יבגני קנל

22. מחרוזת --> מערך --> מחרוזת כתוב תוכנית אשר קולטת מחרוזת וממיינת את התווים שבה לפי סדר המילוני We love Java String s=IO.readString(); System.out.println(s); char [] temp=s.toCharArray(); Arrays.sort(temp); s=String.valueOf(temp); System.out.println(s); We love Java JWaaeelovv ד''ר יבגני קנל

23. השוואות בין מחרוזות המחלקה String מספקת מספר מתודות לביצוע השוואה בין אובייקט מטיפוס String מסוים לאובייקט אחר מטיפוס String. public boolean equals(String otherString) מחזירה true אם המחרוזת שמיוצגת על ידי otherString זהה למחרוזת שמיוצגת על ידי האובייקט שממנו מתודה זו הופעלה. public boolean equalsIgnoreCase(String otherString) מחזירהtrue אם המחרוזת שמיוצגת על ידי otherString זהה למחרוזת שמיוצגת על ידי האובייקט שממנו מתודה זו הופעלה. בביצוע ההשוואה אין התחשבות בהבדלים שבין אותיות קטנות וגדולות. public int compareTo(String otherString) מחזירה 0 אם שתי המחרוזות זהות, משמע: ערכן זהה.(הערך מחושב על פי ערך התווים בחישוב עפ"י טבלת ה-Unicode). מחזירה ערך שלילי אם המחרוזת הנתונה בעלת ערך נמוך מהאחרת. מחזירה ערך חיובי אם המחרוזת הנתונה בעלת ערך גבוה מהאחרת ד''ר יבגני קנל

24. s1 הבדל בין == ו-equal מאחר וערך של משתנה מטיפוס String הוא עצם, אזי למעשה הערך איננו העצם אלא הוא המצביע אל העצם. בהתאם לכך הפלט של קטע התכנית הבא יהיה No String s1 = “abcde”; String s2 = “abc”; s2 = s2 + “de”; if (s1 == s2) IO.writeln(“Yes”); else IO.writeln(“No”); “abcde” “de” s2 “abc” “abcde” No ד''ר יבגני קנל

25. הבדל בין == ו-equal • אם רוצים להתייחס אל השוואה לקסיקוגראפית כדי לקבל פלט Yes - יש להשתמש בפעולה equals המוגדרת בטיפוס String. String s1 = “abcde”; String s2 = “abc” + “de”; if (s1.equals(s2)) IO.writeln(“Yes”); else IO.writeln(“No”); ד''ר יבגני קנל

26. השוואות בין מחרוזות • equals מחזיר boolean (true/false - זהות/לא זהות) • compareTo משווה שתי מחרוזות לפי סדר מילוני lexicographic. הפונקציה מחזירה int: ד''ר יבגני קנל

27. פלט ידוע. מהו הקלט? import java.util.*; public class test42{ static Scanner reader=new Scanner(System.in); public static void main(String[] args){ String s1="abc"; String s2=reader.next(); System.out.println(s1.compareTo(s2)); }} ? -3 d… ae… abf… abcabc abc123 ? ? ? abc ד''ר יבגני קנל

28. השוואת מחרוזות - פעולות נוספות • public boolean startsWith(String prefix) • מחזירה true אם המחרוזת הנתונה מתחילה במחרוזת האחרת (prefix) • public boolean endsWith(String suffix) • מחזירה true אם המחרוזת שמיוצגת על ידי האובייקט מסתיימת במחרוזת האחרת (suffix). • public boolean regionMatches(int thisBgn, • String otherStr, int otherStr, int length) • מחזירה true אם שתי המחרוזות זהות בטווח המצוין. ההשוואה נעשית החל ממספר האינדקס thisBgn במחרוזת שמייצג האובייקט לאורך length תווים. במחרוזת האחרת ההשוואה נעשית החל מהתו שמספר האינדקס שלו הוא otherStr. מתודה זו מתחשבת בהבדלים של אותיות קטנות/גדולות. ד''ר יבגני קנל

29. String s=IO.readString(“Enter Phone Number”); if(s.startsWith("02"))IO.writeln("Jerusalem"); if(s.startsWith("03"))IO.writeln("Gush Dan"); if(s.startsWith("04"))IO.writeln("North"); if(s.startsWith("08"))IO.writeln("South"); String s1=IO.readString("Your Web-site"); if(s1.endsWith("il"))IO.writeln("שלום"); else IO.writeln("Hello"); ד''ר יבגני קנל

30. מציאת תווים ותת-מחרוזות • כל אחת מהמתודות מחזירה את מיקום התו או תת המחרוזתהמבוקשים במחרוזת עפ"י האינדקס המקובל: מ-0עד . length-1 אם התו או תת המחרוזת המבוקשת לא נמצאים במחרוזת שמייצג האובייקט אז מוחזר הערך .–1 • public int indexOf(char ch) • מתודה שמחזירה את מספר האינדקס אשר בו נמצא התו ch במחרוזת שמייצג האובייקט. החיפוש אחרי התו מתחיל מתחילתה של המחרוזת, ומספר האינדקס של התו הראשון, שנמצא זהה לתו ch, מוחזר. • public int lastIndexOf(char ch) • מתודה שמחזירה את מספר האינדקס אשר בו נמצא התו ch במחרוזת שמייצג האובייקט. החיפוש אחרי התו מתחיל מסופה של המחרוזת, והמיקום של התו הראשון שנמצא זהה לתו ch מוחזר. ד''ר יבגני קנל

31. מציאת תווים – מה זה עושה? String s=IO.readString(); for(char ch='a'; ch<='z';ch++) if(s.indexOf(ch)==-1) IO.write(ch); להדפיס אותיות החסרות במחרוזת boolean b=true; String s=IO.readString(); for(int i=0; i<s.length();i++){ char let=s.charAt(i); if(s.indexOf(let)!=s.lastIndexOf(let))b=false; } if (b)IO.writeln("Yes");else IO.writeln("No"); לבדוק שכל תו מופיע רק פעם אחת ד''ר יבגני קנל

32. מציאת תווים ותת-מחרוזות public int indexOf(char ch, int begin) מתודה שמחזירה את מספר האינדקס אשר בו נמצא התו ch במחרוזת שמייצג האובייקט. החיפוש אחריו מתחיל ממספר האינדקס שנשלח אל המתודה, מ- begin, ומספר האינדקס של התו הראשון שנמצא זהה לתו ch מוחזר. public int lastIndexOf(char ch, int fromIndex) מתודה זו מחפשת את התו ch במחרוזת שממנה היא מופעלת החל מאינדקס fromIndex לכיוון התחלתה. התו הראשון שהמתודה מוצאת כזהה לתו ch מוחזר על ידה. ד''ר יבגני קנל

33. מציאת תווים ותת-מחרוזות • public int indexOf(String str) • מתודה זו מחפשת מתחילתה של המחרוזת שהאובייקט מייצג את המחרוזת str. מספר האינדקס שבו היא נמצאת מוחזר על ידי המתודה.   • public int indexOf(String str, int begin) • מתודה זו מחפשת במחרוזת שהאובייקט מייצג את המחרוזת str החל מהמקום שמספר האינדקס שלו הוא begin לכיוון סופה.   • public int lastIndexOf(String str) • מתודה זו מחפשת במחרוזת שמייצג האובייקט את המחרוזת שמיוצגת על ידי str. החיפוש מתחיל מסופה של המחרוזת לכיוון התחלתה. מספר האינדקס שהחל ממנו str נמצאת לראשונה מוחזר על ידי המתודה. • public int lastIndexOf(String str, int fromIndex) • מתודה זו מחפשת במחרוזת שמייצג האובייקט את המחרוזת שמיוצגת על ידי str. החיפוש מתחיל ממיקום fromIndex לכיוון התחלתה של המחרוזת. מספר האינדקס שהחל ממנו str נמצאת לראשונה מוחזר על ידי המתודה. ד''ר יבגני קנל

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

35. "שינוי במחרוזת" • public String replace (char oldChar, char newChar) • מתודה זו מחזירה הפנייה לאובייקט חדש מטיפוס String אשר מייצג מחרוזת תווים שמתקבלת מהמחרוזת, שמייצג האובייקט שממנו המתודה הופעלה, לאחר שכל תו שזהה לתו oldChar מוחלף בתו newChar.  • public String toLowerCase() • מתודה זו מחזירה הפנייהלאובייקט חדש מטיפוס String אשר מתאר את מחרוזת תווים שמתקבלת מהמחרוזת שמייצג האובייקט כאשר מחליפים את כל אחת מהאותיות הגדולות לאות קטנה.  • public String toUpperCase() • מתודה זו מחזירה הפנייה לאובייקט חדש מטיפוס String אשר מתאר את מחרוזת התווים שמתקבלת מהמחרוזת שמייצג האובייקט כאשר מחליפים את כל האותיות הקטנות לאותיות גדולות. • public String trim() • מתודה זו מחזירה הפנייה לאובייקט חדש מטיפוס String שמתאר מחרוזת תווים שמתקבלת מהמחרוזת שמייצג האובייקט לאחר שכל תווי הריווח שמופיעים בתחילת המחרוזת ובסופה נמחקים. ד''ר יבגני קנל

36. "שינוי במחרוזת" String s = new String("We love Java"); System.out.println(s); s.toLowerCase(); System.out.println(s); s.toUpperCase(); System.out.println(s); s.replace(' ','*'); System.out.println(s); We love Java We love Java We love Java We love Java ד''ר יבגני קנל

37. "שינוי במחרוזת" String s="We love Java"; System.out.println(s); String s1=s.toLowerCase(); System.out.println(s1); s=s.toUpperCase(); System.out.println(s); s=s.replace(' ','*'); System.out.println(s); We love Java we love java WE LOVE JAVA WE*LOVE*JAVA ד''ר יבגני קנל

38. החלפת רצף תווים בתוך מחרוזת String s="We love Java"; System.out.println(s); We love Java s=s.replace("Java",IO.readString()); System.out.println(s); We love C# C# s=s.replace(" ",""); System.out.println(s); מחיקה? WeloveC# Error: cannot find symbol symbol : method replace(char,java.lang.String) location: class java.lang.String s=s.replace('e',"ee"); System.out.println(s); ד''ר יבגני קנל

39. שליפה תת-מחרוזת • public String substring(int begin) • מתודה זו מחזירה הפנייה לאובייקט חדש מטיפוס String שמייצג תת מחרוזת למחרוזת שמייצג האובייקט. תת המחרוזת שמוחזרת מורכבת מכל התווים שהחל מהתו שמספר האינדקס שלו begin ועד לסופה של המחרוזת שמייצג האובייקט. • public String substring(int begin, int end) • מתודה זו מחזירה הפנייה לאובייקט חדש מטיפוס String שמייצג תת מחרוזת למחרוזת שמייצג האובייקט. תת המחרוזת שמוחזרת מורכבת מכל התווים החל מהתו שמספר האינדקס שלו begin (כולל) ועד לתו שמספר האינדקס שלו end (לא כולל). ד''ר יבגני קנל

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

41. מה קורה באמת? כאשר הקומפיילר נתקל בשורה כדוגמת: String s=“abc” + “def” + “ghi”; האופן שבו השורה מטופלת הוא כדלקמן: String s=(((new StringBuffer(“abc”)) . append(“def”)). append(“ghi”)). toString() ד''ר יבגני קנל

42. הבדל בין String ו-StringBuffer String s = new String("ssssss"); StringBuffer sb = new StringBuffer("bbbbbb"); s.concat("-aaa"); sb.append("-aaa"); System.out.println(s); System.out.println(sb); ssssss bbbbbb-aaa • מן הרגע שבו נוצר אובייקט חדש מטיפוסStringלאניתןלשנות את המחרוזת שהוא מייצג • את המחרוזת שמייצג אובייקט מטיפוסStringBufferכן ניתן לשנות ד''ר יבגני קנל

43. די דיינו? ואם לא? • אבל מה קורה כאשר נרצה להגדיר פעולה משלנו שתפעל על מחרוזות? • למשל: פעולה הפועלת על מחרוזת ומחזירה את מספר המופעים של תו מסוים בתוך מחרוזת. • מאחר והטיפוס String הוא טיפוס בנוי בשפה, איננו יכולים להרחיב את אוסף הפעולות שלו. המשמעות היא: • עלינו להגדיר את הפעולה כפעולה סטטית (static). • הפעולה תקבל את המחרוזת כפרמטר. ד''ר יבגני קנל

44. public class ExString { public static int numOfChar(String s, char c) { int counter = 0; for (int i=0; i < s.length(); i++) if ( s.charAt(i) == c ) counter ++; return counter; } public static void main(String[] args) { String s1 = "abcabcaasa"; int m = numOfChar(s1, 'a'); IO.writeln(m); } } ד''ר יבגני קנל

45. דוגמה – מחיקת תת-מחרוזת static String delete(String s, int from, int to){ String start = s.substring(0, from); String end = s.substring(to+1); return start + end; } public static void main(String[] args){ String s=“I didn’t love JAVA”; s = delete(s, 2, 8); System.out.println(s);} I love JAVA ד''ר יבגני קנל

46. דוגמה – מחיקה כל מופעים של תת-מחרוזת static String deleteSubString(String s, String subS){ int len=subS.length(); while (s.indexOf(subS)!=-1){ s=s.substring(0,s.indexOf(subS))+ s.substring(s.indexOf(subS)+len); } return s; } str=str.replace(subStr,""); String str=“I didn’t didn’tdidn’tlove JAVA”; String subStr= “didn’t“; str=deleteSubString(str,subStr); System.out.println(str); I love JAVA ד''ר יבגני קנל

47. דוגמה – הכנסת תת-מחרוזת static String insert(String s, String sub, int at) { String start = s.substring(0, at); String end = s.substring(at); return start + sub + end; } String s= "We love Java!"; s = insert(s, " the", 7); ד''ר יבגני קנל

48. class What { public static void main(String[] args) { String s ="the quick brown fox jumped over the lazy dog"; String t = ""; int space = s.lastIndexOf(' '); while (space != -1) { t = t + s.substring(space+1) + " "; s = s.substring(0, space); space = s.lastIndexOf(' '); } t = t + s; System.out.println(t); } } dog lazy the over jumped fox brown quick the ד''ר יבגני קנל

49. מחרוזות - ומה עם ההוראה? • באשר ל: פעולות בטיפוס המוגדר מראש • לא קרה כלום, גם קודם היו לנו פעולות מוגדרות מראש עבור מחרוזות. • באשר ל: השוואת מחרוזות • לא נורא, יקפידו על שימוש ב equals במקום ב == • באשר ל: דרך הפעלת הפעולות על עצמים • קצת מבלבל, עד עכשיו השתמשו בזימון פעולות "רגיל" ועכשיו יצטרכו להתרגל לזימון פעולות "על העצם..." ד''ר יבגני קנל

50. הקלדנית החרוצה קלדנית קבלה בעבודה מקלדת שבה יש בעיות חיבור במקשים (כנראה נשפך עליה קפה...) הבעיות האלה גורמות לכך שאחרי לחיצה על המקש על המסך לא בהכרח מופיע תו מתאים. כתוצאה - בהקלדת טקסט התקבל מסמך "לא מובן". על מנת לתקן את הטקסט קלדנית החליטה להשתמש בשיטה הבאה: היא מקלידה שוב ושוב בדיוק אותו טקסט שרואה על המסך – עד המופיע טקסט נכון. • כתוב תוכנית אשר מדמה את התהליך ההקלדה בשלבים הבאים: • בונה "מקלדת המקולקלת" • מקבלת מחרוזת המורכבת האותיות קטנות של אנגלית ומחזירה את ה"טקסט השגוי" • מבצעת "שיטת הקלדנית" עד לקבלת המחרוזת הזהה ל"מחרוזת המקורית". • יש להציג את התוצאות המתקבלות בכל פעם המפעילים את "שיטת הקלדנית" ולספור כמה הפעלות נדרשו. ד''ר יבגני קנל