streamalism.org

1. סקירה כללית

אוספי Eclipse היא מסגרת איסוף משופרת נוספת עבור Java.

במילים פשוטות, הוא מספק יישומים אופטימליים כמו גם כמה מבני נתונים ותכונות נוספים שאינם נמצאים בג'אבה הליבה.

הספרייה מספקת יישומים ניתנים לשינוי ובלתי משתנים של כל מבני הנתונים.

2. תלות של Maven

נתחיל בהוספת התלות הבאה של Maven שלנו pom.xml:

אנו יכולים למצוא את הגרסה האחרונה של הספרייה במאגר המרכזי של Maven.

3. התמונה הגדולה

3.1. סוגי אוספים בסיסיים

סוגי אוספים בסיסיים באוספי ליקוי חמה הם:

• ListIterable - אוסף מסודר השומר על צו הכניסה ומאפשר אלמנטים כפולים. ממשקי משנה כוללים: MutableList, FixedSizeList ו ImmutableList. הנפוץ ביותר יישום ListIterable הוא FastList, שהוא תת-מחלקה של MutableList
• SetIterable - אוסף שאינו מאפשר אלמנטים כפולים. ניתן למיין אותו או לא למיין אותו. ממשקי משנה כוללים: SortedSetIterable ו UnsortedSetIterable. הנפוץ ביותר לא ממוין SetIterable היישום הוא UnifiedSet
• MapIterable - אוסף של זוגות מפתח / ערך. ממשקי משנה כוללים מפה משתנה, FixedSizeMap ו ImmutableMap. שתי יישומים נפוצים הם UnifiedMap ו MutableSortedMap. בזמן UnifiedMap אינו מקיים שום צו, MutableSortedMap שומר על הסדר הטבעי של היסודות
• BiMap - אוסף של זוגות מפתח / ערך שניתן לחזור עליהם לשני הכיוונים. BiMap מרחיב את MapIterable מִמְשָׁק
• תיק - אוסף לא מסודר המאפשר כפילויות. ממשקי משנה כוללים MutableBag ו-תיק קבוע. היישום הנפוץ ביותר הוא HashBag
• StackIterable - אוסף השומר על הסדר "אחרון פנימה, ראשון החוצה", וחוזר באמצעות אלמנטים בסדר הכנסה הפוך. ממשקי משנה כוללים MutableStack ו ImmutableStack
• MultiMap - אוסף של זוגות מפתח / ערך המאפשר ערכים מרובים לכל מפתח

3.2. אוספים פרימיטיביים

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

• פְּרִימִיטִיבִי רשימות
• פְּרִימִיטִיבִי סטים
• פְּרִימִיטִיבִי ערימות
• פְּרִימִיטִיבִי תיקים
• פְּרִימִיטִיבִי מפות
• אינטרוול

יש מספר עצום של צורות מפה פרימיטיביות המכסות את כל הצירופים האפשריים של מקשים פרימיטיביים או אובייקטים וערכים פרימיטיביים או אובייקטים.

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

4. ייסוד אוסף

כדי להוסיף אלמנטים ל- רשימת מערך אוֹ HashSet, אנו מיישרים אוסף על ידי התקשרות לבנאי no-arg ואז הוספת כל אלמנט אחד אחד.

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

בואו נראה איך נוכל ליצור א FastList:

רשימת MutableList = FastList.newListWith ("פורשה", "פולקסווגן", "טויוטה", "מרצדס", "טויוטה");

באופן דומה, אנו יכולים ליצור א UnifiedSet ולהוסיף לו אלמנטים על ידי העברת האלמנטים אל ה- newSetWith () שיטה סטטית:

הגדר השוואה = UnifiedSet.newSetWith ("פורשה", "פולקסווגן", "טויוטה", "מרצדס");

כך נוכל ליצור א HashBag:

תיק MutableBag = HashBag.newBagWith ("פורשה", "פולקסווגן", "טויוטה", "פורשה", "מרצדס");

יישום מפות והוספת זוגות מפתח וערך אליהם דומה. ההבדל היחיד הוא שאנחנו מעבירים את זוגות המפתח והערך אל ה- newMapWith () שיטה כיישומים של זוג מִמְשָׁק.

בוא ניקח UnifiedMap לדוגמא:

