הרצאה 7: מחרוזות וחתימה של פונקציה מבוא למדעי המחשב הרצאה 7: מחרוזות וחתימה של פונקציה אולי מקום לדיון קצר על יעילות: does the solution scale for large inputs? usually we dont mind to waste a few actions or memory bits if we can perform an algorithm in 2^n vrs n or even n^2 vrs n then we should. constants are less important. but still: why stay in a loop if we could exit earlier. why perform redundant checks if we can avoid them. בעיקרון זו הרצאה עם זמן פנוי להוספת דגשים והשלמת פערים

מחרוזת - String הטיפוס מחרוזת (String) איננו טיפוס פרימיטיבי (נשים לב שהמחלקה כתובה באות גדולה). שימוש בסיסי: String str1 = new String(“abc”); String str2 = new String (“abc”); String str3 = “def”; טבלת משתנים זכרון ערך שם טיפוס 4 x int arr int [] str1 String str2 איך מיוצג מערך בזיכרון: .(new) שוויון: אותו מקום מזיכרון \ שוויון לוגי. S s1= new S (“abc”) S s2 = new S (“abc”) S s3 = s2; s1 != s2 s2==s3 הדוגמא הזאת לא עובדת בלי new לשים לב ש-str3 תצביע ל-String pool, לעומת str1 ו-str2 שיצביעו למקומות אחרים להסביר \b \t \n \\ \” \’ 3 8 2- abc abc 2

שיטות שימושיות של מחרוזות אורך המחרוזת str1.length() התו ה i במחרוזת str2.charAt(i) האינדקס הראשון במחרוזת בו מופיע התו 'A' str1.indexOf(‘A’) השוואת התוכן של שתי מחרוזות str1.equals(str2) כיצד בעצם אנו יודעים אילו שיטות יש למחלקה מסוימת (נניח String)? נא להכיר Java API כבר נתקלנו בעבר - בפרמטרים של main הופיע String כיצד בעצם אנו יודעים אילו שיטות יש למחלקה מסוימת (נניח String)? נא להכיר java api! במקום לרשום בגוגל java api ניתן לרשום ישירות java String ולהגיע לדף המתאים ב-API להסביר ששיטה של מחרוזת היא פונקציה של מחרוזת ספציפית – נדון בכך בהמשך הקורס we cannot change a string (ie at char i) talk about (a) Place.action(...) example Math.random() (b) action(...) example gcd(m,n) (c) animal.action(...) example: s.charAt(i) s.equals(r) 3

אופרטור + במחרוזות System.out.println(6+3+” is the answer”); System.out.println(“The answer is “+6+3);  The answer is 63 System.out.println(“The answer is “+(6+3));  The answer is 9

