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

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

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

עד כמה שאני רואה ווקטור יכול לקבל כל אוביקט, האם יש לו תחליף "זול" יותר שיכול לקבל רק סוג ערך אחד? float במקרה הספציפי שלי

המידע שלי על ווקטורים לקוח מ
http://java.sun.com/j2se/1.3/docs/a...til/Vector.html

תודה לעוזרים

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

ב C++ לפחות ווקטור זה מערך דינאמי אבל יותר יעיל, הוא גדל לא ב 1 כל הזמן אלה במספרים שונים לדוגמא בהתחלה נראה לי זה מקצה 10 תאים אחרי שאתה מגיע לתא 11 הוא מקצה 50 תאים ואז 100 נראה לי וכו'. אני לא רואה סיבה לא להשתמש בווקטור כאשר אתה צריך מערך עם כמות לא יודע של איברים וההכנסה נעשת מהסוף.

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

ציטוט:

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

לא מדויק. הווקטור מראש מקצה יותר זיכרון מאשר שצריך (בC++ זה כפול שתיים עם אני זוכר נכון), ורק כשמגיעים לגבול הוא מקצה עוד פעם משהו יותר גדול.
אפשרות אחרת היא linked list, אבל מה שחשוב פה הוא השימוש שאתה רוצה לעשות עם המערך.

לפנות לאובייקט מסוים במערך, יותר מהיר בווקטור, מכיוון שזו פנייה ישירה במערך, לעומת linked list שבה זו סטטיסטקיה של N/2.
לעומת זאת, עם אתה צריך בכל מקרה לעבור על כל המערך בכל פעם שאתה משתמש בו, לך על linked list.
עם אתה צריך את שניהם, אני מציע לך לנסות ולראות מה יפעל יותר טוב.

אני מניח שlinked list מוגדר כ List בJava.

הוא טועה כי בג'אווה זה תלוי בכמה דברים, לדוגמה בפרמטר capacityIncrement ב-constructor של Vector.

אתה טועה כי ב-CPP התקן לא אומר שום דבר כזה. המימוש של MS מכפיל ב-2 ואולי עוד מימושים עושים את זה, אבל התקן לא מחייב את זה בכלל. הוא אומר דברים כמו:

23.2.4 Template class vector
A vector is a kind of sequence that supports random access iterators. In addition it supports (amortized) constant time insert and erase operation at the end; insert and erase in the middle take linear time. Storage management is handled automatically, though hints can be given to improve efficiency.

23.2.4.3 vector modifiers

iterator insert (iterator position , const T& x);
void insert (iterator position, size_type n, const T& x);
template <class InputIterator> void insert (iterator position, InputIterator first, InputIterator last);

...
Complexity: If first and last are forward iterators, bidirectional iterators, or random access iterators, the complexity is linear in the number of elements in the range [first, last) plus the distance to the end of the vector. If they are input iterators, the complexity is proportional to the number of element in the range [first, last) times the distance to the end of the vector.

ועוד ועוד. הסיכום הוא שיש דרישות על סיבוכיות, אבל לא על הקבועים.

תודה רבה על עזרתכם, בסופו של דבר מצאתי לחשב את המידע בצורה חיה בלי להצטרך לשמור למערך ולחשב מאוחר יותר

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

ועוד נקודה קטנה לסיום:
JAVA 5 הוסיפה לשפה שימוש ב TEMPLATES, מה שמאפשר לך ליצור מראש וקטור של עצמים מסוג מוגדר, התיעוד לגבי מבנה הוקטור ב JAVA 5 נמצא כאן:
http://java.sun.com/j2se/1.5.0/docs...til/Vector.html

הראל

templates זה המנגנון ב-CPP שממש משכפל קוד ב-compile-time עבור כל טיפוס שעושים עבורו instantiation. ב-JAVA יש מנגנון generics שמגן עליך ב-compile-time מהעברת טיפוסים לא נכונים וחוסך cast-ים, אבל היכולת היא ממש להשתמש באותו קוד עבור טיפוסים שונים וזה משהו שמתרחש ב-run-time.

גם התיעוד של SUN מבדיל בין המונחים:

Java Generics vs. C++ Templates

While generics look like the C++ templates, it is important to note that they are not the same. Generics simply provide compile-time type safety and eliminate the need for casts. The main difference is encapsulation: errors are flagged where they occur and not later at some use site, and source code is not exposed to clients. Generics use a technique known as type erasure as described above, and the compiler keeps track of the generics internally, and all instances use the same class file at compile/run time.

A C++ template on the other hand is just a fancy macro processor; whenever a template class is instantiated with a new class, the entire code for the class is reproduced and recompiled for the new class.

עוד הבדל הוא שבעוד שב-CPP בתוך ה-template יש לך את כל המידע על טיפוס (וזוהי דרישה בעצם - אי-אפשר לבצע instantiation ל-incomplete type) בג'אווה קורה בדיוק ההפך: מבצעים את מה שנקרא במונחי ג'אווה type erasure ומעלימים את כל המידע על הטיפוס ה"טמפלייטי".


בג'אווה יש גם מושג של templates אבל הוא מדבר על משהו אחר לגמרי:
http://java.sun.com/javase/6/docs/a.../Templates.html