Containers ב Java אליהו חלסצ'י תכנות מתקדם 89-210 תרגול מספר 3 תשע"א 2010-2011 Containers ב Java אליהו חלסצ'י

הקדמה ב java אין templates במקום, ישנה קבוצה של collections, שיכולה לספק את רוב הצרכים שלנו ב containers קבוצה זו לא נבנתה לשם יעילות כמו ה STL של C++ בעבר קבוצה זו עבדה עם הטיפוס Object וכך היה ניתן להכניס פנימה כל מופע מכל מחלקה אך העבודה עם Object מצריכה casting וזה האט את הביצועים, כיום ניתן להגדיר את הטיפוס המוכנס ל container לא ניתן להכניס primitive types ל containers, משום שדרוש אובייקט, לכן יש את המחלקות העוטפות כדוגמת Integer כמובן שהדבר צורך יותר זיכרון...

Comparator נניח שנרצה למיין רשימה, פעם בסדר עולה ופעם בסדר יורד, האם נצטרך לשם כך שני מימושים? התשובה היא לא, אם משתמשים ב Strategy Pattern ע"פ תבנית זו, אלגוריתם המיון ישתמש בהחלטה מבחוץ כיצד למיין את הרשימה כדי להשפיע על שיטת המיון ב Containers השונים ב java, משתמשים בתבנית זו באמצעות comparator

Comparator כל מחלקה יכולה לממש את הממשקים הבאים: ע"פ המימוש באחד מממשקים אלו, ה containers מחליטים כיצד למיין בפנים את העצמים השמורים interface Comparator { int compare(Object o1, Object o2); } interface Comparable { int compareTo(Object o) ; }