דוגמא לשימוש ב char וב String מספר הופעות התו ‘a’ במחרוזת str: public static int aCouner (String str) { int counter = 0; for (int i = 0; i<str.length(); i=i+1) if (str.charAt(i) == ‘a’) counter = counter+1; return counter; } counter , char c) { c להציג את aCounter (שמוסתר ע"י האנימציה) לשאול: מה אם רוצים לספור את ההופעות של תו אחר כל פעם? אז מציגים את הפונקציה counter לשים לב שניתן לקרוא למשתנה ולפונקציה באותו השם 5

הטיפוס הפרימיטיבי char char char1 = ‘b’; char char2 = ‘a’; S.o.p(char1);  b S.o.p((int) char2);  97 S.o.p((int) char1);  98 S.o.p((char)97);  a S.o.p((char)(int)char1);  b int i = ‘1’; // i=49 S.o.p(i+1);  50 char c = ‘9’; // c=57 S.o.p(c-’0’);  9 A<B<..<Z<a<b<..<z להדגיש שלא צריך לזכור את התרגום ל-int של תו כלשהו (גם אני בתור מתכנת ותיק לא זוכר...) מה שצריך לזכור זה את העובדה שהספרות והאותיות הן רצפים 6

פונקציות – מושג החתימה חתימה של פונקציה: public static <return value> <function name> (<arguments list>) חתימה של פונקציה: שם הפונקציה טיפוסי הפרמטרים (וסדרם!!) תתכן המרת טיפוסים, במידה ולא קיימת פונקציה בעלת החתימה המבוקשת לא יתכן מצב בו למספר פונקציות תהיה אותה חתימה כללי המרה!! Example: Math.sqrt(int) מבנה של פונקציה: public static <return value> <function name> (<arguments list>) חתימה של פונקציה מורכבת משמה ומרשימת הארגומנטים שהפונקציה מקבלת (מספר ,סוגי טיפוסי הפונקציה וסדרם). חתימה הפונקציה מסומנת בקו תחתי. לכל שתי פונקציות בתכנית חתימה שונה. p.s. int sig (int I, double j) {return 1;} p.s. int sig (double I, int j) {return 2;} p.s. void main (String[] args) { int x=1; double y=2.0; S.o.p(sig(x,y)); // 1 S.o.p(sig(y,x)); // 2 S.o.p(sig(x,x)); // Compilation error: ambiguous היה עובד אם היתה קיימת רק פונקציה אחת מהשתיים S.o.p(sig(y,y)); // Compilation error: can’t find… }

פונקציות – מושג החתימה public static int sig (int I, double j) {return 1;} public static int sig (double I, int j) {return 2;} public static void main (String[] args) { int x=1; double y=2.0; System.out.println (sig(x,y)); // 1 System.out.println (sig(y,x)); // 2 System.out.println (sig(x,x)); // Compilation error: ambiguous היה עובד אם היתה קיימת רק פונקציה אחת מהשתיים System.out.println (sig(y,y)); // Compilation error: can’t find… } זה נקרא "העמסה" (Overloading)

פונקציות – מושג החתימה String s = new String(“abcdc”); S.o.p(s.indexOf(‘c’) );  2 S.o.p(s.indexOf(‘c’,3) );  4 זה נקרא "העמסה" (Overloading)

הפיכת String מספרי ל-int: class Literal { public static void main(String[] args) { String s = args[0]; int myVal = intValue(s); … } Note that now s is a parameter given to main!! לדבר על המבנה של ה MAIN The students will see how to practically do it in the PS This function does something similar to Scanner.nextInt()

הפיכת String מספרי ל-int: public static int intValue(String s){ int base; // 8,10 or 16 int first; // Where does the number part start int value = 0, power = 1; if (s.length()==1 | s.charAt(0) != '0') { first=0; base=10;} else if (s.charAt(1)!='x') // Starting with 0 represents octal numbers { first=1; base=8;} else // Starting with 0x represents hexadecimal numbers { first=2; base=16;} for (int i = s.length()-1; i >= first; i = i-1){ value = value + intValue(s.charAt(i)) * power; power = power * base; } return value; Integer literals are strings which represent numeric data. In Java, integer literals of type byte, short, int or long may be written in three different bases: decimal, octal or hexadecimal. To distinguish in which base an integer literal is to be interpreted we examine the first characters in the string. Let us focus on positive integer values. If the first two characters in an integer literal are '0' and 'x' then the literal is specified in base 16; otherwise if the first character is a '0' then it is in base 8, otherwise if the first character is a non-zero digit the literal is decimal.

המשך: public static int intValue(char c) { // assuming c is a digit (indexOf returns also -1) final String conversion = "0123456789ABCDEF"; return conversion.indexOf(c); { an alternative is to return c-'0' or c-'A‘+10 depending on if c is between 0,9 or A,F שימו לב להעמסה של הפונקציה intValue

מחיקת איבר מ-String: public static String removeIndex(String str, int index) { return str.substring(0, index) + str.substring(index+1, str.length()); } // removeIndex להסביר על substring שזה מהאינדקס הראשון כולל ועד לאינדקס השני לא כולל 13

החלפת כל המופעים של תו מסוים: public static String replaceChar(String str, char c1, char c2) { String newStr = str; int i = str.indexOf(c1); while (i != -1) { // -1 means that indexOf did not find c1 newStr = newStr.substring(0,i) + c2 + str.substring(i+1,str.length()); i = str.indexOf(c1, i+1); } // while return newStr; } // replaceChar ניתן היה לרוץ על כל איברי המערך, אבל למה לא להשתמש ב-indexOf? ה-API של String מכיל פנינים רבות, כגון... replace ניתן היה פשוט לקרוא ל str.replace(c1,c2) replace public String replace(char oldChar, char newChar) לשים לב שזה מחזיר string חדש 14