תכונות של ג'אווה 9 עם דוגמאות

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

Java 10 יוצאת לאור, למבט מלא על הגרסה, עבור ל- תכונות Java 10.

תכונות Java 9

כמה מתכונות Java 9 החשובות הן;

1. Java 9 REPL (JShell)
2. שיטות יצירה עבור רשימות, סטים, מפות ו-Map.Entry ללא שינויים
3. שיטות פרטיות בממשקים
4. מערכת מודולים של Java 9
5. שדרוגים ב-API של התהליכים
6. שיפורים ב- Try With Resources
7. שדרוגים ב-API של CompletableFuture
8. זרמים ריאקטיביים
9. אופרטור היהלום עבור מחלקה פנימית אנונימית
10. שדרוגים ב- Optional Class
11. שדרוגים ב-API של זרמים
12. הערות משופרות @Deprecated
13. לקוח HTTP 2
14. ממשק API של תמונה ברזולוציה מרובה
15. תכונות Java 9 שונות

חברת Oracle מתכננת לשחרר את Java SE 9 בסביבות סוף מרץ 2017. בפוסט הזה, אני אדבר קצת על "תכונות Java 9" בקצרה עם דוגמאות מסוימות.

REPL של Java 9 (JShell)

חברת Oracle הציגה כלי חדש בשם "jshell". זה מתייחס ל- Java Shell וגם ידוע כ- REPL (Read Evaluate Print Loop). משמש לביצוע ובדיקת כל בני גוף של Java כמו מחלקה, ממשק, enum, אובייקט, הצהרות וכו 'מאוד בקלות. ניתן להוריד את תוכנת JDK 9 EA (גישה מוקדמת) מ- https://jdk9.java.net/download/

G:\>jshell
|  Welcome to JShell -- Version 9-ea
|  For an introduction type: /help intro


jshell> int a = 10
a ==> 10

jshell> System.out.println("a value = " + a )
a value = 10

אם ברצונך לדעת עוד על הכלי REPL, יש לך אפשרות לעיין ב- יסודות של REPL של Java 9 (חלק 1) ו- תכונות REPL של Java 9 (חלק 2).

שיטות מפענח עבור רשימה, קבוצה, מפתח ו-Map.Entry ללא שינוי

חברת Oracle הציגה כמה שיטות מפענח נוחות כדי ליצור אובייקטים ללא שינוי של רשימה, קבוצה, מפתח ו-Map.Entry. שיטות התועלת הללו משמשות ליצירת אובייקטי אוסף ריקים או לא ריקים. ב-Java SE 8 וגרסאות קודמות, ניתן להשתמש בשיטות התועלת של מחלקת האוסף כמו unmodifiableXXX כדי ליצור אובייקטי אוסף ללא שינוי. לדוגמה, אם נרצה ליצור רשימה ללא שינוי, אז נוכל להשתמש בשיטת Collections.unmodifiableList. עם זאת, שיטות אלו Collections.unmodifiableXXX הן גישה מסורבלת ומפרטת. כדי להתגבר על החסרונות האלה, חברת Oracle הוסיפה כמה שיטות תועלת לממשקי List, Set ו-Map. ממשקי List ו-Set מכילים שיטות "of()" ליצירת רשימה או קבוצה ללא שינוי או ללא ריקה כמצויין למטה: דוגמת רשימה ריקה

List immutableList = List.of();

דוגמת רשימה לא ריקה

List immutableList = List.of("one","two","three");

למפתח יש שתי סדרות של שיטות: שיטות of() ושיטות ofEntries() ליצירת אובייקט Map ללא שינוי ואובייקט Map.Entry ללא שינוי בהתאמה. דוגמת מפתח ריקה

jshell> Map emptyImmutableMap = Map.of()
emptyImmutableMap ==> {}

דוגמת מפתח לא ריקה

jshell> Map nonemptyImmutableMap = Map.of(1, "one", 2, "two", 3, "three")
nonemptyImmutableMap ==> {2=two, 3=three, 1=one}

