streamalism.org

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

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

2. הצטרף לשניים מערכים

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

@ מבחן ציבורי בטל כאשר מצטרפים שני ארציות_ואזבנו () {מחרוזת [] חיות 1 = מחרוזת חדשה [] {"כלב", "חתול"}; מחרוזת [] חיות 2 = מחרוזת חדשה [] {"ציפור", "פרה"}; מחרוזת [] תוצאה = Stream.concat (Arrays.stream (חיות 1), Arrays.stream (חיות 2)). ToArray (מחרוזת [] :: חדש); assertArrayEquals (תוצאה, מחרוזת חדשה [] {"כלב", "חתול", "ציפור", "פרה"}); }

3. הצטרף לשניים אוספים

בואו נעשה את אותו הדבר נצטרף לשניים אוספים:

@Test הציבור בטל כאשרJoiningTwoCollections_thenJoined () {אוסף אוסף 1 = Arrays.asList ("כלב", "חתול"); אוסף אוסף 2 = Arrays.asList ("ציפור", "פרה", "אייל"); תוצאת אוסף = Stream.concat (collection1.stream (), collection2.stream ()) .collect (Collectors.toList ()); assertTrue (result.equals (Arrays.asList ("כלב", "חתול", "ציפור", "פרה", "אייל")); }

4. הצטרף לשניים אוספים Wעם פילטר

עכשיו, בואו נצטרף לשניים אוספים מספרים המסננים כל דבר גדול מ -10:

@ מבחן פומבי בטל כאשרJoiningTwoCollectionsWithFilter_thenJoined () {Collection collection1 = Arrays.asList ("כלב", "חתול"); אוסף אוסף 2 = Arrays.asList ("ציפור", "פרה", "אייל"); תוצאת האוסף = Stream.concat (collection1.stream (), collection2.stream ()) .filter (e -> e.length () == 3) .collect (Collectors.toList ()); assertTrue (result.equals (Arrays.asList ("כלב", "חתול", "פרה")); }

5. הצטרף ל- מַעֲרָך לתוך חוּט

לאחר מכן, בואו נצטרף למערך ל- a חוּט באמצעות א אַסְפָן:

@ מבחן ציבורי בטל כאשר ConvertArrayToString_thenConverted () {String [] בעלי חיים = מחרוזת חדשה [] {"כלב", "חתול", "ציפור", "פרה"}; תוצאת מחרוזת = Arrays.stream (בעלי חיים) .collect (Collectors.joining (",")); assertEquals (תוצאה, "כלב, חתול, ציפור, פרה"); }

6. הצטרף אל אוסף לתוך חוּט

בואו נעשה את אותו הדבר אבל עם א אוסף:

@ מבחן פומבי בטל כאשר ConConvertCollectionToString_thenConverted () {אוסף בעלי חיים = Arrays.asList ("כלב", "חתול", "ציפור", "פרה"); תוצאת מחרוזת = animal.stream (). Collect (Collectors.joining (",")); assertEquals (תוצאה, "כלב, חתול, ציפור, פרה"); }

7. הצטרף אל מַפָּה לתוך חוּט

לאחר מכן, בואו ליצור a חוּט מתוך א מַפָּה.

התהליך דומה מאוד לדוגמאות קודמות, אך כאן יש לנו שלב נוסף להצטרף תחילה לכל אחת מהן מַפָּהכְּנִיסָה:

@ מבחן ציבורי בטל כאשרConvertMapToString_thenConverted () {מפה בעלי חיים = HashMap חדש (); animal.put (1, "כלב"); animal.put (2, "חתול"); animal.put (3, "פרה"); תוצאה מחרוזת = animal.entrySet (). Stream () .map (entry -> entry.getKey () + "=" + entry.getValue ()) .collect (Collectors.joining (",")); assertEquals (תוצאה, "1 = כלב, 2 = חתול, 3 = פרה"); }

8. הצטרף לקן אוספים לתוך חוּט

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

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

@Test ציבורי בטל כאשרConvertNestedCollectionToString_thenConverted () {אוסף מקונן = ArrayList חדש (); nested.add (Arrays.asList ("כלב", "חתול")); nested.add (Arrays.asList ("פרה", "חזיר")); תוצאת מחרוזת = nested.stream (). מפה (nextList -> nextList.stream () .collect (Collectors.joining ("-"))) .collect (Collectors.joining (";")); assertEquals (תוצאה, "כלב-חתול; חזיר-פרה"); }

9. ידית ריק ערכים בעת הצטרפות

פן יראה כיצד אנו יכולים להשתמש ב- לְסַנֵן לדלג על כל אחד ריק ערכים:

@ מבחן ציבורי בטל כאשר ConverCollectionToStringAndSkipNull_thenConverted () {אוסף בעלי חיים = Arrays.asList ("כלב", "חתול", null, "אייל"); תוצאת מחרוזת = animal.stream () .filter (אובייקטים :: nonNull) .collect (Collectors.joining (",")); assertEquals (תוצאה, "כלב, חתול, אייל"); }

10. פיצול א אוסף בשתיים

בואו נחלק א אוסף מספרים לשניים אוספים באמצע:

@ מבחן פומבי בטל כאשר SplitCollectionHalf_thenConverted () {אוסף בעלי חיים = Arrays.asList ("כלב", "חתול", "פרה", "ציפור", "אייל", "חזיר"); אוסף result1 = ArrayList חדש (); אוסף result2 = ArrayList חדש (); ספירת AtomicInteger = AtomicInteger חדש (); נקודת אמצע int = Math.round (animal.size () / 2); animals.forEach (הבא -> {int index = count.getAndIncrement (); if (index <midpoint) {result1.add (next);} else {result2.add (next);}}); assertTrue (result1.equals (Arrays.asList ("כלב", "חתול", "פרה")); assertTrue (result2.equals (Arrays.asList ("ציפור", "אייל", "חזיר")); }

11. פיצול an מַעֲרָך לפי אורך מילים

לאחר מכן, בואו נחלק מערך באורך המילים:

@ מבחן פומבי בטל כאשר SplitArrayByWordLength_thenConverted () {String [] בעלי חיים = מחרוזת חדשה [] {"כלב", "חתול", "ציפור", "פרה", "חזיר", "אייל"}; מַפָּה תוצאה = Arrays.stream (בעלי חיים) .collect (Collectors.groupingBy (מחרוזת :: אורך)); assertTrue (result.get (3) .equals (Arrays.asList ("כלב", "חתול", "פרה", "חזיר")); assertTrue (result.get (4) .equals (Arrays.asList ("ציפור"))); assertTrue (result.get (5) .equals (Arrays.asList ("Moose"))); }

12. פיצול א חוּט לתוך מַעֲרָך

בואו נעשה עכשיו את ההפך, בואו נחלק א חוּט לתוך מַעֲרָך:

@ מבחן ציבורי בטל כאשר ConvertStringToArray_thenConverted () {מחרוזת בעלי חיים = "כלב, חתול, ציפור, פרה"; מחרוזת [] תוצאה = animal.split (","); assertArrayEquals (תוצאה, מחרוזת חדשה [] {"כלב", "חתול", "ציפור", "פרה"}); }

13. פיצול חוּט לתוך אוסף

דוגמה זו דומה לזו הקודמת, יש רק שלב נוסף להמרה ממנו מַעֲרָך אל א אוסף:

@ מבחן ציבורי בטל כאשר ConvertStringToCollection_thenConverted () {חיות מחרוזת = "כלב, חתול, ציפור, פרה"; תוצאת האוסף = Arrays.asList (animal.split (",")); assertTrue (result.equals (Arrays.asList ("כלב", "חתול", "ציפור", "פרה")); }

14. פיצול א חוּט לתוך מַפָּה

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

@ מבחן ציבורי בטל כאשר ConvertStringToMap_thenConverted () {חיות מחרוזת = "1 = כלב, 2 = חתול, 3 = ציפור"; תוצאת מפה = Arrays.stream (animal.split (",")). מפה (next -> next.split ("=")) .collect (Collectors.toMap (entry -> Integer.parseInt (entry [0]) , ערך -> ערך [1])); assertEquals (result.get (1), "כלב"); assertEquals (result.get (2), "חתול"); assertEquals (result.get (3), "ציפור"); }

15. פיצול מחרוזת Wעם מפרידים מרובים

לבסוף, בואו נחלק א חוּט שיש בו מפרידים מרובים המשתמשים בביטוי רגולרי, נסיר גם תוצאות ריקות:

@ מבחן ציבורי בטל כאשר ConConvertCollectionToStringMultipleSeparators_thenConverted ().] ")) .Map (String :: trim) .filter (next ->! Next.isEmpty ()) .collect (Collectors.toList ()); assertTrue (result.equals (Arrays) .asList ("כלב", "חתול", "ציפור", "פרה"))); 

16. מסקנה

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

אתה יכול למצוא את הקוד עבור מאמר זה ב- GitHub.