תוֹכֶן

• טבלת השוואה
• הגדרת ArrayList
• הגדרת וקטור
• קווי דמיון:
• סיכום:

ArrayList ו- Vector שניהם הם הכיתות הנמצאות תחת היררכיית מסגרת האוספים. ArrayList ו- Vector, שניהם משמשים ליצירת מערך דינמי של אובייקטים שבהם המערך יכול לגדול בגודל לפי הצורך. ישנם שני הבדלים בסיסיים המבדילים בין ArrayList ו- Vector הוא שהווקטור שייך לשיעורי Legacy שנקבעו בהמשך לתמיכה בשיעורי האיסוף ואילו ArrayList הוא כיתת אוסף סטנדרטית. הבדל חשוב נוסף הוא ש- ArrayList אינו מסונכרן מצד שני; הווקטור מסונכרן.

הבה נבחן כמה הבדלים אחרים בעזרת תרשים השוואה המוצג להלן.

1. טבלת השוואה
2. הגדרה
3. הבדלים עיקריים
4. קווי דמיון
5. סיכום

טבלת השוואה

בסיס להשוואה	רשימת מערך	וקטור
בסיסי	כיתת ArrayList אינה מסונכרנת.	מחלקת וקטור מסונכרנת.
שיעור מורשת	ArrayList הוא כיתת אוסף רגילה.	וקטור הוא כיתת מורשת, מהונדס מחדש לתמיכה בכיתת האיסוף.
הצהרת כיתה	ArrayList בכיתה	וקטור בכיתה
הקצאה מחדש	כאשר לא צוין ArrayList מצטמצם בחצי מגודלו.	כאשר לא צוין, מגדיל וקטור להכפיל את גודלו.
ביצועים	מכיוון ש- ArrayList אינו מסונכרן, הוא פועל מהר יותר מ- Vector.	כאשר וקטור מסונכרן, הוא פועל לאט יותר מ- ArrayList.
ספירה / איטרטור	ArrayList משתמש בממשק Iterator כדי לחצות את האובייקטים המאוחסנים ב- ArrayList.	וקטור משתמש בספירה כמו גם בממשק Iterator כדי לחצות את האובייקטים המאוחסנים בווקטורים.

הגדרת ArrayList

ArrayList שייך לרשימת שיעורי האיסוף הסטנדרטיים. ArrayList הכיתה מוגדר בתוך java.util חבילה, זה מרחיב את AbstractList כיתה שהיא גם כיתת אוסף סטנדרטית, והיא גם מיישמת רשימה, ממשק המוגדר בממשקי אוסף. ב- Java מערך סטנדרטי תמיד באורך קבוע. זה אומר שברגע שנוצרו; הוא לא צומח או מתכווץ באופן דינמי. לכן עליכם לקבל ידע מוקדם באורך המערך בו אתם משתמשים. אך לעיתים יתכן כי האורך הנדרש מתגלה בזמן הריצה, כדי להתמודד עם סוג זה של סיטואציות שהג'אווה הציגה את ArrayList.

ArrayList הוא מחלקה המשמשת ליצירה דינאמית של מערך המכיל את ההתייחסות לאובייקטים. מערך זה יכול לצמוח בגודלו לפי הצורך. הצהרת הכיתה היא כדלקמן:

ArrayList בכיתה

כאן, E מציין את סוג האובייקטים שמערך יחזיק. המערך שנוצר הוא באורך משתנה, והוא גדל ויורד בגודל כאשר מוסיפים או מוסרים אובייקטים מהרשימה.

פירושו של ArrayList אינו מסונכרן, כלומר יותר מחוט אחד יכול לפעול במערך בו זמנית. לדוגמה, אם פתיל אחד מוסיף הפניה לאובייקט למערך וחוט אחר מסיר הפניה לאובייקט מאותו מערך בו זמנית. יצירת מערך דינמי באמצעות מחלקת ArrayList:

רשימת מערך S1 = ArrayList חדש(); System.out.ln ("הגודל ההתחלתי של S1:" + S1.size ()); S1.add ("T"); S1.add ("C"); S1.add ("H"); S1.add (1, "E"); System.out.ln ("לאחר התוספת S1 מכיל:" + S1); System.out.ln ("גודל S1 לאחר הוספה:" + S1.size ()); S1. Remove ("T"); S1. Remove (2); System.out.ln ("לאחר המחיקה S1 מכיל:" + S1); System.out.ln ("גודל S1 לאחר מחיקה:" + S1.size ()); // פלט גודל ראשוני של S1: 0 לאחר התוספת S1 מכיל:; גודל S1 לאחר ההוספה: 4 לאחר המחיקה S1 מכיל: גודל S1 לאחר המחיקה: 2