זוג זוג 1 = Tuples.pair (1, "אחד"); זוג זוג 2 = Tuples.pair (2, "שניים"); זוג זוג 3 = Tuples.pair (3, "שלוש"); UnifiedMap map = UnifiedMap חדש (pair1, pair2, pair3);

אנחנו עדיין יכולים להשתמש בגישה של Java Collections API:

UnifiedMap map = UnifiedMap חדש (); map.put (1, "one"); map.put (2, "שניים"); map.put (3, "שלוש");

מאז לא ניתן לשנות אוספים בלתי ניתנים לשינוי, ואין להם יישומים של שיטות המשנות אוספים כמו לְהוֹסִיף() ו לְהַסִיר().

אוספים שאינם ניתנים לשינוי, לעומת זאת, מאפשרים לנו לקרוא לשיטות אלה אך יזרקו לא נתמךOperationException אם כן.

5. אחזור אלמנטים מאוספים

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

list.get (0);

וניתן להשיג ערכים של מפות אוספי Eclipse באמצעות המפתח שלהם:

map.get (0);

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

map.getFirst (); map.getLast ();

השיטות מקסימום () ו דקה () ניתן להשתמש בכדי לקבל את הערכים המקסימליים והמינימליים של אוסף בהתבסס על ההזמנה הטבעית.

map.max (); map.min ();

6. איטרציה על פני אוסף

אוספי ליקוי חמה מספקים דרכים רבות לאיתור על פני אוספים. בואו נראה מה הם ואיך הם עובדים בפועל.

6.1. סינון אוספים

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

הנה דוגמה:

@Test הציבור בטל givenListwhenSelect_thenCorrect () {MutableList greaterThanThirty = רשימה .select (Predicates.greaterThan (30)) .sortThis (); Assertions.assertThat (greaterThanThirty). מכיל בדיוק (31, 38, 41); }

ניתן לעשות את אותו הדבר באמצעות ביטוי למבדה פשוט:

list list.select (i -> i> 30) .sortThis ();

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

בואו נראה דוגמה:

@ מבחן ציבורי בטל כאשר Reject_thenCorrect () {MutableList notGreaterThanThirty = list. Reject (Predicates.greaterThan (30)) .sortThis (); Assertions.assertThat (notGreaterThanThirty) .containsExactlyElementsOf (this.expectedList); }

כאן אנו דוחים את כל האלמנטים הגדולים מ- 30.

6.2. ה לאסוף() שיטה

ה לאסוף שיטה מחזירה אוסף חדש שהאלמנטים שלו הם התוצאות שהוחזרו על ידי ביטוי הלמבה המסופק - למעשה זה שילוב של מַפָּה() ו לאסוף() מ- Stream API.

בואו נראה את זה בפעולה:

@ מבחן ציבורי בטל כאשר Collect_thenCorrect () {סטודנט סטודנט 1 = סטודנט חדש ("ג'ון", "הופקינס"); סטודנט סטודנט 2 = סטודנט חדש ("ג'ורג '", "אדמס"); תלמידי MutableList = FastList .newListWith (student1, student2); MutableList lastNames = students .collect (סטודנט :: getLastName); Assertions.assertThat (lastNames). מכיל בדיוק ("הופקינס", "אדמס"); }

האוסף שנוצר שמות משפחה מכיל את שמות המשפחה שנאספים מה- סטודנטים רשימה.

אבל, מה אם האוסף שהוחזר הוא אוסף של אוספים ואנחנו לא רוצים לשמור על מבנה מקונן?

לדוגמא, אם לכל תלמיד יש מספר כתובות, ואנו זקוקים לאוסף המכיל את הכתובות כ- מיתרים במקום אוסף של אוספים, אנו יכולים להשתמש ב- flatCollect () שיטה.

הנה דוגמה:

@ מבחן פומבי בטל כאשרFlatCollect_thenCorrect () {כתובות MutableList = סטודנטים .flatCollect (סטודנט :: getAddresses); Assertions.assertThat (כתובות) .containsExactlyElementsOf (this.expectedAddresses); }

6.3. איתור אלמנטים

ה לזהות השיטה מוצאת ומחזירה את האלמנט הראשון העונה על תנאי הגיוני.

בוא נעבור על דוגמה מהירה:

@Test ציבורי בטל כאשרDetect_thenCorrect () {תוצאה שלמה = list.detect (Predicates.greaterThan (30)); Assertions.assertThat (תוצאה) .isEqualTo (41); }

