streamalism.org

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

ב- Groovy אנחנו יכולים לעבוד עם רשימות בדיוק כמו שאנחנו עושים ב- Java. אבל, עם התמיכה שלה בשיטות הרחבה, זה נשלח עם לא מעט יותר.

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

2. יצירת רשימות גרובי

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

נתחיל ביצירת רשימה עם כמה ערכים באמצעות התחביר הקצר:

רשימת def = [1,2,3]

באופן דומה, אנו יכולים ליצור רשימה ריקה:

def ריק רשימה = []

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

def linkedList = [1,2,3] כ- ListList ArrayList arrList = [1,2,3]

לאחר מכן, ניתן להשתמש ברשימות ליצירת רשימות אחרות באמצעות ארגומנט קונסטרוקטור:

def copyList = ArrayList חדש (arrList)

או על ידי שיבוט:

def cloneList = arrList.clone ()

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

גרובי משתמש במפעיל "==" כדי להשוות את האלמנטים בשתי רשימות לשוויון. בהמשך לדוגמה הקודמת, על השוואה cloneList עם ארליסט התוצאה היא נָכוֹן:

assertTrue (cloneList == arrList)

עכשיו, בואו נסתכל כיצד לבצע כמה פעולות נפוצות ברשימות.

3. אחזור פריטים מרשימה

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

def list = ["שלום", "עולם"] assertTrue (רשימה [1] == "עולם")

או באמצעות לקבל() ו getAt () שיטות:

assertTrue (list.get (1) == "עולם") assertTrue (list.getAt (1) == "עולם")

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

assertTrue (רשימה [-1] == "עולם") assertTrue (list.getAt (-2) == "שלום")

שים לב שה- לקבל() השיטה אינה תומכת באינדקס שלילי.

4. הוספת פריטים לרשימה

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

def list = [] list << 1 list.add ("Apple") assertTrue (list == [1, "Apple"])

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

list [2] = "Box" list [4] = true assertTrue (list == [1, "Apple", "Box", null, true])

לבסוף, אנו יכולים להשתמש ב"+=” מפעיל להוסיף פריטים חדשים לרשימה. בהשוואה לגישות האחרות, אופרטור זה יוצר אובייקט רשימה חדש ומקצה אותו למשתנה רשימה:

def list2 = [1,2] list + = list2 list + = 12 assertTrue (list == [1, 6.0, "Apple", "Box", null, true, 1, 2, 12])

5. עדכון פריטים ברשימה

אנו יכולים לעדכן פריטים ברשימה באמצעות התחביר המילולי או ה- מַעֲרֶכֶת() שיטה:

def list = [1, "Apple", 80, "App"] list [1] = "Box" list.set (2,90) assertTrue (list == [1, "Box", 90, "App"] )

בדוגמה זו, הפריטים באינדקס 1 ו -2 מתעדכנים בערכים חדשים.

6. הסרת פריטים מרשימה

אנו יכולים להסיר פריט באינדקס מסוים באמצעות ה- לְהַסִיר() שיטה:

def list = [1,2,3,4,5,5,6,6,7] list.remove (3) assertTrue (list == [1,2,3,5,5,6,6,7] )

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

list.removeElement (5) assertTrue (list == [1,2,3,5,6,6,7])

בנוסף, אנחנו יכולים להשתמש ב- מִינוּס כדי להסיר את כל המופעים של אלמנט מהרשימה. אולם מפעיל זה אינו משנה את הרשימה הבסיסית - הוא מחזיר רשימה חדשה:

assertTrue (רשימה - 6 == [1,2,3,5,7])

7. איטרציה ברשימה

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

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

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

def list = [1, "App", 3,4] list.each {println it * 2}

השיטה האחרת, eachWithIndex () מספק את ערך האינדקס הנוכחי בנוסף לאלמנט הנוכחי:

list.eachWithIndex {it, i -> println "$ i: $ it"}

8. סינון

סינון הוא פעולה נוספת שמבוצעת לעיתים קרובות ברשימות, ו- Groovy מספק שיטות רבות לבחירה.

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

def filterList = [2,1,3,4,5,6,76]

כדי למצוא את האובייקט הראשון שתואם למצב בו אנו יכולים להשתמש למצוא:

assertTrue (filterList.find {it> 3} == 4)

כדי למצוא את כל האובייקטים התואמים למצב בו אנו יכולים להשתמש מצא הכל:

assertTrue (filterList.findAll {it> 3} == [4,5,6,76])

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

assertTrue (filterList.findAll {it instanceof Number} == [2,1,3,4,5,6,76])

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

assertTrue (filterList.grep (Number) == [2,1,3,4,5,6,76])

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

assertTrue (filterList.grep {it> 6} == [76])

בנוסף, grep שימושים אובייקט # isCase (java.lang.Object) להעריך את המצב בכל רכיב ברשימה.

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

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

def uniqueList = [1,3,3,4] uniqueList.unique () assertTrue (ייחודי רשימה == [1,3,4])

לחלופין, אם הדרישה היא לא לשנות את הרשימה הבסיסית, נוכל להשתמש ב- toUnique () שיטה:

assertTrue (["A", "B", "Ba", "Bat", "Cat"]. toUnique {it.size ()} == ["A", "Ba", "Bat"])

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

ה כֹּל() השיטה מעריכה את המצב בסגירה מול כל רכיב ברשימה. ואז, זה רק חוזר נָכוֹן אם כל האלמנטים ברשימה עומדים בתנאי:

def conditionList = [2,1,3,4,5,6,76] assertFalse (conditionList.every {it <6})

ה כל() לעומת זאת, השיטה חוזרת נָכוֹן אם אלמנט כלשהו ברשימה עומד בתנאי:

assertTrue (conditionList.any {it% 2 == 0})

9. מיון

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

assertTrue ([1,2,1,0]. sort () == [0,1,1,2])

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

השוואה mc = {a, b -> a == b? 0: a <b? 1: -1} def list = [1,2,1,0] list.sort (mc) assertTrue (list == [2,1,1,0])

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

def strList = ["na", "ppp", "as"] assertTrue (strList.max () == "ppp")

השוואה minc = {a, b -> a == b? 0: a <b? -1: 1} def numberList = [3, 2, 0, 7] assertTrue (numberList.min (minc) == 0)

10. איסוף

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

def list = ["קיי", "הנרי", "ג'סטין", "טום"] טוענים נכון (list.collect {"היי" + זה} == ["היי קיי", "הי הנרי", "הי ג'סטין", "היי טום"])

11. הצטרפות

לעיתים נצטרך להצטרף לפריטים ברשימה. לשם כך אנו יכולים לְהִצְטַרֵף() שיטה:

assertTrue (["" אחד, "שניים", "שלושה"]. להצטרף (",") == "אחד, שניים, שלושה")

12. מסקנה

במאמר זה סקרנו כמה מהרחבות שמוסיף גרובי ל- Java אוספים ממשק API.

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

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

כמו תמיד, כל הדוגמאות הנדונות במאמר זמינות באתר GitHub.