תרגול 12: Iterator מחסנית תור 1

מחסנית (stack) מחסנית (stack) היא מבנה נתונים שמזכיר מחסנית של רובה : האיבר שנכנס ראשון למחסנית יוצא ממנה אחרון (LIFO - Last In First Out). ניתן לראות במחסנית קופסה סגורה בעלת פתח יחיד, שדרכו נעשות פעולות הדחיפה והשליפה. הטיפול דרך פתח יחיד יוצר מצב שבו איבר שנכנס אחרון יוצא ראשון - LIFO. מחסנית היא שימושית כאשר יש צורך לשמור נתונים בסדר מסוים ולשלוף אותם בסדר הפוך. 2

public interface Stack { /** * push - adds an element to the stack. o the elemented to be inserted to the stack. */ public void push (Object o); /** * pop - removes an element form the stack (LIFO order). the element from the top of the stack. */ public Object pop (); /** * isEmpty - checks if the stack is empty or not. true if there is no more elements in the stack. */ public boolean isEmpty(); } ממשק 3

מימוש מחסנית בעלת ע"י מערך import java.util.EmptyStackException; public class StackAsArray implements Stack { /* Defines the initial capacity of a stack */ private static final int INITIAL_CAPACITY = 5; /* Defines the capacity extension of a stack when it is full */ private static final int CAPACITY_EXTENSION = 5; protected Object[] elements; protected int size; /* Creates a new stack.*/ public StackAsArray() { elements = new Object[INITIAL_CAPACITY]; size = 0; } 4

מימוש מחסנית ע"י מערך public void push(Object o) { if (size >= elements.length) extend(); elements[size] = o; size = size + 1; } public Object pop() { if (size == 0) throw new EmptyStackException (); size = size - 1; return elements[size]; } public boolean isEmpty() { return size == 0; }

מימוש מחסנית ע"י מערך private void extend() { /* Create a new array with the new size */ Object[] tmpArray = new Object[elements.length + CAPACITY_EXTENSION]; /* Copy the old elements to the new array */ for ( int i = 0; i < elements.length; i=i+1) tmpArray[i] = elements[i]; /* Replace the elements array with the new one */ elements = tmpArray; }

Iterator 7

מידע ונתונים (data) הדרושים לתכנית מחשב נשמרים בתוך מבנה נתונים (data structure). על מבנה נתונים יש צורך לבצע מספר פעולות, כמו הכנסת נתונים והוצאת נתונים. אחת הדרכים להוציא נתונים היא לעבור על אוסף הנתונים פריט - מידע אחר פריט - מידע. האחריות על מבנה הנתונים היא של המתכנת שלו, ברצוננו להקל על המשתמש במבנה הנתונים ככל הניתן. 8

Iterator נרצה שתכונה זו תהיה משותפת למבני נתונים רבים, למשל לרשימה, שראינו זה עתה. לכן נגדיר ממשק, שאותו כל מבנה נתונים יממש. נרצה להגיד שמבנה נתונים הוא ניתן למעבר פריט - אחר - פריט, ובאנגלית : Iterable. ב -JAVA קיים הממשק : 9 public interface Iterable { /** * Returns an iterator over a set of elements. * an Iterator. */ Iterator iterator(); }

Iterator יהיה לנו אובייקט שיעזור בתהליך. אובייקט זה יעבור על אוסף הנתונים פריט אחר פריט, לפי סדר מסוים, ובאנגלית :Iterator. ב -JAVA מוגדר ממשק לעבודה עם אובייקט כזה : 10 public interface Iterator { boolean hasNext(); Object next(); void remove(); }

public interface Iterator { /** * Returns true if the iteration has more elements. true if the iterator has more elements. */ boolean hasNext(); /** * Returns the next element in the iteration. the next element in the iteration. NoSuchElementException iteration has no more elements. */ Object next(); /** * Removes from the underlying collection the last element returned by the * iterator (optional operation) UnsupportedOperationException if the "remove" * operation is not supported by this Iterator. * IllegalStateException if the "next" method has not * yet been called, or the "remove" method has already * been called after the last call to the "next" * method. */ void remove(); } 11