ה anySatisfy השיטה קובעת אם אלמנט כלשהו באוסף עומד בתנאי הגיוני.

הנה דוגמה:

@ מבחן ציבורי בטל כאשר AnySatisfiesCondition_thenCorrect () {תוצאה בוליאנית = list.anySatisfy (Predicates.greaterThan (30)); assertTrue (תוצאה); }

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

בואו נראה דוגמה מהירה:

@ מבחן ציבורי בטל כאשרAnySatisfiesCondition_thenCorrect () {תוצאה בוליאנית = list.allSatisfy (Predicates.greaterThan (0)); assertTrue (תוצאה); }

6.4. ה חֲלוּקָה() שיטה

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

בואו נראה דוגמה:

@ מבחן ציבורי בטל כאשרAnySatisfiesCondition_thenCorrect () {MutableList numbers = list; PartitionMutableList partitionedFolks = מספרים. Partition (i -> i> 30); MutableList greaterThanThirty = partitionedFolks .getSelected () .sortThis (); MutableList smallerThanThirty = partitionedFolks .getRejected () .sortThis (); Assertions.assertThat (smallerThanThirty). מכיל בדיוק (1, 5, 8, 17, 23); Assertions.assertThat (greaterThanThirty). מכיל בדיוק (31, 38, 41); }

6.5. איטרציה עצלנית

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

@ מבחן ציבורי בטל כאשרLazyIteration_thenCorrect () {סטודנט סטודנט 1 = סטודנט חדש ("ג'ון", "הופקינס"); סטודנט סטודנט 2 = סטודנט חדש ("ג'ורג '", "אדמס"); סטודנט סטודנט 3 = סטודנט חדש ("ג'ניפר", "רודריגז"); סטודנטים של MutableList = Lists.mutable .with (student1, student2, student3); LazyIterable lazyStudents = students.asLazy (); LazyIterable lastNames = lazyStudents .collect (סטודנט :: getLastName); Assertions.assertThat (lastNames) .containsAll (Lists.mutable.with ("Hopkins", "Adams", "Rodriguez")); }

הנה ה lazyStudents האובייקט לא מאחזר את האלמנטים של סטודנטים רשימת עד לאסוף() שיטה נקראת.

7. התאמת אלמנטים לאוסף

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

בואו נראה איך נוכל להשתמש בזה:

@ מבחן ציבורי בטל כאשר Zip_thenCorrect () {MutableList numbers = Lists.mutable .with ("1", "2", "3", "Ignored"); מכוניות MutableList = Lists.mutable .with ("פורשה", "וולוו", "טויוטה"); MutableList זוגות = numbers.zip (מכוניות); Assertions.assertThat (זוגות) .containsExactlyElementsOf (this.expectedPairs); }

אנו יכולים גם להתאים את אלמנטים של אוסף לאינדקסים שלהם באמצעות ה- zipWithIndex () שיטה:

@ מבחן ציבורי בטל כאשר Zip_thenCorrect () {מכוניות mutableList = FastList .newListWith ("פורשה", "וולוו", "טויוטה"); MutableList זוגות = cars.zipWithIndex (); Assertions.assertThat (זוגות) .containsExactlyElementsOf (this.expectedPairs); }

8. המרת אוספים

אוספי Eclipse מספק שיטות פשוטות להמרת סוג מיכל לסוג אחר. שיטות אלה הן למנות(), כדי להגדיר(), לתיק() ו למפות().

בואו נראה איך נוכל להשתמש בהם:

רשימה סטטית ציבורית convertToList () {מכוניות UnifiedSet = UnifiedSet חדש (); cars.add ("טויוטה"); cars.add ("מרצדס"); cars.add ("פולקסווגן"); להחזיר cars.toList (); }

בואו נעבור את המבחן שלנו:

@Test הציבור בטל כאשר ConvertContainerToAnother_thenCorrect () {מכוניות MutableList = (MutableList) ConvertContainerToAnother .convertToList (); Assertions.assertThat (מכוניות). מכיל בדיוק ElementsOf (FastList.newListWith ("פולקסווגן", "טויוטה", "מרצדס")); }

9. מסקנה

במדריך זה ראינו סקירה מהירה של אוספי Eclipse והתכונות שהם מספקים.

היישום המלא של מדריך זה זמין ב- GitHub.