streamalism.org

1. הקדמה

זה נפוץ שיש להמיר מבני נתונים דינמיים שונים למערכים.

במדריך זה נדגים כיצד להמיר a זרם למערך ולהיפך בג'אווה.

2. המרת א זרם למערך

2.1. הפניה לשיטה

הדרך הטובה ביותר להמיר זרם למערך זה להשתמש זרם'ס toArray () שיטה:

מחרוזת ציבורית [] usingMethodReference (Stream stringStream) {return stringStream.toArray (String [] :: new); }

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

Stream stringStream = Stream.of ("baeldung", "convert", "to", "string", "array"); assertArrayEquals (מחרוזת חדשה [] {"baeldung", "להמיר", "ל", "מחרוזת", "מערך"}, באמצעות MethodReference (stringStream));

2.2. ביטוי למבדה

מקבילה נוספת היא ל- להעביר ביטוי למבדה אל ה toArray() שיטה:

מחרוזת סטטית ציבורית [] usingLambda (Stream stringStream) {return stringStream.toArray (size -> String new [size]); }

זה ייתן לנו את אותה התוצאה כמו בשימוש בהתייחסות לשיטה.

2.3. כיתה בהתאמה אישית

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

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

כמובן, IntFunction הוא ממשק כדי שנוכל ליישם אותו:

מחלקה MyArrayFunction מיישמת את IntFunction {@Override Public String [] Apply (int size) {החזר מחרוזת חדשה [size]; }};

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

מחרוזת ציבורית [] usingCustomClass (Stream stringStream) {return stringStream.toArray (MyArrayFunction new ()); }

כתוצאה מכך, אנו יכולים להשמיע את אותה קביעה כמו קודם.

2.4. מערכים פרימיטיביים

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

זה קצת שונה עבור פרימיטיבים, אם כי. אם יש לנו זרם שֶׁל מספר שלםs שאנחנו רוצים להמיר אליהם int [], למשל, ראשית עלינו להתקשר ל- mapToInt () שיטה:

public int [] intStreamToPrimitiveIntArray (זרם integerStream) {החזר integerStream.mapToInt (i -> i) .toArray (); }

יש גם mapToLong () ו mapToDouble () שיטות העומדות לרשותנו. כמו כן, שים לב שלא העברנו שום טיעון ל toArray () הפעם.

לסיום, בואו נעשה את טענת השוויון ונאשר שיש לנו את שלנו int מערך נכון:

זרם integerStream = IntStream.rangeClosed (1, 7) .boxed (); assertArrayEquals (int int [] {1, 2, 3, 4, 5, 6, 7}, intStreamToPrimitiveIntArray (integerStream));

מה אם עלינו לעשות את ההפך? בואו נסתכל.

3. המרת מערך ל זרם

אנחנו יכולים, כמובן, גם ללכת בדרך אחרת. ול- Java יש כמה שיטות ייעודיות לכך.

3.1. מגוון של לְהִתְנַגֵדס

אנו יכולים להמיר את המערך ל- זרם באמצעות Arrays.stream () אוֹ זרם של() שיטות:

זרם ציבורי stringArrayToStreamUsingArraysStream (String [] stringArray) {return Arrays.stream (stringArray); } זרם ציבורי stringArrayToStreamUsingStreamOf (String [] stringArray) {return Stream.of (stringArray); }

עלינו לציין כי בשני המקרים, שלנו זרם הוא באותו זמן כמו המערך שלנו.

3.2. מערך פרימיטיבים

באופן דומה, אנו יכולים להמיר מערך של פרימיטיבים:

IntStream פומבי PrimitiveIntArrayToStreamUsingArraysStream (int [] intArray) {return Arrays.stream (intArray); } זרם ציבורי primitiveIntArrayToStreamUsingStreamOf (int [] intArray) {return Stream.of (intArray); }

אבל, בניגוד להמרה לְהִתְנַגֵדלמערכים, יש הבדל חשוב. בעת המרת מערך פרימיטיבי, Arrays.stream () החזרות IntStream, בזמן זרם של() החזרות זרם.

3.3. Arrays.stream לעומת. זרם של

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

בואו נסתכל תחילה על יישום Java של שתי השיטות הבאות:

זרם זרם ציבורי (מערך T []) {זרם חוזר (מערך, 0, מערך.אורך); } זרם ציבורי של (T ... ערכים) {return Arrays.stream (ערכים); }

אנחנו יכולים לראות את זה זרם של() הוא בעצם מתקשר Arrays.stream () באופן פנימי וזו ללא ספק הסיבה לכך שאנחנו מקבלים את אותן התוצאות.

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

זרם IntStream ציבורי (מערך int []) {זרם חוזר (מערך, 0, מערך.אורך); } זרם ציבורי של (T t) {החזר StreamSupport.stream (Streams.StreamBuilderImpl חדש (t), שקר); }

הפעם, זרם של() לא קורא ל Arrays.stream ().

4. מסקנה

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

כמו תמיד, ניתן למצוא קוד מקור מלא ב- GitHub.