אם ברצונך לקרוא עוד אודות שיטות התועלת הללו, אנא עיין בקישורים הבאים:

• שיטות יצרת Java 9 עבור רשימה לא שינוית
• שיטות יצרת Java 9 עבור קבוצה לא שינוית
• שיטות יצרת Java 9 עבור מפה לא שינוית ועבור Map.Entry

שיטות פרטיות בממשקים

ב-Java 8, אנו יכולים לספק ביצוע של שיטות בממשקים באמצעות שיטות ברירת המחדל והסטטיות. אולם, אי אפשר ליצור שיטות פרטיות בממשקים. כדי למנוע קוד חוזר ולהגביר את היכולת לשוב ושימוש רב יותר, חברת Oracle הולכת להציע שיטות פרטיות בממשקי Java SE 9. החל מ-Java SE 9 והלאה, ניתן לכתוב שיטות פרטיות ושיטות סטטיות פרטיות גם בממשק באמצעות מילת המפתח 'private'. שיטות אלו הן כמו שיטות פרטיות אחרות במחלקה, אין הבחנה ביניהן.

public interface Card{

  private Long createCardID(){
    // ביצוע השיטה הולך כאן.
  }

  private static void displayCardDetails(){
    // ביצוע השיטה הולך כאן.
  }

}

אם ברצונך לקרוא עוד על תכונה זו, ניתן לעיין בקישור הבא: שיטות פרטיות ב-Java 9 בממשק.

מערכת מודולים של Java 9

אחת השינויים הגדולים או התכונות של Java 9 היא מערכת המודולים. חברת Oracle מתכוונת להציג את התכונות הבאות כחלק מהפרויקט Jigsaw.

• JDK מודולרי
• קוד מקור של Java בגרסה מודולרית
• תמונות ריצה מודולריות
• הטמעת ממשקי API פנימיים של Java
• מערכת מודולים של פלטפורמת Java

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

module com.foo.bar { }

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

• יסודות מערכת מודולים של Java 9
• דוגמאות למערכת מודולים של Java 9 באמצעות שורת פקודה
• דוגמת מודול של Hello World של Java 9 באמצעות סביבת Eclipse IDE

שיפורים ב-API של תהליך

Java SE 9 מגיעה עם שיפורים ב-API של תהליך. הם הוסיפו מספר מחלקות ושיטות חדשות כדי להקל על שליטה וניהול של תהליכי מערכת ההפעלה. שתי ממשקים חדשים ב-API של תהליך:

• java.lang.ProcessHandle
• java.lang.ProcessHandle.Info

דוגמת API של תהליך

 ProcessHandle currentProcess = ProcessHandle.current();
 System.out.println("Current Process Id: = " + currentProcess.getPid());

שיפור בניהול משאבים בעזרת Try With Resources

אנו יודעים, כי Java SE 7 הכניסה בנייה חדשה לטיפול בחריגות: Try-With-Resources כדי לנהל משאבים באופן אוטומטי. המטרה העיקרית של ההצהרה החדשה הזו היא "ניהול משאבים אוטומטי טוב יותר". Java SE 9 הולכת לספק שיפורים להצהרה זו כדי למנוע קצת יותר שטיות ולשפר קריאות. דוגמת Java SE 7

void testARM_Before_Java9() throws IOException{
 BufferedReader reader1 = new BufferedReader(new FileReader("journaldev.txt"));
 try (BufferedReader reader2 = reader1) {
   System.out.println(reader2.readLine());
 }
}

דוגמת Java 9

void testARM_Java9() throws IOException{
 BufferedReader reader1 = new BufferedReader(new FileReader("journaldev.txt"));
 try (reader1) {
   System.out.println(reader1.readLine());
 }
}

כדי לקרוא עוד על תכונה זו החדשה, אנא עבר על המדריך המקורי שלי ב־Java 9 Try-With-Resources Improvements

CompletableFuture API Improvements

ב־Java SE 9, חברת Oracle מתכוונת לשפר את ממשק ה־CompletableFuture API כדי לפתור חלק מהבעיות שהופיעו ב־Java SE 8. הם מתכוונים להוסיף תמיכה בעיכובים ובטיימאאוטים, כמה שיטות יעילות ושיפור ביצירת תת־מחלקות.

