1. הרצאה 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.
בעיקרון זו הרצאה עם זמן פנוי להוספת דגשים והשלמת פערים

2. מחרוזת - 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

3. שיטות שימושיות של מחרוזות
אורך המחרוזת 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

4. אופרטור + במחרוזות 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

5. דוגמא לשימוש ב 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

6. הטיפוס הפרימיטיבי 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

7. פונקציות – מושג החתימה חתימה של פונקציה:
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… }

8. פונקציות – מושג החתימה
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)

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

10. הפיכת 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()

11. הפיכת 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.

12. המשך: public static int intValue(char c) {
// assuming c is a digit (indexOf returns also -1)
final String conversion = " ABCDEF";
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

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

14. החלפת כל המופעים של תו מסוים:
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) + c 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