בקוד לעיל תוכלו לראות זאת; יצרתי מערך של אובייקטים מסוג מחרוזת. הוספתי כמה אובייקטים למערך S1 בשיטת add (), ומאוחר יותר מחקתי כמה אובייקטים בשיטת הסר (). אתה יכול לראות אם לא תציין את הגודל הראשוני של המערך זה יהיה באורך '0'. כפי שאתה יכול לראות המערך גדל ומתכווץ בגודלו תוך כדי הוספת ומחיקת האלמנטים.

הגדרת וקטור

וקטור הוא כיתת מדור קודם שנמצאת מחדש בתמיכה בכיתת האיסוף בהיררכיית מסגרת האוספים. מחלקת הווקטורים מוגדרת גם ב- java.util חבילה, מורחבת על ידי AbstractList בכיתה ויושם על ידי רשימה ממשק. מחלקת וקטור מוצהרת כדלקמן:

וקטור בכיתה

כאן ה- E מגדיר את סוג האובייקט שיישמר במערך. מערך שנוצר באמצעות מחלקת וקטור הוא באורך משתנה. זה מגדיל כפול מגודלו אם התוספת לא צוינה. בואו נבין יצירת מערך באמצעות וקטור.

וקטור V = וקטור חדש(1,1); V.addElement ("טק"); V.addElement ("הבדלים"); System.out.ln ("קיבולת לאחר 2 תוספות:" + V. כושר ()); V.addElement ("בין"); V.addElement ("וקטורים"); System.out.ln ("קיבולת נוכחית:" + יכולת V. ()); // כושר תפוקה לאחר 2 תוספות: 2 קיבולת נוכחית: 4

בקוד לעיל תוכלו לראות את זה, ציינתי במיוחד את גודל וערך התוספת בבניית וקטור בהתאמה, תוך הכרזת מערך חפצי המיתר. מכאן שתוכלו לראות שככל שמגבלת המערך מסתיימת, זה מצטבר בערך המסופק לבנאי בזמן ההכרזה.

1. האשכולות המרובים יכולים לפעול ב- ArrayList באותו זמן ומכאן שהוא נחשב לא מסונכרן. שלא כמו ArrayList, רק חוט בודד יכול לפעול על וקטור בכל פעם; מכאן שזה נקרא מסונכרן.
2. בגירסה מוקדמת של ג'אווה, חלק מהשיעורים והממשקים יספקו את השיטות לאחסון אובייקטים שכונו כיתות Legacy וקטור הוא אחד מהכיתות Legacy של ג'אווה. מאוחר יותר הוכנסו שוב שיעורי מורשת אלה לתמיכה בכיתת האוספים, בעוד שכיתת ArrayList היא כיתת אוסף רגילה.
3. כאשר משתמשים במלוא הגבול של מערך ומוסיפים אובייקט חדש לצד המערך המותש, גודלו גדל בשני המקרים, כלומר ב- ArrayList וגם בווקטור, אך ההבדל הוא שב- ArrayList, אם לא צוין הגודל מוגדל על ידי 50% מהמערך הנוכחי ואילו, במערך וקטור מוכפל כגודל אם ערך התוספת אינו מוגדר.
4. וקטור משתמש בספירה כמו גם באיטרטור כדי לחצות מערך ואילו ArrayList משתמש רק באיטרטור לצורך חציית מערך.
5. מכיוון ש- ArrayList אינו מסונכרן וחוטים רבים יכולים לפעול עליו בו זמנית הביצועים שלו טובים יותר מ- Vector עליהם רק חוט אחד יכול לפעול בכל פעם.

קווי דמיון:

1. שניהם ArrayList ו- Vector מוגדרים בחבילת java.util.
2. ArrayList ו- Vector שניהם מרחיבים את מחלקת AbsractList.
3. ArrayList ו- Vector שניהם מיישמים ממשק רשימה.
4. שניהם ArrayList ו- Vectors משמשים ליצירת מערך דינמי שצומח כנדרש.
5. שניהם ArrayList ו- Vector כוללים הפניות לאובייקטים.

סיכום:

אני מסכם באמירה שהשימוש ב- ArrayList עדיף על השימוש ב- Vector שכן הוא מתפקד מהר יותר ויותר.