ומבוא ( ) המחלקה מחרוזת – 9פרק String לעצמים

‫פרק ‪ – 9‬המחלקה מחרוזת )‪ (String‬ומבוא‬
‫לעצמי‬
‫בתוכניות שכתבנו עד כה השתמשנו בטיפוסי שוני המוגדרי בשפת ‪ :Java‬של‪ ,‬ממשי‪ ,‬תווי‬
‫ובוליאני‪ .‬יכולנו להגדיר משתני מטיפוסי אלו‪ ,‬ולבצע עליה פעולות שונות )קלט‪ ,‬פלט‪ ,‬חישובי‬
‫וכו'(‪ .‬ע זאת‪ ,‬מרבית התוכניות שכתבנו התייחסו ג למחרוזות‪ ,‬סדרות של תווי‪ .‬עד עתה השתמשנו‬
‫במחרוזות כאשר רצינו להדפיס הודעות למשתמש ותחמנו אות במירכאות‪ ,‬למשל‪ ,‬בהוראה‪:‬‬
‫;)"‪System.out.println("Please insert two numbers‬‬
‫ההודעה "‪ "Please insert two numbers‬היא מחרוזת‪.‬‬
‫הנה דוגמאות נוספות למחרוזות בשפת ‪:Java‬‬
‫"?‪"" ,"J" ,"453" ,"Hello, How Are You‬‬
‫)האחרונה היא מחרוזת ריקה‪ ,‬שאינה מכילה א תו(‪.‬‬
‫לעיתי נוח להתייחס למחרוזות במפורש ולבצע עליה פעולות נוספות‪ ,‬פרט להדפסה‪ .‬בפרק זה נראה‬
‫כיצד נית לקלוט מחרוזות מהמשתמש‪ ,‬לשמור אות‪ ,‬ולבצע עיבודי על מחרוזות‪ .‬א עד עתה יכולנו‬
‫לקלוט מספרי או תווי בודדי בלבד‪ ,‬עכשיו נוכל לבקש מהמשתמש להקיש את שמו‪ ,‬כתובתו‬
‫וכדומה‪ ,‬ולבצע פעולות שונות על המחרוזות הנקלטות‪ .‬דר! ההיכרות ע מחרוזות נערו! ג היכרות‬
‫ראשונית ע מחלקות ועצמי‪.‬‬
‫‪ 9.1‬היכרות ראשונית עם המחלקה ‪String‬‬
‫בשפת ‪ Java‬לא מוגדר טיפוס פשוט עבור מחרוזות‪ ,‬בדומה לטיפוסי אחרי שראינו‪ .‬אבל‪ ,‬בשפת‬
‫‪ Java‬מוגדרת המחלקה ‪ ,String‬ובה נוכל להיעזר כאשר נרצה להשתמש במחרוזות‪.‬‬
‫למעשה‪ ,‬נית להתייחס אל מחלקה כאל טיפוס חדש בשפה‪ ,‬המאפשר הצהרה ושימוש במשתני‬
‫מטיפוס זה‪ .‬למשל‪ ,‬א ‪ String‬היא מחלקה בשפה‪ ,‬אפשר לכתוב‪:‬‬
‫;‪String s1, s2‬‬
‫בדומה להצהרה על משתני מטיפוס רגיל )למשל‪ ,‬של או תווי(‪.‬‬
‫נהוג לקרוא למשתני של טיפוסי חדשי כאלה מופעי של המחלקה ‪ String‬או עצמי של‬
‫המחלקה ‪ .String‬כפי שנראה מיד‪ ,‬השימוש בעצמי שונה מעט משימוש במשתני רגילי‪ .‬בפרק זה‬
‫נכיר‪ ,‬בעזרת המחלקה ‪ ,String‬מושגי בסיסיי הקשורי לשימוש במחלקות ובעצמי‪ .‬ביחידת‬
‫ההמש! )"יסודות מדעי המחשב ‪ ("2‬תלמדו כיצד להגדיר בעצמכ מחלקות חדשות‪.‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-383-‬‬
‫מדעי המחשב‬
‫אמנ‪ ,‬הצהרה על עצמי דומה להצהרה על משתני מטיפוסי רגילי‪ .‬אבל‪ ,‬שלא כמו עבור‬
‫משתני מטיפוסי רגילי‪ ,‬בדר! כלל הצהרה על עצ חדש אינה מספיקה! עלינו להקצות מקו חדש‬
‫בזיכרו עבור עצ זה‪ .‬עבור משתני רגילי‪ ,‬הקצאת המקו בזיכרו נעשית אוטומטית ע ההצהרה‬
‫עליה‪ .‬אי זה כ! עבור עצמי‪ .‬בהמש! הפרק נראה כיצד מבוצעת הקצאת שטח עבור עצמי‪.‬‬
‫בשפת ‪ Java‬מחרוזת‬
‫היא עצ‪ ,‬כלומר‪ ,‬מופע של המחלקה )‪ (class‬מחרוזת‪ .‬נית להצהיר על‬
‫מחרוזות בדומה להצהרת משתני רגילי‪.‬‬
‫כדי שנית יהיה להשתמש בעצ מהמחלקה מחרוזת‪ ,‬יש להקצות עבורו שטח זיכרו‪.‬‬
‫בעיה ‪1‬‬
‫מטרת הבעיה ופתרונה‪ :‬הצגת שימוש בסיסי במחלקה מחרוזת‪.‬‬
‫פתחו ויישמו אלגורית שיקבל כקלט את שמכ‪ ,‬וידפיס על המס! את המחרוזת ‪Your name is‬‬
‫ומיד אחריה את הש שנקלט‪.‬‬
‫בחירת משתני‬
‫?‬
‫באיזה טיפוס נשתמש כדי לשמור את הש שנקלט?‬
‫כיוו שעלינו לקלוט מילה‪ ,‬נשתמש במחלקה מחרוזת‪ .‬א כ!‪ ,‬רשימת המשתני תכלול את העצ‬
‫‪ name‬מהמחלקה מחרוזת‪.‬‬
‫האלגורית‪:‬‬
‫‪name-ì úæåøçî èåì÷ .1‬‬
‫‪"Your name is " èìôë âöä .2‬‬
‫‪name úà èìôë âöä .3‬‬
‫יישו האלגורית‬
‫עד כה ראינו כיצד לקלוט ערכי של טיפוסי פשוטי – שלמי‪ ,‬ממשיי ותווי‪ .‬ביצוע קלט של‬
‫מחרוזת נעשה בצורה דומה‪ .‬את הוראה ‪ 1‬נוכל לממש על ידי המשפט‪:‬‬
‫;)(‪name = In.readString‬‬
‫בדומה להוראות קלט אחרות בה השתמשנו‪ ,‬א נרצה לצר הנחיה למשתמש לגבי מהות הקלט לו‬
‫מצפה התוכנית‪ ,‬נכתוב את ההודעה המתאימה בתו! הסוגריי‪.‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-384-‬‬
‫מדעי המחשב‬
‫שימו ♥‪ :‬כמו הוראות קלט של ערכי מטיפוסי פשוטי‪ ,‬ג הוראת קלט של מחרוזת היא למעשה‬
‫הוראת השמה‪ .‬בעת ביצוע ההוראה ;)(‪ name = In.readString‬נקראת מחרוזת מהקלט‪ ,‬ונוצר‬
‫עצ חדש מהמחלקה מחרוזת‪ ,‬שהוקצה עבורו מקו בזיכרו כחלק מפעולת הקלט‪ .‬עצ זה שומר את‬
‫מחרוזת הקלט‪ .‬הפעולה ‪ ,In.readString‬מחזירה הפניה לשטח הזיכרו החדש שהוקצה‪ .‬בעקבות‬
‫ההשמה מפנה ‪ name‬אל אותו שטח זיכרו‪ ,‬ודר! ‪ name‬נית להגיע אל אותו שטח ולבצע עליו פעולות‬
‫שונות‪ .‬בהמש! הפרק נעמיק בהשמה של מחרוזות‪.‬‬
‫משו שפעולת קליטת מחרוזת מבצעת הקצאת שטח בזיכרו עבור המחרוזת הנקלטת אי צור!‬
‫במקרה זה להקצות שטח זיכרו עבור מחרוזת זו ע הצהרתה‪.‬‬
‫התוכנית המלאה‬
‫*‪/‬‬
‫קלט‪ :‬שם‪ ,‬הנקלט כמחרוזת‬
‫פלט‪ :‬השם‪ ,‬מלווה בהודעה מקדימה‬
‫‪*/‬‬
‫‪public class YourName‬‬
‫{‬
‫)‪public static void main (String [] args‬‬
‫{‬
‫הצהרה על עצם מהמחלקה מחרוזת ‪//‬‬
‫;‪String name‬‬
‫הוראת קלט ‪ +‬הקצאת מקום בזיכרון ‪//‬‬
‫;)"‪name = In.readString("Insert your name‬‬
‫פלט ‪//‬‬
‫;)‪System.out.println("your name is: " + name‬‬
‫‪} // main‬‬
‫‪} // class YourName‬‬
‫סוף פתרון בעיה‬
‫‪1‬‬
‫נית לבצע קלט של מחרוזת באמצעות הפעולה ‪.In.readString‬‬
‫נית להעביר לפעולת הקלט מחרוזת שתנחה את המשתמש לגבי הקלט שהוא מתבקש לתת‪.‬‬
‫פעולת הקלט מקצה שטח עבור המחרוזת החדשה‪.‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-385-‬‬
‫מדעי המחשב‬
‫‪ 9.2‬ביצוע פעולות על מחרוזות‬
‫כש שעל ערכי ומשתני של טיפוסי פשוטי‪ ,‬כגו ‪ char‬ו(‪ ,int‬אפשר לבצע פעולות שונות‬
‫)למשל‪ ,‬פעולות חשבוניות או פעולות השוואה(‪ ,‬נרצה לבצע פעולות שונות ג על מופעי של מחלקות‪,‬‬
‫הטיפוסי החדשי בשפה‪ .‬כאשר מוגדרת מחלקה בשפה‪ ,‬מוגדרות איתה ג פעולות שנית לבצע על‬
‫עצמי של המחלקה‪.‬‬
‫כדי לבצע פעולה של מחלקה על עצ מהמחלקה יש לכתוב ראשית את שמו‪ ,‬אחריו את הסימ נקודה‪,‬‬
‫ולאחר מכ את ש הפעולה לביצוע‪ .‬למשל‪ ,‬אחת מהפעולות המוגדרות עבור המחלקה מחרוזת היא‬
‫הפעולה ‪ ,length‬המחשבת את אורכה של מחרוזת מסוימת‪ .‬א ‪ s1‬הוא עצ של המחלקה מחרוזת‪,‬‬
‫אז הביטוי )(‪ s1.length‬מפעיל את הפעולה ‪ length‬על העצ ‪ s1‬ומחזיר את תוצאת ההפעלה‪,‬‬
‫כלומר את אורכה של המחרוזת ‪ .s1‬בכל הפעלה של פעולה של המחלקה מחרוזת נשתמש בסימו‬
‫הנקודה‪ ,‬כדי לציי את העצ שעליו היא מופעלת‪.‬‬
‫הסוגריי שאחרי ש הפעולה נועדו להעברת ערכי )פרמטרי( לה נזקקת הפעולה‪ .‬במקרה של‬
‫הפעולה ‪ length‬אי צור! בהעברת ער!‪ ,‬ולכ הסוגריי נותרי ריקי‪ .‬בהמש! הפרק נכיר פעולות‬
‫נוספות‪ ,‬אשר מצפות לקבל ערכי מסוימי לצור! הפעלת‪.‬‬
‫בעיה ‪2‬‬
‫מטרת הבעיה ופתרונה‪ :‬הדגמת השימוש בפעולות על מחרוזות‪ .‬הכרת הפעולות ‪ length‬ו( ‪.charAt‬‬
‫פתחו ויישמו אלגורית אשר יקבל כקלט מחרוזת‪ .‬א אור! המחרוזת הוא זוגי יוצג כפלט התו‬
‫הראשו במחרוזת‪ ,‬וא אור! המחרוזת הוא אי(זוגי יוצג התו האחרו במחרוזת‪.‬‬
‫למשל‪ ,‬עבור הקלט ‪ shalom‬יוצג התו‪ .'s' :‬ועבור הקלט ‪ dog‬יוצג התו‪.'g' :‬‬
‫שימו ♥‪ :‬בשפת ‪ Java‬מיקו התווי במחרוזת מתחיל מ(‪ .0‬כלומר‪ ,‬התו הראשו במחרוזת נמצא‬
‫במקו ‪ ,0‬התו השני במחרוזת הוא במקו ‪ ,1‬השלישי במקו ‪ ,2‬וכ הלאה‪.‬‬
‫?‬
‫א התו הראשו נמצא במקו ‪ ,0‬באיזה מקו נמצא התו האחרו?‬
‫נתבונ למשל במחרוזת "‪ "abcd‬שאורכה ‪ .4‬התו האחרו בה הוא '‪ 'd‬והוא נמצא במקו ‪.3‬‬
‫מיקו התווי‬
‫במחרוזת מתחיל מ(‪.0‬‬
‫בכל מחרוזת‪ ,‬א נסמ את אור! המחרוזת ב(‪ ,len‬אז התו האחרו במחרוזת נמצא במקו ‪.len −1‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-386-‬‬
‫מדעי המחשב‬
‫בחירת משתני‬
‫נשתמש במשתני הבאי‪:‬‬
‫‪ – str‬עצ מהמחלקה מחרוזת‬
‫‪ – letter‬האות המבוקשת‪ ,‬מטיפוס ‪char‬‬
‫‪ – len‬לשמירת אור! המחרוזת‪ ,‬מטיפוס של‬
‫האלגורית‬
‫‪str-ì úæåøçî èåì÷ .1‬‬
‫‪len-á str úæåøçîä ìù äëøåà úà íùä .2‬‬
‫‪.3‬‬
‫‪íà‬‬
‫‪éâåæ len‬‬
‫‪str-á 0 íå÷îá àöîðä åúä úà letter-á íùä 3.1‬‬
‫‪.4‬‬
‫‪úøçà‬‬
‫‪str-á len−1 íå÷îá àöîðä åúä úà letter-á íùä 4.1‬‬
‫‪letter ìù åëøò úà èìôë âöä .5‬‬
‫יישו האלגורית‬
‫?‬
‫כדי לבדוק את אורכה של המחרוזת נשתמש בפעולה ‪ ,length‬באיזו פעולה נשתמש כדי לדעת מהו‬
‫התו שנמצא במקו מסוי במחרוזת?‬
‫במחלקה מחרוזת מוגדרות פעולות נוספות ואחת מה היא הפעולה )‪ .charAt(k‬פעולה זו מקבלת‬
‫כפרמטר )בתו! הסוגריי( מספר של ‪ ,k‬ומחזירה את התו שנמצא במקו ה(‪ k‬במחרוזת עבורה‬
‫הופעלה‪ .‬לכ‪ ,‬למשל‪ ,‬כדי לדעת מהו התו שנמצא במקו ‪0‬‬
‫במחרוזת ‪ str‬נכתוב )‪.str.charAt(0‬‬
‫התוכנית המלאה‬
‫*‪/‬‬
‫קלט‪ :‬מחרוזת‬
‫פלט‪ :‬התו הראשון או האחרון במחרוזת‪ ,‬בהתאם לאורכה )זוגי או אי‪-‬זוגי(‬
‫‪*/‬‬
‫‪public class IsEven‬‬
‫{‬
‫)‪public static void main (String[] args‬‬
‫{‬
‫;‪String str‬‬
‫;‪int len‬‬
‫;‪char letter‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-387-‬‬
‫מדעי המחשב‬
‫;)"‪str = In.readString("Insert a string please‬‬
‫;)(‪len = str.length‬‬
‫)‪if (len % 2 == 0‬‬
‫{‬
‫;)‪letter = str.charAt(0‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;)‪letter = str.charAt(len - 1‬‬
‫}‬
‫;)‪System.out.println("The letter is " + letter‬‬
‫‪} // main‬‬
‫‪} // class IsEven‬‬
‫סוף פתרון בעיה ‪2‬‬
‫בסו הפרק תוכלו למצוא טבלה המפרטת את הפעולות השכיחות המוגדרות ב(‪ Java‬עבור עצמי‬
‫מהמחלקה ‪.String‬‬
‫העמודה הימנית בטבלה מתארת את ש הפעולה ואת רשימת הפרמטרי שהיא מצפה לקבל )בתו!‬
‫סוגריי(‪ .‬כפי שראינו זה עתה‪ ,‬הפעולה הראשונה בטבלה‪ ,length ,‬אינה מצפה לקבל ער! כלשהו‪,‬‬
‫ולכ הסוגריי ריקי‪ .‬לעומתה‪ ,‬הפעולה השנייה‪ ,charAt ,‬מצפה לקבל פרמטר אחד מטיפוס של‪,‬‬
‫והפעולה השלישית‪ indexOf ,‬מצפה לקבל עצ מהמחלקה מחרוזת‪ ,‬או תו‪.‬‬
‫העמודה השלישית מתארת את טיפוס הער! המוחזר כתוצאת הפעולה‪ .‬בדומה לפעולות המתמטיות‬
‫שלמדנו בפרק ‪ ,4‬ג כא יש לשי לב לטיפוס הער! המוחזר ולוודא התאמה בינו לבי הפעולות‬
‫המבוצעות עליו‪ .‬למשל‪ ,‬א נבצע השמה של ער! מוחזר מפעולה על מחרוזת לתו! משתנה‪ ,‬עלינו‬
‫לוודא התאמה בי טיפוס הער! המוחזר לטיפוס המשתנה אליו מתבצעת ההשמה‪.‬‬
‫חלק מהגדרת המחלקה מחרוזת כוללת הגדרה של פעולות הניתנות לביצוע‬
‫על מחרוזת‪.‬‬
‫הפעלת פעולה של המחלקה מחרוזת על עצ מהמחלקה מחרוזת נכתבת כ!‪:‬‬
‫)פרמטרי(ש הפעולה‪.‬ש העצ‬
‫יש לבדוק היטב בתיאור הפעולה אילו ערכי היא מצפה לקבל ומה טיפוס הער! שהיא מחזירה‪.‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-388-‬‬
‫מדעי המחשב‬
‫בעיה ‪3‬‬
‫מטרת הבעיה ופתרונה‪ :‬הדגמת השימוש בפעולת השוואת מחרוזת של המחלקה ‪ ,String‬ושילוב‬
‫מחרוזות בתבנית מנייה‪.‬‬
‫פתחו ויישמו אלגורית אשר הקלט שלו הוא רשימת מחרוזות שמסתיימת במחרוזת‬
‫"‪"STOP‬‬
‫)זקי (‪ ,‬והפלט הוא מספר המחרוזות ברשימה‪.‬‬
‫למשל‪ ,‬עבור הקלט‪ "abc", "dog", "shalom", "people", "STOP" :‬הפלט המתאי הוא ‪.4‬‬
‫פירוק הבעיה לתתמשימות‬
‫למעשה‪ ,‬האלגורית צרי! לבצע מנייה‪ ,‬בדומה לאלגוריתמי אחרי שפיתחנו בפרקי אחרי‪ .‬לכ‪,‬‬
‫נית פשוט לכתוב את רשימת התת(משימות הבאה‪:‬‬
‫‪ .1‬מניית מספר המחרוזות שבקלט‬
‫‪ .2‬הצגה כפלט של מספר המחרוזות שנמנו‬
‫תת(משימה ‪ 1‬תבוצע בדומה למשימות מנייה אחרות‪ ,‬ההבדל הוא כמוב בטיפוס הערכי הנמני –‬
‫מחרוזת במקרה זה – ובאופ ביצוע הפעולות עליה‪ .‬בשלב יישו האלגורית נראה כיצד לעשות‬
‫זאת‪.‬‬
‫בחירת משתני‬
‫‪ – str‬המחרוזת התורנית מהקלט‪ ,‬עצ מהמחלקה מחרוזת‬
‫‪ – counter‬למניית מספר המחרוזות‪ ,‬מטיפוס של‬
‫האלגורית‬
‫‪0-ì counter úà ìçúà .1‬‬
‫‪str-ì úæåøçî èåì÷ .2‬‬
‫‪.3‬‬
‫‪ãåò ìë‬‬
‫"‪:òöá str ≠"STOP‬‬
‫‪1-á counter ìù åëøò úà ìãâä .3.1‬‬
‫‪str-ì úæåøçî èåì÷ .3.2‬‬
‫‪counter ìù åëøò úà èìôë âöä .4‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-389-‬‬
‫מדעי המחשב‬
‫יישו האלגורית‬
‫?‬
‫כיצד נבדוק הא המחרוזת הנקלטת שווה למחרוזת "‪?"STOP‬‬
‫הפעולה ‪ equals‬בודקת הא שתי מחרוזות שוות זו לזו‪ .‬נשתמש בה‪ ,‬כפי שמתואר בטבלה שבסו‬
‫הפרק‪.‬‬
‫התוכנית המלאה‬
‫*‪/‬‬
‫קלט‪ :‬רשימת מחרוזות המסתיימת בזקיף‬
‫פלט‪ :‬מספר המחרוזות ברשימה‬
‫‪*/‬‬
‫‪public class HowManyStrings‬‬
‫{‬
‫)‪public static void main (String[] args‬‬
‫{‬
‫הגדרת משתנים ואתחולם ‪//‬‬
‫;‪String str‬‬
‫;‪int counter = 0‬‬
‫לולאת זקיף ‪//‬‬
‫;)"‪str = In.readString("Insert a string please‬‬
‫כל עוד המחרוזת ‪ str‬שונה מ‪while (! str.equals("STOP")) //"STOP"-‬‬
‫{‬
‫;‪counter++‬‬
‫;)"‪str = In.readString("Insert another string please‬‬
‫‪} // while‬‬
‫;)" ‪System.out.println(counter + " Strings‬‬
‫‪} // main‬‬
‫‪} // class HowManyStrings‬‬
‫שימו ♥‪ :‬כפי שהסברנו קוד‪ ,‬הוראת הקלט של מחרוזת מקצה בכל פע מקו בזיכרו עבור‬
‫המחרוזת החדשה‪ .‬לכ למעשה‪ ,‬העצ ‪ str‬מפנה בכל פע אל מקו אחר בזיכרו‪ ,‬משו שבכל פע‬
‫ההשמה המתבצעת אליו מתייחסת לשטח זיכרו אחר‪.‬‬
‫סוף פתרון בעיה ‪3‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-390-‬‬
‫מדעי המחשב‬
‫שאלה ‪9.1‬‬
‫פתחו ויישמו אלגורית שיקבל כקלט מילה באנגלית ויציג אותה פעמיי‪ ,‬פע באותיות גדולות ופע‬
‫באותיות קטנות‪ .‬למשל‪ ,‬עבור הקלט ‪ Memory‬הפלט יהיה‪ MEMORY :‬ומיד אחר(כ! ‪.memory‬‬
‫שאלה ‪9.2‬‬
‫פתחו אלגורית שיקבל כקלט מחרוזת ותו‪ .‬פלט האלגורית יהיה מספר ההופעות של התו הנתו‬
‫בתו! המחרוזת הנתונה‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫הדרכה‪ :‬מאחר שנית לברר את אור! המחרוזת הנתונה נית להשתמש בהוראה לביצוע חוזר שמספר‬
‫הסיבובי בה ידוע מראש )לולאת ‪.(for‬‬
‫שאלה ‪9.3‬‬
‫פתחו אלגורית המקבל כקלט רשימת מחרוזות המסתיימת במחרוזת "***"‪.‬‬
‫פלט האלגורית יהיה המחרוזת הארוכה ביותר ברשימה‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫שרשור מחרוזות‬
‫פעולה נוספת ושימושית מאוד על מחרוזות היא פעולת השרשור‪ .‬פעולה זו מקבלת שתי מחרוזות‬
‫ויוצרת מחרוזת חדשה‪ ,‬המורכבת מהמחרוזת הראשונה כשאחריה מוצמדת המחרוזת השנייה‪ .‬היא‬
‫אינה משנה את המחרוזות המקוריות‪.‬‬
‫בשפת ‪ Java‬מתבצע שרשור בעזרת סימ הפעולה ‪ .+‬כלומר‪ ,‬א ‪ s1‬ו(‪ s2‬ה מחרוזות‪ ,‬אז ער! הביטוי‬
‫‪ s1+s2‬הוא השרשור של ‪ s1‬ו(‪ .s2‬למשל‪ ,‬א ב(‪ s1‬נמצאת המחרוזת "‪ "he‬וב(‪ s2‬נמצאת המחרוזת‬
‫"‪ ,"llo‬אז ‪ s1+s2‬היא המחרוזת החדשה "‪."hello‬‬
‫שימו ♥‪ :‬פעולת השרשור אינה פעולה של המחלקה מחרוזת ולכ אופ הפעלתה שונה מזה של‬
‫פעולות כמו ‪ charAt ,length‬או פעולות אחרות של המחלקה‪ .‬היא אינה מופעלת על עצ של‬
‫המחלקה‪ ,‬ולכ אי שימוש בסימ הנקודה‪ .‬אופ הפעלת פעולת השרשור על מחרוזות דומה לאופ‬
‫הפעלת פעולות על טיפוסי רגילי בשפה‪.‬‬
‫למעשה‪ ,‬כבר השתמשנו פעמי רבות בפעולת השרשור על מחרוזות‪ .‬כזכור‪ ,‬עד כה השתמשנו‬
‫במחרוזות בהוראות הדפסה כגו‬
‫;)"‪System.out.println("hello‬‬
‫לעיתי‪ ,‬פקודות ההדפסה היו מעט יותר מורכבות‪ .‬למשל‬
‫; )‪System.out.println("The number is: " + number‬‬
‫או אפילו‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-391-‬‬
‫מדעי המחשב‬
‫‪System.out.println("There are " + bags + " bags, " + left + " are left‬‬
‫;)"‪over.‬‬
‫בכל ההוראות האלו הפעולה ‪ println‬מקבלת מחרוזת להדפסה‪ .‬בראשונה מבי דוגמאות ההדפסה‬
‫שלעיל‪ ,‬זוהי המחרוזת "‪ ."hello‬בדוגמאות האחרות מועברות לפעולה ‪ println‬מחרוזות‬
‫שהתקבלה כתוצאה מהפעלת פעולה‪ ,‬פעולה שמחזירה מחרוזת‪ .‬כ! למשל‪ ,‬המחרוזת שקיבלה‬
‫‪ println‬בכל אחת משתי הדוגמאות האחרות‪ ,‬התקבלה כתוצאה מהפעלת הפעולה ‪) +‬פע אחת‬
‫בדוגמה הראשונה‪ ,‬וארבע פעמי בשנייה(‪.‬‬
‫למשל‪ ,‬א ערכו של המשתנה ‪ number‬הוא ‪ ,3‬אז המחרוזת שהועברה להדפסה בהוראה הראשונה‬
‫היא שרשור של המחרוזת " ‪ "The number is:‬ע המחרוזת "‪ ,"3‬כלומר המחרוזת‬
‫‪"The‬‬
‫"‪.number is: 3‬‬
‫שימו ♥‪ :‬מאחר שבמשתנה ‪ number‬יש ער! מטיפוס של‪ ,‬הרי שטר ביצוע פעולת השרשור‬
‫התבצעה באופ אוטומטי פעולת הסבה של הער! המספרי למחרוזת המתאימה לו‪ .‬כ! קורה תמיד‬
‫כאשר אנו מבקשי לשרשר מחרוזת ע ער! מטיפוס שאינו מחרוזת‪ :‬לפני ביצוע פעולת השרשור‬
‫מתבצעת באופ אוטומטי פעולת הסבה של הערכי שאינ מחרוזות למחרוזות‪ .‬לכ‪ ,‬הפעולה ‪+‬‬
‫מתבצעת כפעולת שרשור של מחרוזות ולפעולה ‪ println‬מועברת מחרוזת אחת‪ ,‬שהיא תוצאת‬
‫השרשור‪.‬‬
‫שרשור מחרוזות נית לבצע בעזרת הפעולה ‪ ,+‬כ!‪:‬‬
‫מחרוזת‪ + 2‬מחרוזת‪1‬‬
‫פעולת השרשור יוצרת מחרוזת חדשה‪ ,‬ודואגת להקצות עבורה מקו‪ .‬היא אינה משפיעה על‬
‫המחרוזות המקוריות‪.‬‬
‫לפני ביצוע שרשור של מחרוזת ע ער! שאינו מחרוזת‪ ,‬הער! שאינו מחרוזת מוסב באופ אוטומטי‬
‫למחרוזת‪.‬‬
‫שאלה ‪9.4‬‬
‫פתחו אלגורית שיקבל כקלט ‪ 100‬זוגות של מחרוזות‪ .‬עבור כל זוג מחרוזות תוצג כפלט מחרוזת‬
‫שהיא שרשור של שתי המחרוזות )כלומר‪ ,‬בס! הכל יוצגו ‪ 50‬מחרוזות(‪ .‬ישמו את האלגורית בשפת‬
‫‪.Java‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-392-‬‬
‫מדעי המחשב‬
‫ומה בפנים? פעולות המסתכלות אל תוך הקנקן‬
‫למרות שכל מחרוזת היא עצ אחד‪ ,‬כמה מ הפעולות המוגדרות על עצמי של המחלקה מחרוזת‬
‫מאפשרות להתייחס באופ מפורש ג לתווי שמרכיבי מחרוזת‪ .‬פעולות כאלו‪ ,‬כמו הפעולה‬
‫‪ charAt‬שכבר היכרנו‪ ,‬מסייעות מאוד בפתרו בעיות שונות‪ ,‬כפי שמדגימה הבעיה הבאה‪:‬‬
‫בעיה ‪4‬‬
‫מטרת הבעיה ופתרונה‪ :‬הדגמת השימוש בפעולות המגלות מידע על רכיביה של מחרוזת‪.‬‬
‫פתחו אלגורית שהקלט שלו הוא מחרוזת המהווה משפט באנגלית‪ ,‬והפלט הוא האות האחרונה של‬
‫המילה הראשונה במשפט‪ ,‬ומספר המילי במשפט‪.‬‬
‫למשל‪ ,‬עבור הקלט‪ welcome to Israel and have a nice day! :‬הפלט המתאי הוא ‪.e 8‬‬
‫ישמו את האלגורית בשפת ‪.Java‬‬
‫ניתוח הבעיה בעזרת דוגמאות‬
‫נתבונ במשפט שנית כדוגמה‪.welcome to Israel and have a nice day! :‬‬
‫?‬
‫כיצד נית לדעת כמה מילי יש במשפט הנתו?‬
‫כיוו שלפני כל מילה‪ ,‬חו* מהראשונה‪ ,‬יש רווח‪ ,‬נוכל למנות את מספר הרווחי במחרוזת ולהוסי ‪.1‬‬
‫למשל‪ ,‬במשפט !‪ welcome to Israel and have a nice day‬יש ‪ 7‬רווחי‪ ,‬ולכ ‪ 8‬מילי‪) .‬זאת בהנחה‬
‫שבי מילה למילה יש רווח אחד בלבד!(‬
‫?‬
‫מהי האות האחרונה במילה הראשונה?‬
‫האות האחרונה במילה הראשונה היא האות שנמצאת מיד לפני הרווח הראשו‪.‬‬
‫פירוק הבעיה לתתמשימות‬
‫לש פתרו הבעיה נפתור את התת(משימות הבאות‪:‬‬
‫‪ .1‬קליטת המחרוזת‬
‫‪ .2‬מניית מספר הרווחים במחרוזת שנקלטה‬
‫‪ .3‬חישוב מספר המילים במחרוזת‬
‫‪ .4‬מציאת הרווח הראשון במחרוזת‬
‫‪ .5‬מציאת התו שנמצא מיד לפני הרווח הראשון במחרוזת‬
‫‪ .6‬הצגה כפלט של מספר המילים במחרוזת ושל התו שנמצא בתת‪-‬משימה ‪5‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-393-‬‬
‫מדעי המחשב‬
‫בחירת משתני‬
‫‪ – sentence‬מחרוזת לשמירת המשפט שנקלט‬
‫‪– numOfSpaces‬של‪ ,‬מונה את מספר הרווחי במשפט‬
‫‪ – numOfWords‬של‪ ,‬שומר את מספר המילי במשפט‬
‫‪ – placeOfFirstSpace‬של‪ ,‬שומר את מיקומו של הרווח הראשו )לפניו נמצאת האות‬
‫המבוקשת(‬
‫האלגורית‬
‫‪sentence-á èôùî èåì÷ .1‬‬
‫‪0-ì numOfSpaces ìù åëøò úà ìçúà .2‬‬
‫‪.3‬‬
‫‪ìë øåáò‬‬
‫‪íà .3.1‬‬
‫‪:òöá úæåøçîä êøåàî ïè÷ù i éìéìù-éà íìù øôñî‬‬
‫‪çååø àåä sentence úæåøçîá i-ä íå÷îá àöîðù åúä‬‬
‫‪.3.1.1‬‬
‫‪1-á numOfSpaces ìù åëøò úà ìãâä‬‬
‫‪numOfSpaces+1 êøòä úà numOfWords-á íùä .4‬‬
‫‪placeOfFirstSpace-á íùäå ïåùàøä çååøä ìù åîå÷î úà àöî .5‬‬
‫‪sentence-á placeOfFirstSpace-1 íå÷îá úàöîðù úåàä úà èìôë âöä .6‬‬
‫‪numOfWords ìù åëøò úà èìôë âöä .7‬‬
‫יישו האלגורית‬
‫את הוראה ‪ 3.1‬אפשר לייש בעזרת הפעולה ‪ .charAt‬אבל‪ ,‬נשי לב שהפעולה ‪ charAt‬מחזירה ער!‬
‫מטיפוס ‪ char‬ולא מטיפוס מחרוזת‪ ,‬ולכ יש להשוות את הער! המוחזר ממנה לתו רווח )ולא‬
‫למחרוזת המכילה את התו היחיד רווח(‪ .‬א כ!‪ ,‬את הוראה ‪ 3.1‬נייש כ!‪:‬‬
‫)' '==)‪if (sentence.charAt(i‬‬
‫ליישו הוראה ‪ 5‬נשתמש בפעולה ‪ .indexOf‬כפי שמתואר בטבלה שבסו הפרק‪ ,‬פעולה זו יכולה‬
‫לקבל תו או מחרוזת‪ .‬לכ נעביר לה את התו רווח והיא תחזיר את מקומו במחרוזת‪ ,‬כמספר של‪:‬‬
‫)' '(‪sentence.indexOf‬‬
‫שימו ♥‪ :‬יש תמיד לדאוג להתאמה בי טיפוסי הערכי בה אנו משתמשי לבי אלו המתוארי‬
‫בכותרת הפעולה‪.‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-394-‬‬
‫מדעי המחשב‬
‫התוכנית המלאה‬
/*
‫ משפט באנגלית‬:‫קלט‬
‫ האות האחרונה במילה הראשונה ומספר המילים במשפט‬:‫פלט‬
*/
public class HowManyWords
{
public static void main (String[] args)
{
String sentence;
int placeOfFirstSpace;
int numOfSpaces = 0;
int numOfWords;
sentence = In.readString("Enter a sentence, with exactly one
space between words");
// ‫מניית הרווחים במשפט‬
for (int i = 0 ; i < sentence.length() ; i++)
{
if (sentence.charAt(i) == ' ')
{
numOfSpaces++;
} // if
} // for
numOfWords = numOfSpaces + 1;
// ‫מציאת מקומו של הרווח הראשון‬
placeOfFirstSpace = sentence.indexOf(' ');
System.out.println("The last letter of the first word is: " +
sentence.charAt(placeOfFirstSpace - 1));
// ‫כמה מילים במשפט‬
System.out.println("There are " + numOfWords + " words");
}//main
}// class HowManyWords
4 ‫סוף פתרון בעיה‬
‫מדעי המחשב‬
-395-
‫אביב‬-‫ אוניברסיטת תל‬,‫הוראת המדעים‬
‫שאלה ‪9.5‬‬
‫פתחו ויישמו אלגורית שהקלט שלו הוא תו ומחרוזת והפלט הוא הודעה הא התו נמצא במחרוזת‬
‫או לא‪.‬‬
‫שאלה ‪) 9.6‬בגרות ‪(1995‬‬
‫פתחו ויישמו אלגורית שקולט מחרוזת‪ .‬האלגורית מציג כפלט כל תו במחרוזת פעמיי‪ ,‬פרט לתו‬
‫'*' )כוכבית( אשר ג א הוא כלול במחרוזת הוא לא מוצג כלל‪ .‬הפלט מוצג בשורה אחת‪.‬‬
‫למשל‪ ,‬עבור הקלט‪ AB*3B*? :‬הפלט יהיה ??‪.AABB33BB‬‬
‫שאלה ‪9.7‬‬
‫פתחו ויישמו אלגורית שמקבל כקלט רשימה של ‪ 100‬מחרוזות‪ .‬האלגורית מחשב בכמה מחרוזות‬
‫מתו! ה(‪ 100‬התו הראשו שווה לתו האחרו‪ ,‬ומציג כפלט את הער! שחישב‪.‬‬
‫שאלה ‪9.8‬‬
‫פתחו אלגורית שהקלט שלו הוא שלוש מחרוזות‪ ,‬והפלט שלו הוא שלוש המחרוזות לפי סדר מילוני‪.‬‬
‫ישמו את האלגורית בשפת ‪.Java‬‬
‫למשל‪ ,‬עבור הקלט‪ good, today, apple :‬הפלט המתאי הוא‪today :‬‬
‫‪good‬‬
‫‪.apple‬‬
‫‪ 9.3‬השמת מחרוזות‬
‫עד כה ראינו כיצד לבצע פעולות קלט ופלט של מחרוזות‪ ,‬והשתמשנו בפעולות שונות על מחרוזות‪,‬‬
‫פעולות שמחזירות לנו מידע על המחרוזת‪ .‬בעיבוד של משתני רגילי‪ ,‬אחת מהפעולות השימושיות‬
‫ביותר היא הוראת השמה‪ .‬בסעי זה נדו בביצוע השמה עבור מחרוזות‪ ,‬כלומר בהשמה של מחרוזת‬
‫אל מחרוזת‪.‬‬
‫למעשה‪ ,‬כפי שכבר נאמר‪ ,‬ג הוראת קלט של מחרוזת היא הוראת השמה‪ .‬למשל‪ ,‬בהוראה‬
‫;)(‪str = In.readString‬‬
‫הפעולה ‪ In.readString‬מחזירה הפניה לשטח הזיכרו החדש שהוקצה עבור מחרוזת הקלט‪.‬‬
‫בעקבות ההשמה מפנה ‪ str‬אל אותו שטח זיכרו‪ ,‬ודר! ‪ str‬נית להגיע אל אותו שטח ולבצע עליו‬
‫פעולות שונות‪.‬‬
‫בסעי זה נראה כיצד לבצע השמה של מחרוזות‪ ,‬שאינה הוראת קלט או הוראת הקצאה ואתחול‪.‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-396-‬‬
‫מדעי המחשב‬
‫בעיה ‪5‬‬
‫מטרת הבעיה הבאה‪ :‬הצגת השמת מחרוזת למחרוזת והדגמה נוספת של השימוש בפעולות של‬
‫המחלקה ‪.String‬‬
‫נאמר שכתובת דואר אלקטרוני היא חוקית א היא מקיימת את התנאי הבאי‪:‬‬
‫מתחילה באות לועזית‪ ,‬מורכבת מרצ לא ריק של תווי שאחריו מגיע התו '@'‪ ,‬אחריו שוב רצ לא‬
‫ריק‬
‫של‬
‫תווי‪,‬‬
‫אחריו‬
‫התו‬
‫'‪,'.‬‬
‫ולאחריו‬
‫עוד‬
‫רצ‬
‫לא‬
‫ריק‬
‫של‬
‫תווי‪.‬‬
‫כתובת ישראלית מסתיימת במחרוזת "‪".il‬‬
‫בקביעת חוקיות של כתובת דואר אי משמעות להבדל בי אותיות גדולות וקטנות‪.‬‬
‫למשל‪ ,‬המחרוזת ‪ d@ccv.hhh‬היא כתובת דואר אלקטרוני חוקית‪ ,‬וכ! ג ‪.IL‬ייי@‪ ,t‬שהיא כתובת‬
‫ישראלית‪ .‬לעומת‪ ,‬המחרוזות הבאות אינ כתובות חוקיות‪.cc :‬יח@ח )לא מתחילה באות לועזית(‪,‬‬
‫‪) tr@.il‬רצ‬
‫התווי שבי התו '@' לבי התו '‪ '.‬הוא ריק(‪) rt@jjj ,‬לא מכילה את התו '‪('.‬‬
‫‪) sda.asd@sad‬התו '‪ '.‬מופיע לפני התו '@'(‪.‬‬
‫פתחו אלגורית המקבל כקלט מחרוזת‪ .‬נית להניח כי במחרוזת המתקבלת התו '‪ '.‬לא מופיע יותר‬
‫מפע אחת וכ! ג התו '@'‪ .‬האלגורית מציג כפלט את המחרוזת שנקלטה‪ ,‬בצירו הודעה‬
‫המבהירה א המחרוזת מהווה כתובת דואר אלקטרוני חוקית‪ ,‬וא כ‪ ,‬הא זוהי כתובת ישראלית‪.‬‬
‫ישמו את האלגורית בשפת התכנות ‪.Java‬‬
‫ניתוח הבעיה בעזרת דוגמאות‬
‫הכתובת ‪ tr@xxx.IL‬היא חוקית וישראלית‪ .‬ג הכתובת ‪ tr@xxx.il‬היא חוקית וישראלית‪ .‬אכ‪ ,‬אי‬
‫משמעות לשימוש באותיות קטנות או גדולות – ההבדל ביניה אינו משפיע על קביעת חוקיות‬
‫המחרוזת וג לא על סיווגה ככתובת ישראלית‪ .‬אבל‪ ,‬הפלט אינו לגמרי זהה בשני המקרי‪ :‬אמנ‪,‬‬
‫בשני המקרי נציג הודעה כי המחרוזת חוקית וישראלית‪ ,‬א! במקרה הראשו נציג את המחרוזת‬
‫‪ tr@xxx.IL‬ובמקרה השני את המחרוזת ‪.tr@xxx.il‬‬
‫כיוו שלצור! בדיקת חוקיות המחרוזת והקביעה א היא ישראלית או לא אי משמעות להבדל בי‬
‫אותיות גדולות לקטנות‪ ,‬נוכל לפשט את הבדיקה א נבצע אותה על מחרוזת זהה למחרוזת הקלט‬
‫פרט לכ! שהיא אחידה‪ ,‬כלומר‪ ,‬מורכבת רק מאותיות גדולות או רק מאותיות קטנות‪ .‬נחליט כי‬
‫המחרוזת האחידה תורכב כולה מאותיות קטנות‪ .‬את מחרוזת הקלט נשמור כמו שהיא‪ ,‬כדי שנוכל‬
‫להציגה כפלט‪.‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-397-‬‬
‫מדעי המחשב‬
‫קל לבדוק א התו הראשו הוא אות לועזית‪ .‬ברגע שבדיקה זו הצליחה‪ ,‬כבר ברור שהמילה אינה‬
‫מתחילה בתו '@'‪ ,‬כלומר‪ ,‬שהרצ שלפני התו '@' אינו ריק‪.‬‬
‫פירוק הבעיה לתתמשימות‬
‫‪ .1‬קליטת מחרוזת‬
‫‪ .2‬יצירת מחרוזת זהה לזו שנקלטה‪ ,‬פרט לכך שבמקום כל אות גדולה מופיעה האות הקטנה‬
‫המתאימה לה‬
‫‪ .3‬בדיקה שהתו הראשון הוא אות לועזית‬
‫‪ .4‬בדיקה שהתוים '@' ו‪ '.'-‬מופיעים במחרוזת‬
‫‪ .5‬בדיקה שהתו '‪ '.‬מופיע אחרי התו '@'‪ ,‬אך לא מיד אחריו‬
‫‪ .6‬בדיקה שהרצף אחרי התו '‪ '.‬אינו ריק‬
‫‪ .7‬עבור מחרוזת חוקית‪ :‬בדיקה אם היא ישראלית‬
‫‪ .8‬הצגה כפלט של המחרוזת ושל הודעה מלווה מתאימה‬
‫בחירת משתני‬
‫בשאלה מתוארי כמה תנאי בה צריכה לעמוד מחרוזת חוקית‪ .‬מספיק שאחד מה לא מתקיי‪,‬‬
‫כדי לקבוע שהמחרוזת אינה חוקית‪ .‬נוכל להיעזר במשתנה בוליאני‪ :‬כל עוד לא מצאנו בעיה בכתובת‬
‫הדואר האלקטרוני ערכו של המשתנה יהיה ‪ .true‬כאשר נמצא שגיאה באחד התנאי נציב בו ‪.false‬‬
‫ההודעה לפלט תוצג על פי ערכו של המשתנה‪.‬‬
‫בנוס נזדקק לשתי מחרוזות‪ :‬האחת לשמירת מחרוזת הקלט המקורית‪ ,‬והשנייה לשמירת המחרוזת‬
‫האחידה‪.‬‬
‫כדי לבדוק את חוקיות המחרוזת נשתמש בשני משתני שלמי שישמרו את מקו התווי '@' ו('‪.'.‬‬
‫לבסו ‪ ,‬נקדיש משתנה ג לאור! המחרוזת שנקרא מהקלט‪ .‬כ! נוכל לחשב את האור! פע אחת‪,‬‬
‫ולהשתמש בער! המשתנה בכל הפעמי בה נזדקק לאור! המחרוזת‪.‬‬
‫‪ – isLegal‬משתנה בוליאני )"דגל"(‪ ,‬שיעיד הא הכתובת היא חוקית או לא‬
‫‪ – str‬מחרוזת לשמירת הכתובת הנקלטת‬
‫‪ – lowerCaseStr‬מחרוזת זהה למחרוזת הקלט פרט לכ! שבמקו כל אות גדולה נמצאת‬
‫האות הקטנה המתאימה לה‬
‫‪ – atPlace‬מספר של‪ ,‬לשמירת מקומו של התו '@'‬
‫‪ – dotPlace‬מספר של‪ ,‬לשמירת מקומו של התו '‪'.‬‬
‫‪ – len‬אור! מחרוזת הקלט‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-398-‬‬
‫מדעי המחשב‬
‫האלגורית‬
true-ì isLegal êøò úà ìçúà .1
str-ì úáåúë èåì÷ .2
äìåãâ úåà ìë íå÷îáù êëì èøô ,str-áù úæåøçîì ääæ ,äùãç úæåøçî øåö .3
lowerCaseStr-á äúåà íùäå ,äì äîéàúîä äðè÷ä úåàä úàöîð
úéìâðà úåà àì àéä äðåùàøä úåàä
íà
.4
false-ì isLegal êøò úà äðù .4.1
úæåøçîá íéòéôåî íðéà '@' åúä
åà '.' åúä íà
.5
false-ì isLegal êøò úà äðù .5.1
úøçà
åéøçà ãééî àì êà '@' åúä éøçà òéôåî '.' åúä
false-ì isLegal êøò úà äðù
.6
íà .6.1
.6.1.1
(len – 1 íå÷îá) úæåøçîá ïåøçà òéôåî '.' åúä
íà
.7
false-ì isLegal êøò úà äðù .7.1
true-ì äååù isLegal ìù åëøò
íà
.8
úé÷åç úáåúëä éë äòãåä èìôë âöä .8.1
".il"
úæåøçîä íä íéðåøçàä íéååúä úùåìù
úéìàøùé úáåúëä éë äòãåä èìôë âöä
íà .8.2
.8.2.1
úøçà .8.3
úéìàøùé äðéà úáåúëä éë äòãåä èìôë âöä
.8.3.1
úøçà
.9
úé÷åç úáåúëä éë äòãåä èìôë âöä .9.1
‫מדעי המחשב‬
-399-
‫אביב‬-‫ אוניברסיטת תל‬,‫הוראת המדעים‬
‫יישו האלגורית‬
‫כדי לבדוק הא התווי '‪ '.‬ו( '@' מופיעי במחרוזת ‪ ,str‬וא כ – הא מיקומ תקי‪ ,‬נשתמש‬
‫בפעולה ‪ str.indexOf‬המקבלת תו‪ ,‬ומחזירה את מקומו במחרוזת ‪.str‬‬
‫כדי ליצור ממחרוזת הקלט )השמורה ב(‪ (str‬מחרוזת חדשה הזהה לה‪ ,‬פרט לכ! שכל אות גדולה‬
‫הוחלפה באות הקטנה המתאימה לה‪ ,‬נשתמש בפעולה ‪ .str.toLowerCase‬כמו כל פעולה הפועלת‬
‫על מחרוזות‪ ,‬ג הפעולה ‪ toLowerCase‬אינה משנה את המחרוזת עליה היא מופעלת‪ ,‬כלומר‪ ,‬היא‬
‫אכ יוצרת מחרוזת חדשה‪ .‬כמו כל פעולה שיוצרת מחרוזת חדשה‪ ,‬הפעולה ‪ toLowerCase‬דואגת‬
‫להקצות מקו עבור המחרוזת החדשה‪.‬‬
‫אנו מעונייני שדר! המשתנה ‪ lowerCaseStr‬נית יהיה להגיע למחרוזת החדשה‪ .‬לכ נשתמש‬
‫במשפט השמה‪ ,‬ונשי את הער! המוחזר מהפעולה ‪ str.toLowerCase‬ל(‪ ,lowerCaseStr‬כ!‪:‬‬
‫;)(‪lowerCaseStr = str.toLowerCase‬‬
‫בעקבות הוראה זאת העצ ‪ lowerCaseStr‬מפנה אל שטח בזיכרו‪ ,‬בו שמורה מחרוזת חדשה‪ ,‬הזהה‬
‫למחרוזת הקלט‪ ,‬פרט לכ! שבמקו כל אות גדולה נמצאת האות הקטנה המתאימה לה‪ .‬במחרוזת‬
‫המקורית‪ ,‬השמורה ב(‪ str‬לא חל כל שינוי‪.‬‬
‫לא היינו צריכי להקצות במפורש שטח זיכרו לעצ ‪ ,lowerCaseStr‬מפני שההקצאה עבור השטח‬
‫אליו הוא מפנה בוצעה בתו! הפעולה ‪.toLowerCase‬‬
‫התוכנית המלאה‬
‫*‪/‬‬
‫התוכנית מקבלת כקלט מחרוזת‪ ,‬מציגה אותה כפלט‪ ,‬ומציגה גם הודעה המבהירה אם‬
‫זו מחרוזת דואר אלקטרוני חוקית‪ ,‬ואם כן‪ ,‬האם היא כתובת ישראלית‬
‫‪*/‬‬
‫‪public class EmailAddress‬‬
‫{‬
‫)‪public static void main (String[] args‬‬
‫{‬
‫מחרוזת הקלט ‪//‬‬
‫;‪String str‬‬
‫‪//‬‬
‫;‪String lowerCaseStr‬‬
‫מחרוזת זהה למחרוזת הקלט‪ ,‬פרט לכך‬
‫שאותיות גדולות מוחלפות בקטנות‬
‫שומר מיקום התו '@' ‪//‬‬
‫;‪int atPlace‬‬
‫שומר מיקום התו '‪// '.‬‬
‫;‪int dotPlace‬‬
‫דגל חוקיות הכתובת ‪//‬‬
‫;‪boolean isLegal = true‬‬
‫אורך המחרוזת שנקלטה ‪//‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-400-‬‬
‫;‪int len‬‬
‫מדעי המחשב‬
// ‫קלט מחרוזת ושמירת אורכה‬
str = In.readString("Insert an e-mail address, with only one .
and one @");
len = str.length();
// ‫יצירת המחרוזת החדשה ושמירתה‬
lowerCaseStr = str.toLowerCase();
// ‫בדיקה שהתו הראשון הוא אות לועזית‬
if (!(str.charAt(0) >= 'a' && str.charAt(0) <= 'z'))
{
isLegal = false;
} // if
// '@'-‫' ו‬.' ‫מציאת מקום התווים‬
atPlace = lowerCaseStr.indexOf('@');
dotPlace = lowerCaseStr.indexOf('.');
if ((dotPlace == -1)||(atPlace == -1)) // ‫אחד משני התווים חסר‬
{
isLegal = false;
}
else
{
if ((dotPlace < atPlace)|| (dotPlace == atPlace + 1))
{ // ‫הסדר בין התווים שגוי או שהם מופיעים ברצף‬
isLegal = false;
}
} // else
// ‫' אינו ריק‬.' ‫בדיקה שרצף התווים שאחרי התו‬
if (dotPlace == len - 1)
{
isLegal = false;
}
// ‫הפלט‬
if (isLegal)
{
System.out.println(str + " is a legal Email address");
// .il-‫ האם שווים ל‬,‫בדיקת שלושת התווים האחרונים במחרוזת‬
if (lowerCaseStr.IndexOf(".il") == len - 3)
‫מדעי המחשב‬
-401-
‫אביב‬-‫ אוניברסיטת תל‬,‫הוראת המדעים‬
‫{‬
‫;)"‪System.out.println("Email address is Israeli‬‬
‫}‬
‫‪else‬‬
‫{‬
‫;)"‪System.out.println("Email address is not Israeli‬‬
‫}‬
‫)‪}// if (isLegal‬‬
‫‪else‬‬
‫{‬
‫;)"‪System.out.println(str + " is not a legal Email address‬‬
‫}‬
‫‪} // main‬‬
‫‪} // EmailAddress‬‬
‫סוף פתרון בעיה ‪5‬‬
‫השמת מחרוזות נכתבת כהוראת השמה רגילה‪:‬‬
‫;‪string1 = string2‬‬
‫בעקבות ביצוע ההשמה‪ ,‬מפנה ‪ string1‬אל אותו שטח זיכרו שאליו מפנה ‪ .string2‬לכ‪ ,‬אי‬
‫צור! לבצע קוד הקצאת זיכרו עבור ‪.string1‬‬
‫בעיה ‪6‬‬
‫מטרת הבעיה ופתרונה‪ :‬הדגמת בניית מחרוזת בשלבי‪ .‬היכרות ע הפעולה ‪.new‬‬
‫פתחו אלגורית אשר הקלט שלו הוא מחרוזת‪ .‬הפלט יהיה מחרוזת חדשה‪ ,‬הזהה למחרוזת‬
‫המקורית‪ ,‬פרט לכ! שמופיעה בה האות ‪ c‬בכל מקו שבו הופיעה האות ‪ b‬או ‪ B‬במחרוזת המקורית‪.‬‬
‫למשל‪ ,‬עבור המחרוזת "‪ "abcd‬הפלט יהיה המחרוזת "‪."accd‬‬
‫שימו ♥‪ :‬פרט לשינוי המתואר‪ ,‬המחרוזת החדשה צריכה להיות זהה למקורית‪ .‬בפרט‪ ,‬לא נית‬
‫להפו! בה אותיות גדולות לקטנות או להפ!‪.‬‬
‫פירוק הבעיה לתתמשימות‬
‫‪ .1‬קליטת מחרוזת‬
‫‪ .2‬בניית המחרוזת החדשה‬
‫‪ .3‬הדפסת המחרוזת החדשה‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-402-‬‬
‫מדעי המחשב‬
‫את תת(משימה ‪ 2‬נוכל לפרק באופ הבא‪:‬‬
‫‪ .2.1‬יצירת מחרוזת חדשה ואתחולה למחרוזת ריקה‬
‫‪ .2.2‬בנייה הדרגתית של המחרוזת החדשה‪ ,‬תו בכל פעם‬
‫את תת(משימה ‪ 2.2‬נוכל לייש על ידי הוראה לביצוע חוזר‪ ,‬בה מספר הפעמי לביצוע ידוע מראש‬
‫ונקבע על פי אור! המחרוזת‪.‬‬
‫בחירת משתני‬
‫‪ – str‬המחרוזת שמתקבלת כקלט‬
‫‪ – new_str‬המחרוזת החדשה‬
‫האלגורית‬
‫‪str-ì úæåøçî èåì÷ .1‬‬
‫‪ä÷éø úæåøçîë new_str úà ìçúà .2‬‬
‫‪.3‬‬
‫‪ìë øåáò‬‬
‫‪:òöá str-á character åú‬‬
‫‪åà 'b'-ì äååù character íà .3.1‬‬
‫‪.3.1.1‬‬
‫'‪'B‬‬
‫‪'c' åúä úà new_str-ì øùøù‬‬
‫‪úøçà .3.2‬‬
‫‪.3.2.1‬‬
‫‪character åúä úà new_str-ì øùøù‬‬
‫‪new_str úà èìôë âöä .4‬‬
‫יישו האלגורית‬
‫בפתרו בעיה זו אנו מצהירי לראשונה על מחרוזת שתקבל את ערכה הראשוני לא על ידי הוראת‬
‫קלט ולא על ידי השמה אלא על ידי אתחול )הוראה ‪ .(2‬משו כ!‪ ,‬בניגוד לפתרונות הקודמי בה‬
‫הקצאת השטח עבור המחרוזת נעשתה באופ סמוי )על ידי פעולת הקלט או על ידי פעולות אחרות‬
‫המייצרות מחרוזות( בפתרו זה נדאג אנו להקצאת שטח עבור המחרוזת‪.‬‬
‫הקצאה מקו לעצ מתבצעת על ידי הפעולה ‪ .new‬למשל‪ ,‬כדי להקצות מקו בזיכרו לעצ‬
‫מהמחלקה מחרוזת נכתוב‪:‬‬
‫‪str‬‬
‫;)(‪String str = new String‬‬
‫הוראה זו מצהירה על העצ ומקצה לו מקו בזיכרו‪.‬‬
‫כזכור‪ ,‬עבור משתני רגילי נית לבצע אתחול תו! כדי הצהרה‪ .‬ג עצמי נית לאתחל תו! כדי‬
‫הצהרה‪ ,‬על ידי העברת ער! לפעולה ‪ .new‬למשל‪ ,‬ההוראה‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-403-‬‬
‫מדעי המחשב‬
‫;)"‪String str = new String("abc‬‬
‫מצהירה על עצ של המחלקה מחרוזת בש ‪ ,str‬מקצה לו מקו בזיכרו‪ ,‬ומאתחלת את ערכו‪ ,‬כ!‬
‫שכעת הוא שומר בתוכו את המחרוזת "‪."abc‬‬
‫לא במקרה הוראת אתחול זו דומה להשמה‪ .‬למעשה‪ ,‬פעולת ‪ ,new‬מיד אחרי שהיא מקצה שטח‬
‫בזיכרו‪ ,‬היא מחזירה ער!‪ ,‬שהוא הפניה לשטח הזיכרו שהוקצה‪.‬‬
‫ההוראה )"‪ str = new String("abc‬היא אכ הוראת השמה‪ ,‬בה מוש הער! המוחזר מהפעולה‬
‫‪ new‬ב(‪ .str‬כעת‪ str ,‬מפנה אל השטח שהוקצה עבורו בזיכרו‪ ,‬ובכל פע שנתייחס בתוכנית לעצ‬
‫‪ str‬ונבצע עליו פעולות שונות‪ ,‬ה יתבצעו על שטח הזיכרו המתאי‪.‬‬
‫בדומה להשמת ער! ראשוני לתו! משתני‪ ,‬ג הקצאת מקו בזיכרו לעצמי‪ ,‬ואתחול המקו הזה‬
‫לא חייבי להיעשות מיד ע ההצהרה‪ .‬למשל‪ ,‬נית לכתוב את ההוראות הבאות‪:‬‬
‫;‪String str‬‬
‫;)"‪str = new String("abc‬‬
‫ע זאת‪ ,‬בדיוק כמו שעבור משתני העדפנו לאתחל משתנה כמה שיותר מוקד‪ ,‬מיד כשידוע ער!‬
‫מתאי לאתחול‪ ,‬ולא לדחות את האתחול‪ ,‬כ! ג לגבי עצמי בכלל‪ ,‬ומחרוזות בפרט‪.‬‬
‫ביישו האלגורית לפתרו בעיה ‪ ,2‬האתחול כמחרוזת ריקה )הוראה ‪ (2‬יכול להתבצע יחד ע‬
‫הקצאת המקו עבור המחרוזת‪ ,‬כלומר‪ ,‬בעזרת הפעולה ‪ ,new‬כ!‪:‬‬
‫;)""(‪new_str = new String‬‬
‫את ערכו של כל תו תור במחרוזת נוכל לדעת )לצור! הוראה ‪ (3.1‬בעזרת הפעולה ‪.charAt‬‬
‫בהוראות ‪ 3.1.1‬ו(‪ 3.2.1‬עלינו לשרשר תו נוס למחרוזת‪ .‬נוכל להשתמש לש כ! בפעולת השרשור על‬
‫מחרוזות‪ .‬לכ‪ ,‬למשל‪ ,‬את הוראה ‪ 3.1.1‬נוכל לייש כ!‪:‬‬
‫;'‪new_str = new_str +'c‬‬
‫שימו ♥‪ :‬פעולת השרשור היא פעולה שמחזירה מחרוזת‪ .‬כמו כל פעולה שמחזירה מחרוזת‪ ,‬פעולת‬
‫השרשור אינה משנה את המחרוזות עליה היא פועלת‪ ,‬אלא יוצרת מחרוזת חדשה )כמוב‪ ,‬אחרי‬
‫שדאגה להקצות מקו עבורה(‪ ,‬השווה לשרשור המחרוזות המקוריות‪.‬‬
‫נניח למשל‪ ,‬שב(‪ new_str‬נמצאת המחרוזת "‪ ."ad‬מה קורה בעת ביצוע הוראת ההשמה שלעיל?‬
‫פעולת השרשור מקבלת שתי מחרוזות )במקרה זה‪ new_str ,‬והמחרוזת "‪ ,"c‬אחרי המרת התו‬
‫'‪'c‬‬
‫למחרוזת(‪ ,‬יוצרת‪ ,‬תו! הקצאת מקו מתאי בזיכרו‪ ,‬מחרוזת חדשה שמכילה את שרשור שתי‬
‫המחרוזות‪ ,‬כלומר את המחרוזת "‪ ."adc‬היא מחזירה את המחרוזת החדשה‪.‬‬
‫בפעולת ההשמה מושמת אותה מחרוזת חדשה אל ‪ .new_str‬כלומר‪ ,‬במקו ש(‪ new_str‬יפנה אל‬
‫המחרוזת המקורית )"‪ ,("ad‬הוא מצביע כעת אל השטח החדש בזיכרו‪ .‬מה קרה לעצ שהוא‬
‫המחרוזת המקורית? נית לומר שהוא הל! לאיבוד‪ .‬בכ! פעולת השמה של מחרוזות אינה שונה‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-404-‬‬
‫מדעי המחשב‬
‫מפעולת השמה רגילה של משתני‪ :‬ג כאשר אנו מבצעי השמה כגו ‪ ,x = y‬כאשר ‪ x‬ו(‪ y‬משתני‬
‫רגילי‪ ,‬ערכו המקורי של ‪ x‬אובד‪ ,‬והער! החדש‪ ,‬הלא הוא ערכו של ‪ ,y‬מחלי אותו‪.‬‬
‫כאשר נשרשר למחרוזת תו נוס ‪ ,‬אותו תהלי! יחזור על עצמו‪ :‬הקצאת שטח למחרוזת חדשה שהיא‬
‫שרשור של המחרוזת המקורית והתו החדש‪ ,‬והשמה‪ ,‬הגורמת ל(‪ new_str‬להצביע על המחרוזת‬
‫החדשה‪.‬‬
‫א כ!‪ ,‬בבנייה הדרגתית של מחרוזת‪ ,‬כפי שתואר לעיל‪ ,‬לא יהיה זה מדויק לומר שאותה מחרוזת‬
‫צומחת כל פע בתו נוס ‪ .‬למעשה‪ ,‬נוצרת סדרה של מחרוזות‪ :‬בכל פע נוצרת מחרוזת חדשה‪ ,‬ארוכה‬
‫בתו אחד‪ ,‬והיא תופסת את מקומה של המחרוזת הקודמת‪.‬‬
‫התוכנית המלאה‬
‫*‪/‬‬
‫קלט‪ :‬מחרוזת‬
‫פלט‪ :‬מחרוזת זהה למקורית‪ ,‬פרט לכך שכל '‪ 'B‬או '‪ 'b‬מוחלף ב‪'c'-‬‬
‫‪*/‬‬
‫‪public class ReplaceCForB‬‬
‫{‬
‫)‪public static void main (String[] args‬‬
‫{‬
‫;‪String str‬‬
‫מחרוזת הקלט ‪//‬‬
‫המחרוזת החדשה ‪//‬‬
‫;‪String new_str‬‬
‫קלט ‪//‬‬
‫;)"‪str = In.readString("Insert a string please‬‬
‫בניית המחרוזת החדשה ‪//‬‬
‫אתחול המחרוזת החדשה למחרוזת ריקה ‪new_str = new String("");//‬‬
‫סריקת מחרוזת הקלט תו אחר תו‪for(int i = 0; i<str.length(); i++)//‬‬
‫{‬
‫))'‪if ((str.charAt(i) == 'b') || (str.charAt(i) == 'B‬‬
‫{‬
‫החלפת '‪ 'B‬או '‪ 'b‬ב‪new_str = new_str + 'c'; // 'c'-‬‬
‫}‬
‫‪else‬‬
‫{‬
‫העתקת התו המקורי ‪new_str = new_str + str.charAt(i); //‬‬
‫}‬
‫‪} // for‬‬
‫פלט ‪//‬‬
‫;)‪System.out.println("The new String is: " + new_str‬‬
‫‪} // main‬‬
‫‪} // class ReplaceCForB‬‬
‫סוף פתרון בעיה ‪6‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-405-‬‬
‫מדעי המחשב‬
‫הקצאת שטח זיכרו למחרוזת‬
‫נית לבצע בעזרת הפעולה ‪.new‬‬
‫נית להעביר לפעולה ‪ new‬ער! לאתחול המחרוזת החדשה‪.‬‬
‫כאשר אנו נדרשי לבנות מחרוזת חדשה בשלבי‪ ,‬תו אחרי‬
‫תו נית לעשות זאת באופ‬
‫הבא‪ :‬ליצור מחרוזת חדשה ולאתחל אותה כמחרוזת ריקה )""(; באמצעות הוראה לביצוע חוזר‪,‬‬
‫לבצע בכל פע שרשור של המחרוזת הנוכחית ע תו מתאי‪ ,‬והחלפת המחרוזת הנוכחית במחרוזת‬
‫החדשה‪ ,‬שהתקבלה מפעולת השרשור‪.‬‬
‫שאלה ‪9.9‬‬
‫פתחו ויישמו אלגורית שהקלט שלו הוא מחרוזת המהווה משפט משובש‪ :‬במקו כל רווח מופיע‬
‫הסימ ‪ .$‬האלגורית מייצר מחרוזת חדשה ובה המשפט התקני‪ ,‬ומציג אותו כפלט‪ .‬ישמו את‬
‫האלגורית בשפת ‪.Java‬‬
‫שאלה ‪9.10‬‬
‫ר וד המציאו שפה מוצפנת‪ .‬המשפטי הניתני להצפנה כוללי מילי ורווחי בלבד‪ ,‬כאשר כל‬
‫מילה נכתבת רק באותיות לועזיות קטנות‪.‬‬
‫ההצפנה מתבצעת באופ הבא‪ :‬כל רווח מוחל בסימ '@'‪ ,‬ולאחר כל אות מופיעה האות הלועזית‬
‫הגדולה המתאימה לה‪.‬‬
‫למשל‪ ,‬המשפט ‪ good morning‬מוצפ כ! ‪.gGoOoOdD@mMoOrRnNiInNgG‬‬
‫פתחו אלגורית המקבל משפט כקלט ומציג כפלט את המשפט המוצפ המתאי לו‪ .‬ישמו את‬
‫האלגורית בשפת ‪.Java‬‬
‫שאלה ‪9.11‬‬
‫פתחו אלגורית שמקבל כקלט מחרוזת‪ ,‬מייצר מחרוזת חדשה שבה סדר התווי הפו! ביחס‬
‫למחרוזת המקורית‪ ,‬ומציג את המחרוזת החדשה כפלט‪ .‬בנוס ‪ ,‬האלגורית בודק א שתי המחרוזות‬
‫)המקורית וההפוכה( שוות זו לזו‪ .‬במילי אחרות‪ ,‬האלגורית בודק א המחרוזת המקורית היא‬
‫פלינדרו‪ .‬האלגורית מציג כפלט הודעה מתאימה לתוצאת הבדיקה‪.‬‬
‫למשל‪ ,‬עבור הקלט‪dog :‬‬
‫עבור הקלט‪aba :‬‬
‫יהיה הפלט‪.god – not a palindrome :‬‬
‫יהיה הפלט‪.aba – a palindrome :‬‬
‫ישמו את האלגורית בשפת ‪.Java‬‬
‫שאלה ‪9.12‬‬
‫תלמידי הכיתה התעניינו לדעת למי יש סבתא ע הש הכי ארו!‪ .‬פתחו אלגורית אשר יקבל כקלט‬
‫את מספר התלמידי בכיתה‪ ,‬ואחר כ! רשימה שאורכה כמספר תלמידי הכיתה‪ ,‬של שמות הסבתות‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-406-‬‬
‫מדעי המחשב‬
‫של תלמידי הכיתה‪ ,‬כמחרוזות‪ .‬פלט האלגורית יהיה הש הארו! ביותר‪ .‬ישמו את האלגורית‬
‫בשפת ‪.Java‬‬
‫שאלה ‪9.13‬‬
‫כתובת אתר אינטרנט של חברה מסחרית בינלאומית בנויה בדר! כלל מ(‪ 3‬חלקי המופרדי‬
‫בנקודות‪:‬‬
‫‪.com‬ש החברה‪www.‬‬
‫פתחו אלגורית המקבל כקלט כתובת של אתר של חברה מסחרית בינלאומית‪ ,‬במבנה שתואר לעיל‪,‬‬
‫ומציגה כפלט את ש החברה‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫הדרכה‪ :‬השתמשו בפעולה ‪ substring‬שבטבלת הפעולות אשר בסו הפרק‪.‬‬
‫שאלה ‪9.14‬‬
‫כתובת אתר אינטרנט של חברה מסחרית שאינה בינלאומית בנויה בדר! כלל מ(‪ 3‬חלקי המופרדי‬
‫בנקודות‪:‬‬
‫סיומת המדינה‪.‬ש החברה‪www.‬‬
‫פתחו אלגורית המקבל כקלט רשימת כתובות של אתרי חברות מסחריות לאומיות )כל אחת מה‬
‫במבנה שתואר לעיל(‪ ,‬המסתיימת במחרוזת "‪ ,"end‬ומציגה כפלט עבור כל חברה את שמה ואת סיומת‬
‫המדינה שלה‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫שאלה ‪9.15‬‬
‫יואב ועומרי המציאו משחק‪ .‬כל אחד בתורו רוש משפט המתחיל במילה האחרונה של המשפט‬
‫מהתור הקוד‪ .‬המשפט הראשו במשחק יתחיל במילה "‪ ."start‬למשל‪:‬‬
‫‪start the game‬‬
‫‪game is one of the best ways to kill the time‬‬
‫‪time is money‬‬
‫פתחו אלגורית המסייע למשחקי‪ :‬האלגורית מקבל כקלט את מספר התורות המבוקש‪ .‬בתחילת‬
‫כל תור הוא מציג את המילה בה צרי! להתחיל המשפט הבא‪ ,‬ולאחר מכ הוא מקבל כקלט את‬
‫המשפט החדש‪ .‬המשחק מסתיי כאשר מספר התורות הגיע לחס המבוקש‪ ,‬או כאשר המשפט שבחר‬
‫אחד השחקני מתחיל במילה שגויה‪ .‬ישמו את האלגורית בשפת ‪.Java‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-407-‬‬
‫מדעי המחשב‬
‫סיכום‬
‫בפרק זה למדנו כיצד לבצע עיבוד של מחרוזות‪.‬‬
‫בשפת ‪ Java‬מחרוזת אינה טיפוס פשוט‪ ,‬כמו ‪ int‬או ‪ .char‬הטיפוס החדש מוגדר בשפה כמחלקה‬
‫בש ‪ ,String‬ומחרוזות ה עצמי של מחלקה זו‪.‬‬
‫למעשה‪ ,‬כבר הכרנו והשתמשנו במחלקות שונות כגו מחלקת המתמטיקה ששימשה אותנו לצור!‬
‫ביצוע פעולות מתמטיות שונות‪ ,‬או המחלקה ‪ System‬ששימשה אותנו להוראות פלט )כמו‬
‫‪ .(System.out.println‬אבל‪ ,‬בפרק זה הכרנו והגדרנו לראשונה מופעי של מחלקה‪ ,‬עצמי‪ ,‬שה‪,‬‬
‫כאמור‪ ,‬מעי משתני של הטיפוס החדש‪ .‬בפרק זה ג הפעלנו לראשונה פעולות של מחלקה על עצ‬
‫מהמחלקה‪ .‬השימוש בעצמי שונה מהשימוש במשתני מהטיפוסי המוכרי לנו‪.‬‬
‫הצהרה על עצ ממחלקה מסוימת דומה להצהרה על משתנה מטיפוס סטנדרטי )כגו ‪ int‬או ‪.(char‬‬
‫למשל‪,‬‬
‫;‪string str‬‬
‫בניגוד להצהרה על משתני מטיפוסי סטנדרטיי‪ ,‬אחרי הצהרה על עצ צרי! ג לבצע עבורו‬
‫הקצאת שטח זיכרו‪ ,+‬על ידי הפעולה ‪ .new‬הפעולה ‪ new‬משמשת ג לאתחול עצ‪ ,‬תו! כדי הצהרה‬
‫עליו או לאחר מכ‪.‬‬
‫למשל‪ ,‬ההוראה הבאה מקצה מקו עבור ‪ s‬ומאתחלת אותו כ! שישמור את המחרוזת "‪: "ab‬‬
‫;)"‪s = new String("ab‬‬
‫מיקו התווי במחרוזת מתחיל מ(‪ .0‬בפרט‪ ,‬בכל מחרוזת‪ ,‬א נסמ את אור! המחרוזת ב(‪ ,len‬אז‬
‫התו האחרו במחרוזת נמצא במקו ‪ ,len −1‬והתו הראשו נמצא במקו ה(‪.0‬‬
‫במחלקה ‪ String‬מוגדרות פעולות שנית‪ +‬לבצע על מחרוזות‪ ,‬כלומר‪ ,‬על עצמי של המחלקה‪.‬‬
‫לכל פעולה המוגדרת במחלקה יש חוקי משלה‪ :‬איזה סוגי ערכי )פרמטרי( היא מצפה לקבל‪,‬‬
‫ומאיזה טיפוס הער! המוחזר ממנה‪ .‬חשוב לוודא התאמה בי טיפוסי הפרמטרי המועברי לפעולה‬
‫לאלה אות היא מצפה לקבל‪ ,‬ובי טיפוס הער! המוחזר ממנה לפעולות המתבצעות עליו‪ .‬למשל‪ ,‬א‬
‫אנו מבצעי השמה של הער! המוחזר מפעולה לתו! משתנה‪ ,‬יש לוודא התאמה בי הטיפוס של‬
‫המשתנה לטיפוס הער! המוחזר‪.‬‬
‫כדי לציי ביצוע פעולה של עצ מהמחלקה משתמשי בסימו‪ +‬הנקודה‪ :‬ראשית נכתב ש העצ‪,‬‬
‫אחריו נכתבת נקודה‪ ,‬לאחר מכ נכתב ש הפעולה לביצוע‪ ,‬ומייד אחר כ! מפורטי בסוגריי‬
‫הערכי המועברי לפעולה‪ .‬למשל‪ str.length() ,‬או )‪.str.charAt(5‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-408-‬‬
‫מדעי המחשב‬
‫עבור עצמי של המחלקה ‪ String‬מוגדרות פעולות רבות‪ ,‬המשמשות אותנו ביישו אלגוריתמי‬
‫הקשורי למחרוזות‪ .‬למחלקה זו פעולות רבות נוספות‪ ,‬פרט לאלו שהוצגו בפרק‪ ,‬ולא נרחיב עליה את‬
‫הדיבור כא‪ .‬תוכלו למצוא הרחבה על כל אחת מהפעולות בקישור הזה‪:‬‬
‫‪http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html‬‬
‫ביחידה זו נשתמש רק בפעולות אות למדנו בפרק זה‪.‬‬
‫כל הפעולות שמחזירות מחרוזת‪ ,‬אינ משנות את המחרוזת עבורה הופעלו‪ .‬ה יוצרות מחרוזת חדשה‬
‫ומבצעות כבר הקצאת שטח עבורה‪.‬‬
‫לביצוע קלט של מחרוזת השתמשנו בפעולה ‪ .In.readString‬ג פעולה זו מקצה שטח זיכרו עבור‬
‫המחרוזת החדשה‪.‬‬
‫בעקבות ביצוע השמה של מחרוזת אל מחרוזת‪ ,string1 = string2 ,‬מפנה ‪ string1‬אל אותו‬
‫שטח זיכרו שאליו מפנה ‪ .string2‬לכ‪ ,‬אי צור! לבצע קוד הקצאת זיכרו עבור ‪.string1‬‬
‫בנוס לפעולות הסטנדרטיות על מחרוזות‪ ,‬למדנו בפרק זה על פעולת השרשור‪ .‬פעולה זו מקבלת שתי‬
‫מחרוזות ויוצרת מחרוזת חדשה שהיא שרשור של שתי המחרוזות‪ .‬זוהי פעולה שימושית מאוד לצור!‬
‫הדפסה‪ .‬פעולת השרשור אינה פעולה של המחלקה ‪ String‬ולכ בכתיבתה אי שימוש בסימו‬
‫הנקודה‪ .‬סימ פעולת השרשור הוא הסימ ‪.+‬‬
‫ביחידת ההמש! )"יסודות מדעי המחשב ‪ ("2‬נלמד להגדיר מחלקות בעצמנו‪ ,‬ולא רק להשתמש‬
‫במחלקות קיימות‪.‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-409-‬‬
‫מדעי המחשב‬
‫רשימת פעולות על מחרוזות‬
‫הפעולה‬
‫תיאור הפעולה‬
‫טיפוס‬
‫התוצאה‬
‫פעולה המחזירה את אורכה‬
‫של המחרוזת )מספר התווי‬
‫במחרוזת(‪.‬‬
‫של‬
‫דוגמאות‬
‫הער‪ ,‬המוחזר‬
‫הפעולה‬
‫)(‪s1.length‬‬
‫)(‪length‬‬
‫כאשר ב(‪ s1‬נמצאת המחרוזת‬
‫‪3‬‬
‫"‪"dog‬‬
‫)(‪s2.length‬‬
‫כאשר ב(‪ s1‬נמצאת המחרוזת‬
‫‪0‬‬
‫""‬
‫)‪charAt(int index‬‬
‫)‪indexOf(String s‬‬
‫)‪indexOf(char c‬‬
‫פעולה המחזירה את התו‬
‫הנמצא במחרוזת במקו‬
‫)‪s1.charAt(2‬‬
‫תו‬
‫כאשר ב(‪ s1‬נמצאת המחרוזת‬
‫)אינדקס( הנתו‪.‬‬
‫"‪"shalom‬‬
‫פעולה המקבלת מחרוזת‪ ,‬או‬
‫תו ומחזירה את המקו‬
‫)"‪s1.indexOf("pl‬‬
‫הראשו שממנו מופיעה‬
‫המחרוזת הנתונה או התו‬
‫הנתו בתו! המחרוזת שעליה‬
‫מופעלת הפעולה‪ .‬א‬
‫כאשר ב(‪ s1‬נמצאת המחרוזת‬
‫'‪'a‬‬
‫‪3‬‬
‫"‪"people‬‬
‫של‬
‫)'‪s1.indexOf('o‬‬
‫כאשר ב(‪ s1‬נמצאת המחרוזת‬
‫המחרוזת או התו לא‬
‫מופיעי‪ ,‬יוחזר הער! ‪.(1‬‬
‫‪2‬‬
‫"‪"people‬‬
‫)‪s1.equals(s2‬‬
‫)‪equals(String s‬‬
‫פעולה המקבלת מחרוזת‪,‬‬
‫כאשר ב(‪ s1‬נמצאת המחרוזת‬
‫ומחזירה ‪ true‬א המחרוזת‬
‫"‪ "love‬וב(‪ s2‬נמצאת‬
‫המחרוזת "‪"Love‬‬
‫שעליה הופעלה הפעולה‬
‫בוליאני‬
‫והמחרוזת הנתונה שוות זו‬
‫)‪s1.equals(s2‬‬
‫לזו בדיוק‪ .‬אחרת‪ ,‬היא‬
‫כאשר ב(‪ s1‬נמצאת המחרוזת‬
‫"‪ "love‬וב(‪ s2‬נמצאת‬
‫מחזירה ‪.false‬‬
‫המחרוזת "‪"love‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-410-‬‬
‫מדעי המחשב‬
‫‪false‬‬
‫‪true‬‬
‫פעולה המקבלת מחרוזת‪,‬‬
‫ומשווה בינה לבי המחרוזת‬
‫שעליה הופעלה הפעולה‪ .‬א‬
‫ה שוות זו לזו מוחזר הער!‬
‫)‪compareTo(String s‬‬
‫‪ .0‬א המחרוזת עליה‬
‫)‪s1.compareTo(s2‬‬
‫מופעלת הפעולה קודמת‬
‫כאשר ב(‪ s1‬נמצאת המחרוזת‬
‫"‪ "aa‬וב(‪ s2‬נמצאת המחרוזת‬
‫למחרוזת הנתונה‪ ,‬על פי סדר‬
‫מילוני‪ ,‬יוחזר מספר של‬
‫שלילי‪ .‬א המחרוזת הנתונה‬
‫קודמת על פי סדר מילוני‬
‫של‬
‫"‪"ab‬‬
‫מספר חיובי‬
‫כלשהו‬
‫למחרוזת שעליה מופעלת‬
‫הפעולה‪ ,‬יוחזר מספר של‬
‫חיובי‪.‬‬
‫)(‪toLowerCase‬‬
‫פעולה שיוצרת ומחזירה‬
‫מחרוזת שזהה למחרוזת‬
‫עליה היא מופעלת‪ ,‬פרט לכ!‬
‫שבמקו כל אות לועזית‬
‫גדולה נמצאת האות הקטנה‬
‫המתאימה לה‪.‬‬
‫)(‪s1.toLowerCase‬‬
‫מחרוזת‬
‫כאשר ב(‪ s1‬נמצאת המחרוזת‬
‫"‪"Peace‬‬
‫המחרוזת‬
‫החדשה‬
‫"‪"peace‬‬
‫פעולה שיוצרת ומחזירה‬
‫)(‪toUpperCase‬‬
‫)‪substring(int k‬‬
‫מחרוזת שזהה למחרוזת‬
‫עליה היא מופעלת‪ ,‬פרט לכ!‬
‫שבמקו כל אות לועזית‬
‫גדולה נמצאת האות הקטנה‬
‫המתאימה לה‪.‬‬
‫פעולה שיוצרת ומחזירה‬
‫מחרוזת שזהה לתת(מחרוזת‬
‫המתחילה מהמקו ה(‪ k‬של‬
‫המחרוזת עליה היא מופעלת‪,‬‬
‫ועד סופה‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-411-‬‬
‫מחרוזת‬
‫מחרוזת‬
‫)(‪s1.toUpperCase‬‬
‫המחרוזת‬
‫כאשר ב(‪ s1‬נמצאת המחרוזת‬
‫החדשה‬
‫"‪"Peace‬‬
‫"‪"PEACE‬‬
‫)‪s1.substring(4‬‬
‫המחרוזת‬
‫כאשר ב(‪ s1‬נמצאת המחרוזת‬
‫החדשה‬
‫"‪"GoodBye‬‬
‫"‪"Bye‬‬
‫מדעי המחשב‬
‫‪substring(int k,‬‬
‫)‪int s‬‬
‫פעולה שיוצרת ומחזירה‬
‫מחרוזת שזהה לתת(מחרוזת‬
‫המתחילה מהמקו ה(‪ k‬של‬
‫המחרוזת עליה היא מופעלת‪,‬‬
‫ואורכה הוא ‪ ,s-k‬כלומר‪,‬‬
‫היא מסתיימת במקו ה(‬
‫כאשר ב(‪ s1‬נמצאת המחרוזת‬
‫המחרוזת‬
‫החדשה‬
‫"‪"GoodBye Israel‬‬
‫"‪"Bye Is‬‬
‫)‪s1.substring(4,10‬‬
‫מחרוזת‬
‫)‪(s-1‬‬
‫הוראת המדעים‪ ,‬אוניברסיטת תל‪-‬אביב‬
‫‪-412-‬‬
‫מדעי המחשב‬