Executor exe = CompletableFuture.delayedExecutor(50L, TimeUnit.SECONDS);

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

Reactive Streams

בימינו, תכנות ריאקטיבי הפך לפופולרי מאוד בפיתוח יישומים כדי לקבל רווחה יפה. מסגרות כמו Scala, Play, Akka כבר משתלבות עם Reactive Streams ומקבלות רבות מכך. חברת Oracle גם מציגה API חדש של Reactive Streams ב־Java SE 9. ממשק ה־Reactive Streams ב־Java SE 9 הוא מסגרת פרסום/הרשמה כדי ליישם יישומים אסינכרוניים, נפרדים ופרוצדורליים בקלות רבה באמצעות שפת Java. Java SE 9 הציגה את ה־API הבאים כדי לפתח Reactive Streams ביישומי מבוססי Java.

• java.util.concurrent.Flow
• java.util.concurrent.Flow.Publisher
• java.util.concurrent.Flow.Subscriber
• java.util.concurrent.Flow.Processor

קרא עוד ב- Java 9 זרמים רקטיביים .

אופרטור היהלום למחלקה מופנית בתוך מחלקה אנונימית

אנו יודעים, ש-Java SE 7 הכניסה תכונה חדשה: אופרטור היהלום כדי למנוע קוד מיותר ופליציות, כדי לשפר קריאות. אך, ב-Java SE 8, חברת Oracle Corp (מפתחת ספריית Java) מצאה כי יש מגבלות בשימוש באופרטור היהלום עם מחלקה אנונימית. הם תיקנו את הבעיות האלו ומתכוונים לשחרר אותן כחלק מ-Java 9.

  public List getEmployee(String empid){
      // קוד לקבלת פרטי עובד ממאגר הנתונים 
     return new List(emp){ };
  }

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

שיפורים במחלקת אופציונל

ב-Java SE 9, תוספו על ידי חברת אורקל מספר שיטות חדשות ושימושיות למחלקת java.util.Optional. כאן אני הולך לדון באחת מהשיטות הללו עם דוגמה פשוטה: השיטה stream. אם ערך קיים באובייקט Optional הנתון, שיטת זרימה stream() מחזירה זרם סידרתי עם הערך הזה. אחרת, היא מחזירה זרם ריק. הם הוסיפו את השיטה "stream()" כדי לעבוד עם אובייקטים Optional באופן עצל כפי שמוצג למטה:

Stream<Optional> emp = getEmployee(id)
Stream empStream = emp.flatMap(Optional::stream)

כאן, השיטה Optional.stream() משמשת להמיר זרם של Optional של אובייקטי Employee לזרם של Employee כך שנוכל לעבוד על תוצאה זו באופן עצל בקוד התוצאה. כדי להבין יותר על תכונה זו עם דוגמאות נוספות וקריאה נוספת על שיטות חדשות המתווספות למחלקת Optional, אנא עברו על המדריך המקורי שלי ב: Java SE 9: שיפורים במחלקת Optional

שיפורים ב-Stream API

ב-Java SE 9, חברת Oracle הוסיפה ארבעה שיטות חדשות ושימושיות לממשק java.util.Stream. מכיוון ש-Stream הוא ממשק, כל השיטות החדשות שהוסרו הן שיטות ברירת מחדל. שתיים מתוכן הן חשובות מאוד: השיטות dropWhile ו-takeWhile. אם אתה מכיר עם שפת Scala או כל שפת תכנות פונקציונלית אחרת, בהחלט תכיר בשיטות אלו. אלו הן שיטות מאוד שימושיות בכתיבת קוד בסגנון פונקציונלי. בוא נדבר על שיטת ה- takeWhile כאן. פונקציית takeWhile() מקבלת פונקציית Predicate כארגומנט ומחזירה Stream של תת-קבוצה של ערכי ה-Stream הנתונים עד שה-Predicate מחזירה ערך שקר לראשונה. אם הערך הראשון אינו מקיים את ה-Predicate, היא פשוט מחזירה Stream ריק.