שימוש ב -Iterator בהמשך נראה כיצד להפוך את המחלקה StackAsArrayכך שתתמוך ב-Iterator, כרגע נניח שהמחלקה כבר תומכת בו, ועל סמך זאת נעשה שימוש ב-Iterator שמתקבל מהשיטה iterator(), שמובטחת לנו מכיוון ש- StackAsArray מממשת את Iterable. 12 public static void main(String[] args) { StackAsArray stack= new StackAsArray(); stack.push("Tasty"); stack.push(“Are"); stack.push("Shnitsels"); Iterator it = stack.iterator(); while (it.hasNext()) { Object currentData = it.next(); System.out.print(currentData); if (it.hasNext()) System.out.print(", "); } System.out.println(); }

מימוש ה -Iterator עבור StackAsArray public class StackAsArrayIterator implements Iterator { private int currentIndex; private Object[] Array; public ArrayIterator(int size, Object[] Array ) { currentIndex = size; this.Array = Array; } public boolean hasNext() { return (currentIndex != 0); } public Object next() { if (!hasNext()) { throw new NoSuchElementException(); } currentIndex = currentIndex -1; Object data = arry[currentIndex]; return data; } public void remove() { throw new UnsupportedOperationException(); } 13

עתה נראה כיצד נתמוך ב Iterator במחלקה LinkedList: 14 public interface Iterable { /** * Returns an iterator over a set of elements. * an Iterator. */ Iterator iterator(); } מימוש ה -Iterable במחלקה LinkedList

מימוש ה -Iterable במחלקה StackAsArray עכשיו כל מה שנותר לעשות הוא לממש את השיטה iterator() של הממשק Iterable ב StackAsArray : public class StackAsArray implements Iterable{ … protected Object[] elements; protected int size; /* Creates a new stack.*/ public StackAsArray() { elements = new Object[INITIAL_CAPACITY]; size = 0; } … public Iterator iterator(){ return new StackAsArrayIterator( elements,size ); }

הערות Iterator מניח שלא נעשה שינוי באוסף עליו הוא עובר במהלך המעבר. אם נעשה שינוי – האיטרטור איננו במצב חוקי ואין הבטחה לפעולה תקינה שלו. השיטה ()next מחוייבת לזרוק את החריגה NoSuchElementException במידה ואין יותר אלמנטים באוסף. ( אם לפני כל קריאה ל -next() נוודא ש hasNext() החזיר true אז לא נתקל בחריגה זו ). החריגה : UnsupportedOperationException נזרקת כאשר אנו מחוייבים להכריז שיטה מסויימת ( למשל כי היא חלק מממשק ) במחלקה שלנו, אך אנו לא תומכים בשיטה זו. לכן בגוף השיטה נזרוק את החריגה. 16

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

המשך import java.util.Scanner; … public static void main(String args[]) { Scanner sc = new Scanner(System.in); Queue s = new stackAsArray(); System.out.println("Insert few lines … "); while (sc.hasNextLine()) { String line = sc.nextLine(); s.push( line ); } System.out.println("Printing all the lines back! "); while (!s.isEmpty()) { System.out.println(s.pop()); } 18

השיטה copy מקבלת כארגומנט מחסנית s ומחזירה העתק של המחסנית s כאשר יש לשמור על סדר האיברים במחסנית המועתקת וב-s זהה. לא תמיד נצטרך לדעת כיצד מימשו את הממשק– העתק מחסנית public static Stack copy(Stack s) { } 19

השיטה copy מקבלת כארגומנט מחסנית s ומחזירה העתק של המחסנית s כאשר יש לשמור על סדר האיברים במחסנית המועתקת וב-s זהה. לא תמיד נצטרך לדעת כיצד מימשו את הממשק– העתק מחסנית public static Stack copy(Stack s) { Stack temp = new StackImpl(); Stack ans = new StackImpl(); while (!s.isEmpty()) { temp.push(s.pop()); } while (!temp.isEmpty()) { Object o = temp.pop(); ans.push(o); s.push(o); } return ans; } 20

תור - Queue תור (Queue) הוא מבנה נתונים המזכיר תור של בני אדם : האיבר שנכנס ראשון לתור - יוצא ממנו ראשון. ניתן לראות כקופסה סגורה בעלת 2 פתחים : פתח הכנסה ופתח יציאה. איבר שנכנס ראשון יוצא ראשון FIFO (FIFO - First In First Out). שימושים : ניהל תהליכים ע " י מערכת ההפעלה, ניהול תור בבית מרקחת,... 21

public interface Queue{ /** * isEmpty - checks if the queue is empty or not. true if the queue is empty */ public boolean isEmpty(); /** * dequeue - removes an object from the head of the queue. * (FIFO order) the next object in the queue. */ public Object dequeue(); /** * enqueue - inserts an object into the queue. o the object to be enqueued. */ public void enqueue(Object o); } 22

שיטה זו מקבלת תור כפרמטר והופכת את סדר האיברים בו. מוגדר לכם משתנה אחד מטיפוס.Object אין להגדיר משתנים נוספים בשיטה זו. דוגמה public static void reverse(Queue q) { Object o; } 23

שיטה זו מקבלת תור כפרמטר והופכת את סדר האיברים בו. מוגדר לכם משתנה אחד מטיפוס.Object אין להגדיר משתנים נוספים בשיטה זו. דוגמה public static void reverse(Queue q) { Object o; if(!q.isEmpty()){ o=q.deueue(); reverse(q); q.enqueue(o); } 24

תרגיל הוסיפו למחלקה StackAsArray המממשת את הממשק Iterable את השיטה filter לסינון איברים העונים על תנאי מתוך כלל איברי במחסנית. Stack filter(Filter f) התנאי ע " פ מסננים האיברים הוא Filter f. נגדיר ממשק Filter המכיל שיטה אחת והיא accept, המקבלת אובייקט ומחליטה האם הוא עובר את הסינון או לא. 25

public interface Filter { /** * accept – defines the filtration criterion. o the object to be examined. true if the object should not be * filtered out. */ public boolean accept(Object o); } אנו נממש Filter פשוט עבור המחלקה String, המשאיר רק את המחרוזות הלא ריקות: public class EmptyStringFilter implements Filter { public boolean accept(Object o) { boolean ans = false; if (o instanceof String) { String s = (String) o; ans = s.length() > 0; } return ans; } } 26

public stackAsArray filter(Filter filter) { stackAsArray filteredStack = new stackAsArray() ; Iterator it = this.iterator(); while (it.hasNext()) { Object data = it.next(); if(filter.accept(data)) { filteredStack.push(data) ; } return filteredStack; } כל שנותר הוא לממש את השיטת הסינון ב - StackAsArray : השיטה מקבלת כקלט מסנן, ומחזיר מחסנית חדשה שתכיל את כל אברי המחסנית הנוכחית שעברו את המסנן. 27