Comparator דוגמא: פלט: aaabc aabc abc Robot r1=new RV1(); Robot r2=new RV1(); Robot r3=new RV1(); r1.setName("aaabc"); r2.setName("aabc"); r3.setName("abc"); ArrayList<Robot> ar=new ArrayList<Robot>(); ar.add(r3); ar.add(r2); ar.add(r1); Collections.sort(ar); for(int i=0;i<ar.size();i++){ System.out.println(ar.get(i).getName()); } פלט: aaabc aabc abc public class RV1 implements Robot ,Comparable<Robot>{ … private String name; public String getName() { return name; } public int compareTo(Robot arg0) { return name.compareTo(arg0.getName()); } מיון: אופטימיזציה של merge sort מהירה ויציבה: מיון מהיר: nlog(n) תמיד מובטח (בניגוד ל quick sort) עובד מהר יותר על רשימות כמעט ממוינות. מיון יציב : - לא ממיינת עצמים שווים. (דוג' דואר שממוין לפי תאריך)

Containers שימושיים ב java יש שני סוגים של Containers: Collections קבוצה של ערכים בודדים List – רשימה: שומר על הערכים ברצף מסוים Set – קבוצה: אותו הערך לא יכול להופיע יותר מפעם אחת Map קבוצה של הזוגות מפתח + ערך לכל אלו מימושים שונים על בסיס הצורות שלמדתם בקורס מבנה נתונים לכל אחד יתרונות וחסרונות אחרים, ולכן יש להתאים את ה container לדרישות התוכנה

Containers שימושיים להלן כמה דוגמאות: List Set Map ArrayList ממומש על בסיס מערך: גישה אקראית מהירה, אך הוספה ומחיקה מהאמצע איטית LinkedList ממומש על בסיס רשימה מקושרת דו כיוונית: גישה אקראית איטית, אך הוספה ומחיקה מהאמצע מהירה Set HashSet לשימוש כשזמן חיפוש האלמנט חשוב, יש לממש המתודה HashCode() לאובייקט שברצוננו להכניס TreeSet ניתן בקלות להוציא רשימה ממוינת Map HashMap ממומש באמצעות hash tables, אובייקט המפתח חייב לממש את HashCode() LinkedHashMap – אותו הדבר, אך שומר גם את סדר ההכנסה TreeMap – ממומש ע"י עץ אדום שחור, ניתן לקבל תוצאות ממוינות

Containers שימושיים מתודות שימושיות ל Collections: boolean add(Objetc o) boolean add(Collection c) void clear() boolean contains(Object o) boolean isEmpty() Iterator iterator() boolean remove(Object o) boolean removeAll(Collection c) int size() Object[] toArray()

Containers שימושיים מתודות שימושיות ל Map: Object put(Object key, Object value) void putAll(Map t) Object get(Object key) void clear() boolean containsKey(Object key) boolean containsValue(Object value) boolean isEmpty() Object remove(Object key) int size() Set entrySet() Set keySet() Collection values()

Iterator מטרת ה Iterator היא לספק גישה לעצמים ב Container מבלי לחשוף את אופן פעולתו בממשק (של List לדוג') לא ניתן לספק את כל האופנים השונים בהם נרצה לטייל ב container ייתכנו כמה iterators עבור אותו ה container כל אחד יטייל בדרך שונה על העצמים

Iterator דוגמאות: ArrayList<Robot> ar=new ArrayList<Robot> (); ar.add(r3); ar.add(r2); ar.add(r1); for(int i=0;i<ar.size();i++){ System.out.println(ar.get(i).getName()); } for(Robot r : ar){ System.out.println(r.getName()); Iterator<Robot> it=ar.iterator(); while (it.hasNext()){ System.out.println(it.next().getName()); על arrayList אפשר לרוץ כמו מערך וגם באמצעות iterator

Iterator דוגמאות: HashSet HashMap HashSet hs<Robot>=new HashSet<Robot> (); hs.add(r3); hs.add(r2); hs.add(r1); Iterator<Robot> it=hs.iterator(); while (it.hasNext()){ System.out.println(it.next().getName()); } דוגמאות: HashSet HashMap String key; HashMap<String,Robot> hm=new HashMap<String,Robot> (); hm.put(r3.getName(), r3); hm.put(r2.getName(), r2); hm.put(r1.getName(), r1); Iterator<String> it=hm.keySet().iterator(); while (it.hasNext()){ key=it.next(); System.out.println(hm.get(key).getName()); } על arrayList אפשר לרוץ כמו מערך וגם באמצעות iterator

Iterator דרכים נוספות לעבור על HashMap for(Entry<String,Robot> e : hm.entrySet()) System.out.println(e.getKey()+","+e.getValue()); for(String k : hm.keySet()) System.out.println(k+","+hm.get(k)); for(Robot r : hm.values()) System.out.println(r); על arrayList אפשר לרוץ כמו מערך וגם באמצעות iterator

Factory Pattern בעיה: נניח שיש לנו n סוגים של אובייקטים ולכל אחד שם, אופן פעולת התוכנית צריך להיות כך שהמשתמש בכל פעם בוחר שם והאובייקט הרצוי נוצר לכאורה, במקרה הגרוע צריך n השוואות כדי לדעת באיזה שם המשתמש בחר, וע"פ השם הזה ליצור את האובייקט הרצוי.  O(n) דרך טובה יותר לפתור את הבעיה, היא להשתמש ב Factory Pattern, יש הרבה דרכים למימוש, נראה דוגמא לדרך אחת

Factory Pattern ניצור ממשק עם הפקודה create. private HashMap<String,RobotFac> robotFactory; public RobotFactory(){ robotFactory=new HashMap<String,RobotFac> (); robotFactory.put("RV1", new RV1Fac()); robotFactory.put("RV2", new RV2Fac()); robotFactory.put("Aibo", new AiboFac()); } public Robot createRobot(String type){ return robotFactory.get(type).create(); import java.util.HashMap; public class RobotFactory { private interface RobotFac{ public Robot create(); } private class RV1Fac implements RobotFac{ public Robot create(){ return new RV1();} private class RV2Fac implements RobotFac{ public Robot create(){ return new RV2();} private class AiboFac implements RobotFac{ public Robot create(){ return new Aibo();} ניצור ממשק עם הפקודה create.

Factory Pattern ניצור ממשק עם הפקודה create. private HashMap<String,RobotFac> robotFactory; public RobotFactory(){ robotFactory=new HashMap<String,RobotFac> (); robotFactory.put("RV1", new RV1Fac()); robotFactory.put("RV2", new RV2Fac()); robotFactory.put("Aibo", new AiboFac()); } public Robot createRobot(String type){ return robotFactory.get(type).create(); import java.util.HashMap; public class RobotFactory { private interface RobotFac{ public Robot create(); } private class RV1Fac implements RobotFac{ public Robot create(){ return new RV1();} private class RV2Fac implements RobotFac{ public Robot create(){ return new RV2();} private class AiboFac implements RobotFac{ public Robot create(){ return new Aibo();} ניצור ממשק עם הפקודה create. נממש את הממשק ע"י מחלקות עבור כל אחד מסוגי האובייקטים הרצויים.

Factory Pattern ניצור ממשק עם הפקודה create. private HashMap<String,RobotFac> robotFactory; public RobotFactory(){ robotFactory=new HashMap<String,RobotFac> (); robotFactory.put("RV1", new RV1Fac()); robotFactory.put("RV2", new RV2Fac()); robotFactory.put("Aibo", new AiboFac()); } public Robot createRobot(String type){ return robotFactory.get(type).create(); import java.util.HashMap; public class RobotFactory { private interface RobotFac{ public Robot create(); } private class RV1Fac implements RobotFac{ public Robot create(){ return new RV1();} private class RV2Fac implements RobotFac{ public Robot create(){ return new RV2();} private class AiboFac implements RobotFac{ public Robot create(){ return new Aibo();} ניצור ממשק עם הפקודה create. נממש את הממשק ע"י מחלקות עבור כל אחד מסוגי האובייקטים הרצויים. ניצור HashMap עבור המחלקות הנ"ל, כשהמפתח הוא השם דרכו המשתמש בוחר ליצור את האובייקט הרצוי.

Factory Pattern ניצור ממשק עם הפקודה create. private HashMap<String,RobotFac> robotFactory; public RobotFactory(){ robotFactory=new HashMap<String,RobotFac> (); robotFactory.put("RV1", new RV1Fac()); robotFactory.put("RV2", new RV2Fac()); robotFactory.put("Aibo", new AiboFac()); } public Robot createRobot(String type){ return robotFactory.get(type).create(); import java.util.HashMap; public class RobotFactory { private interface RobotFac{ public Robot create(); } private class RV1Fac implements RobotFac{ public Robot create(){ return new RV1();} private class RV2Fac implements RobotFac{ public Robot create(){ return new RV2();} private class AiboFac implements RobotFac{ public Robot create(){ return new Aibo();} ניצור ממשק עם הפקודה create. נממש את הממשק ע"י מחלקות עבור כל אחד מסוגי האובייקטים הרצויים. ניצור HashMap עבור המחלקות הנ"ל, כשהמפתח הוא השם דרכו המשתמש בוחר ליצור את האובייקט הרצוי. נכניס את הזוגות String, RobotFac>> ל Hashmap

Factory Pattern ניצור ממשק עם הפקודה create. private HashMap<String,RobotFac> robotFactory; public RobotFactory(){ robotFactory=new HashMap<String,RobotFac> (); robotFactory.put("RV1", new RV1Fac()); robotFactory.put("RV2", new RV2Fac()); robotFactory.put("Aibo", new AiboFac()); } public Robot createRobot(String type){ return robotFactory.get(type).create(); import java.util.HashMap; public class RobotFactory { private interface RobotFac{ public Robot create(); } private class RV1Fac implements RobotFac{ public Robot create(){ return new RV1();} private class RV2Fac implements RobotFac{ public Robot create(){ return new RV2();} private class AiboFac implements RobotFac{ public Robot create(){ return new Aibo();} ניצור ממשק עם הפקודה create. נממש את הממשק ע"י מחלקות עבור כל אחד מסוגי האובייקטים הרצויים. ניצור HashMap עבור המחלקות הנ"ל, כשהמפתח הוא השם דרכו המשתמש בוחר ליצור את האובייקט הרצוי. נכניס את הזוגות String, RobotFac>> ל Hashmap פקודת יצירת האובייקט: בהינתן מחרוזת שהמשתמש בחר, ניגש בזמן של O(1) ל HashMap אל האובייקט השמור תחת אותה המחרוזת כמפתח נקרא ל create ונקבל את האובייקט הרצוי. החלפנו O(n) זמן ב O(n) מקום, וקיבלנו זמן של O(1) ליצירת אובייקטים + נוחות לתחזק ולהוסיף בעתיד או אובייקטים ל Factory.

Trove העובדה ש containers מקבלים אובייקט מצריכה אותנו לבזבז זיכרון בעקבות השימוש במחלקות העוטפות, במקרה שאנו רוצים להשתמש רק ב primitive types הקבוצה GNU Trove יצרה Collections חדשים שמקבלים primitive types ובכך חוסכות זיכרון, וכן משפרת משמעותית את הביצועים באתר הקורס פרטים על הורדה + הדרך להוסיף jars לפרויקט באמצעות ה eclipse

Trove קוד לדוגמא: פלט: last value for key1 was 0.2 key: 2 , value: 0.2 import gnu.trove.*; public class HelloWorldApp { static TByteFloatHashMap hm=new TByteFloatHashMap(); public static void main(String[] args) { float lastValueForThisKey; byte key1=1,key2=2,key3=3; hm.put(key1, (float) 0.2); lastValueForThisKey=hm.put(key1, (float) 0.1); System.out.println("last value for key1 was "+lastValueForThisKey); hm.put(key2, (float) 0.2); hm.put(key3, (float) 0.3); TByteFloatIterator it= hm.iterator(); while (it.hasNext()){ it.advance(); System.out.println("key: "+it.key()+" , value: "+ it.value()); } פלט: last value for key1 was 0.2 key: 2 , value: 0.2 key: 1 , value: 0.1 key: 3 , value: 0.3

הטמעה מנה 2 חסרונות של ה containers ב java לעומת C++ STL באיזה אלגוריתם מיון משתמש Collections.sort() ומדוע? בדקו האם המתודה boolean contains(Object o) מחזירה "אמת" לפי תוכן האובייקט או לפי מיקומו בזיכרון כנסו לאתר Sun ותכירו עוד containers כגון PriorityQueue, Hashtable צרו collection כלשהו עבור int באמצעות trove ותעברו עליו באמצעות iterator