jshell> Stream.of(1,2,3,4,5,6,7,8,9,10).takeWhile(i -> i < 5 )
                 .forEach(System.out::println);
1
2
3
4

לקריאה נוספת על השיטות takeWhile ו-dropWhile ועל שאר השיטות החדשות, אנא עבור למדריך המקורי שלי ב: Java SE 9: Stream API Improvements

משופר @Deprecated הערות

ב-Java SE 8 וגרסאות קודמות, ההערה @Deprecated היא פשוט ממשק סימון ללא שיטות. היא משמשת לסימון של API של Java שהוא מחלקה, שדה, שיטה, ממשק, בנאי, enum וכו '. ב-Java SE 9, חברת Oracle העשירה את ההערה @Deprecated כדי לספק מידע נוסף אודות ה-API שהוצג כמנות וגם לספק כלי לניתוח של השימוש הסטטי של יישומון ב-APIs שהוצגו. הם הוסיפו שני שיטות לממשק ההוצג: forRemoval ו-since כדי לספק את המידע הזה.

לקוח HTTP 2

ב-Java SE 9, חברת Oracle מתכוונת לשחרר ממשק API חדש ל-HTTP 2 Client כדי לתמוך בפרוטוקול HTTP/2 ובתכונות של WebSocket. מכיוון שיש בעיות רבות עם ממשק ה-HTTP Client הקיים או המסורתי (כמו תמיכה בפרוטוקול HTTP/1.1 וחוסר תמיכה בפרוטוקול HTTP/2 וב-WebSocket, ועבודה רק במצב חסין ועוד בעיות בביצועים), הם מחליטים להחליף את API ה-HttpURLConnection עם ממשק ה-HTTP Client החדש. הם מתכוונים להציע ממשק חדש ל-HTTP 2 Client תחת החבילה "java.net.http". ה-Multi-Resolution Image API החדש יתווסף תחת Java SE 9, והממשק החשוב בו הוא MultiResolutionImage שזמין בחבילת java.awt.image. MultiResolutionImage מקנה סט של תמונות עם גדלים ורוחבים שונים (שזו רזולוציה שונה) ומאפשר לנו לשאול אותם עם הדרישות שלנו. לדוגמא, ניתן לראות את ה-API החדש בקישור: https://download.java.net/java/jdk9/docs/api/java/net/http/package-summary.html וקישור לדוגמא של HTTP 2 Client: HTTP 2 Client Example

jshell> import java.net.http.*

jshell> import static java.net.http.HttpRequest.*

jshell> import static java.net.http.HttpResponse.*

jshell> URI uri = new URI("https://rams4java.blogspot.co.uk/2016/05/java-news.html")
uri ==> https://rams4java.blogspot.co.uk/2016/05/java-news.html

jshell> HttpResponse response = HttpRequest.create(uri).body(noBody()).GET().response()
response ==> java.net.http.HttpResponseImpl@79efed2d

jshell> System.out.println("Response was " + response.body(asString()))

אני ממליץ לעיין במדריך המקורי שלך בקישור: Java SE 9: HTTP 2 Client כדי להבין את פרוטוקול ה-HTTP/2 ו-WebSocket, יתרונות ה-API החדש וחסרונות ה-API הישן עם דוגמאות שימושיות.

Multi-Resolution Image API

תכונות נוספות של Java 9

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

• שיפורים באיסוף הזבל (Garbage Collector)
• ממשק Stack-Walking
• סינון של נתוני סריאליזציה נכנסים
• הסרת תמיכה ב- Applet API
• החלפת חיבורי מחרוזות ל- Indify
• הרחבת ידיות של מתודות
• ממשק רישום ושירות ללוגים של פלטפורמת Java
• מחרוזות קומפקטיות
• ממשק ה- Parser עבור Nashorn
• חיפוש ב- Javadoc
• Javadoc של HTML5

I will pickup these java 9 features one by one and update them with enough description and examples. That’s all about Java 9 features in brief with examples.