מאמר
הַתחָלָה
תתחיל ללמוד
JavaRush /בלוג Java /Random-HE /Java 13: תכונות חדשות
Эллеонора Керри
רָמָה

Java 13: תכונות חדשות

פורסם בקבוצה
כבר התרגלנו לעובדה שגרסה חדשה של JDK מופיעה כל חצי שנה. עד כה, הגישה הזו הצדיקה את עצמה, והדאגות של חלק מהמפתחים שלא יעמדו בקצב העדכונים היו לשווא: יש מעט שינויים של חצי שנה והם אינם גלובליים כמו קודם. ובכן, מתכנתים מתחילים עשויים שלא לשים לב לחידוש בכלל. Java 13: תכונות חדשות - 1עם זאת, עדיף למפתחי תוכנה עתידיים להתעדכן בחידושים. במאמר זה נתאר באופן מסורתי הצעות הרחבה מקובלות (JEP). Java 13 כולל רק חמישה JEPs ו-76 אלמנטים חדשים של ספריית ליבה (כמעט מחציתם הם תוספות פשוטות לחבילת java.io).

JEP 355 : בלוקים של טקסט (תצוגה מקדימה)

נתחיל בשינוי התחביר של השפה. המשמעותיים שבהם הם בלוקי טקסט. הם מאפשרים לך להימנע מתווים בריחה ולדעת איך לעצב מחרוזות. אתה אולי זוכר ש-JDK 12 לא כלל את תכונת המיתר הגולמי (JEP 326) הצפויה לעבודה עם מילות מיתר. ב-Java 13, הוא הוחלף ב-JEP 355 עם בלוקי הטקסט שלו. אתה בוודאי זוכר שב-Java, מחרוזת עטופה במירכאות כפולות. זה טוב, אבל הבעיה היא ששורה לא יכולה לתפוס יותר משורה אחת בקובץ המקור (כדי למנוע בלבול עם שורת Java, כאן נקרא לשורה של קובץ "שורה"). ובכן, בואו נסתובב ונשתמש, למשל, בסמל \nאם נדרשת הפסקה, או שרשור של ביטויים מרובי שורות. זה לא יוצא יפה במיוחד! מילולי טקסט עם קטעי HTML, XML, SQL או JSON מוטבעים הם מסורבלים במיוחד. כל הבריחה, השרשור והעריכה הידנית הזו הופכים את הקוד לבלתי נוח לכתיבה וקשה לקריאה. בלוקים של טקסט מנסים לפתור בעיה זו. הם מתחילים אה... עם מרכאות כפולות משולשות ומסתיימות בהן (אני יודע, זה לא נשמע טוב). כל מה שבין הציטוטים מתפרש כחלק מהשורה, כולל שורות חדשות. ניתן להשתמש בלוקים של טקסט בדיוק כמו מילוליות טקסט רגילות, ו-Java יקמפל את הקוד באותו אופן. אחרי ציטוטי פתיחה יש להגדיר קו מפריד; לא ניתן להשתמש בלוקי טקסט בשורה אחת, אז הקוד 
String smallBlock = """Only one line""";
יוביל לשגיאות הבאות: 
TextBlock.java:3: error: illegal text block open delimiter sequence, missing line terminator
   String smallBlock = """Text Block""";
                          ^
TextBlock.java:3: error: illegal text block open delimiter sequence, missing line terminator
   String smallBlock = """Text Block""";
                                   	^
Java-университет
כעת ניתן לכתוב קטע HTML פשוט כך: 
String htmlBlock = """
               	<html>
                 	<body>
                   	<p>CodeGym Web page</p>
                 	</body>
               	<html>
         	     """;
נזכיר כמה דקויות שעדיף להיות מודעים אליהן בעת ​​שימוש בלוקים של טקסט. המיקום של הציטוטים הסוגרים מתברר כחשוב: הוא קובע כיצד מטפלים ברווח הלבן מדי פעם. בדוגמה שלמעלה, המירכאות הסוגרות מיושרות עם ההזחה של טקסט ה-HTML. במקרה זה, המהדר יסיר את רווחי ההזחה, וכתוצאה מכך נקבל שורה כזו: 
<html>
  <body>
    <p>My web page</p>
  </body>
</html>
הערה:שורה כזו תכיל שורה חדשה בסוף השורה. אם אין צורך בכך, ניתן להציב מרכאות סגורות """ ישירות אחרי התג </html>. אם נקרב את המרכאות הסוגרות לשוליים השמאליים, זה ישנה את כמות ההזחה שהוסרה. אם נעביר אותם שני רווחים שמאלה, נוסיף שני רווחים להזחה לכל קו קו. מעבר לקצה השמאלי יגרום לכל הריפוד להישמר. להזזת הציטוטים ימינה יותר לא תהיה השפעה ולא תוסיף עוד הזחה. בלוקי טקסט נכללו ב-JDK 13 כתכונת תצוגה מקדימה. המשמעות היא שהם עדיין לא כלולים במפרט שפת Java התואם. כלומר, לא ברור אם הפיצ'ר הזה יהפוך לחלק קבוע מהשפה או שהוא רק אורח כאן. נכון לעכשיו, מפתחים יכולים לבדוק את התכונה ולהביע את דעתם עליה. גורלם של בלוקי טקסט יהיה תלוי בזה: ניתן לשפר את התכונה, ואם אתה לא אוהב אותה, אז ניתן להסיר אותה לחלוטין. אם אתה רוצה לנסות בלוקים של טקסט בפועל, זכור שתכונות התצוגה המקדימה חייבות להיכלל במפורש כדי להדר ולהפעיל. הַהדָרָה: 

javac --enable-preview --release 13 TextBlock.java
כדי להפעיל את האפליקציה, עליך להפעיל תכונות תצוגה מקדימה: 

java --enable-preview TextBlock
לכיתה Stringיש שלוש שיטות חדשות המשלימות את שינוי השפה הזה:
  • formatted(): עצב מחרוזת באמצעות המחרוזת עצמה כמחרוזת הפורמט. שווה ערך לאתגרformat(this, args)
  • stripIndent(): מסיר רווחים אקראיים ממחרוזת. זה שימושי אם אתה קורא מחרוזות מרובות שורות וברצונך להחיל את אותה אי הכללת רווחים לבנים כפי שהיית עושה בהצהרה מפורשת.
  • translateEscapes(): מחזירה מחרוזת עם רצפי בריחה (כגון \ r), מתורגמת לערך Unicode המתאים.
זה מעניין שהשיטות האלה הופיעו זה עתה, אבל כבר מסומנות כמי שהוצאו משימוש ... מצב עניינים זה מצביע על כך שהן עשויות להיות מוסרות בגרסה עתידית של ה-JDK. זה נראה קצת אקסצנטרי להוסיף שיטה חדשה ולנטוש אותה מיד. עם זאת, שים לב ששיטות אלו משויכות לתכונת תצוגה מקדימה שניתן לשנות או להסיר. אולי הכנסת ביאור @PreviewFeatureתעזור במצבים כאלה, אבל היא עדיין לא נכללת ב-JDK (אם כי בסבירות גבוהה היא תופיע ב-JDK 14).

JEP 354 : Switch Expression (תצוגה מקדימה)

Java 12 הציגה הצעה לצורת כתיבה חדשה של ביטויים עם הצהרת switch - JEP 325 . התברר שזו תכונת התצוגה המקדימה הראשונה וגורלה מוכיח שהגשת הצעות למשתמשים היא רעיון מצוין. לפני JDK 12, switchניתן היה להשתמש בו רק כהצהרה שמבצעת פעולה אך לא מחזירה תוצאה. אבל ב-Java 12 זה אפשר להשתמש בו switchכביטוי שמחזיר תוצאה שניתן להקצות למשתנה. היו שינויים אחרים בתחביר של הצהרות מקרה בתוך switch. בואו נסתכל על דוגמה מ-JEP כדי להבין איך זה עובד. 
int numberOfLetters;
switch(dayOfWeek) {
  case MONDAY:
  case FRIDAY:
  case SUNDAY:
    numberOfLetter = 6;
    break;
  case TUESDAY
    numberOfLetter = 7;
    break;
  case THURSDAY
  case SATURDAY
    numberOfLetter = 8;
    break;
  case WEDNESDAY
    numberOfLetter = 9;
    break;
  default:
   throw new IllegalStateException("Huh?: " + day);
}
בדוגמה זו, אנו משתמשים ב-value dayOfWeekכדי להקצות את הערך ל numberOfLetters. בשל המוזרויות של עבודתו של המפעיל switch, קוד זה אינו היפה ביותר וקל לעשות טעויות. ראשית, אם נשכח להחיל הצהרה breakעל כל קבוצה של תוויות מקרה, ברירת מחדל נעבור לקבוצה הבאה של תוויות מקרה. זה יכול להוביל לשגיאות שקשה למצוא. שנית, עלינו להגדיר כל קבוצה של תוויות מקרים. אם נשכח, אז, כמובן, נקבל שגיאת מהדר, אולם אפשרות זו אינה אידיאלית. הקוד שלנו הוא גם די מילולי מכיוון שלכל ערך dayOfWeekחייב להיות תווית רישיות משלו. באמצעות התחביר החדש, אנו מקבלים קוד הרבה יותר נקי ופחות נוטה לשגיאות: 
int numberOfLetters = switch (dayOfWeek) {
   case MONDAY, FRIDAY, SUNDAY -> 6;
   case TUESDAY -> 7;
   case THURSDAY, SATURDAY -> 8;
   case WEDNESDAY -> 9;
   default -> throw new IllegalStateException("Huh?: " + day);
};
כעת עלינו לבצע את ההקצאה פעם אחת בלבד (מערך ההחזרה של הביטוי switch) ונוכל להשתמש ברשימה מופרדת בפסיקים עבור תוויות המקרים. ומכיוון שאנו לא משתמשים באופרטור break, אנו מבטלים את הבעיות הקשורות אליו. תחביר הביטוי switchמאפשר לנו להשתמש בתחביר בסגנון ישן יותר, אז ב-JDK 12 נוכל לכתוב אותו כך: 
int numberOfLetters = switch (dayOfWeek) {
  case MONDAY:
  case FRIDAY:
  case SUNDAY:
   break 6;
  case TUESDAY
   break 7;
  case THURSDAY
  case SATURDAY
   break 8;
  case WEDNESDAY
   break 9;
  default:
   throw new IllegalStateException("Huh?: " + day);
};
על פי קהילת Java, שימוש בעומס יתר breakכדי לציין ערך החזרה יכול להיות מבלבל. שפת Java גם מאפשרת לך להשתמש break(ו continue) עם תווית כמו אופרטור הקפיצה ללא תנאי goto. JEP 354 שינה את השימוש הזה break, אז ב-Java 13 הקוד שלנו משתנה מעט: 
int numberOfLetters = switch (dayOfWeek) {
  case MONDAY:
  case FRIDAY:
  case SUNDAY:
   yield 6;
  case TUESDAY
   yield 7;
  case THURSDAY
  case SATURDAY
   yield 8;
  case WEDNESDAY
   yield 9;
  default:
   throw new IllegalStateException("Huh?: " + day);
};
שלושת ה-JEP הבאים משויכים ל-Java Virtual Machine.

JEP 350 Dynamic CDS Archive

הרחבה זו מאפשרת לך לאחסן שיעורים באופן דינמי בסוף הפעלת יישום Java. CDS או Class Data Sharing מאפשרים לך לארוז את כל המחלקות שהושקו בעת ההפעלה בארכיון מיוחד class data sharing, תוך שימוש ברשימת אותן מחלקות כברירת מחדל. זה מוביל להאצה משמעותית בהשקת אפליקציות וחיסכון ב-RAM. בעבר, השימוש ב-AppCDS היה תהליך רב-שלבי שכלל יצירת רשימה של מחלקות רלוונטיות ושימוש ברשימה זו ליצירת ארכיון שישמש להרצות הבאות. כעת כל מה שנדרש הוא השקה אחת של האפליקציה עם הדגל -XX: ArchiveClassesAtExitהמציין את המיקום שבו ייכתב הארכיון. עם גישה זו, מחלקות נארזות אוטומטית לארכיון לאחר הפסקת היישום כרגיל.

JEP 351 ZGC : בטל זיכרון שאינו בשימוש

לפני שנה, JDK 11 הציג את ZGC, אספן אשפה ניסיוני, ניתן להרחבה, עם אחזור נמוך. בהתחלה, ZGC התנהג בצורה מוזרה למדי: היא לא אפשרה להחזיר זיכרון למערכת ההפעלה, גם אם כבר לא היה בו צורך. עבור סביבות מסוימות, כגון קונטיינרים, שבהן משתמשים במשאבים על ידי מספר שירותים בו-זמנית, הדבר עשוי להגביל את המדרגיות והיעילות של המערכת. ערימת ה-ZGC מורכבת ממה שנקרא ZPages. כאשר ZPages מנקים במהלך מחזור איסוף האשפה, הם מוחזרים ל-ZPageCache. ה-ZPages במטמון זה מסודרים לפי כמה לאחרונה נעשה בהם שימוש. ב-Java 13, ZGC תחזיר למערכת ההפעלה דפים שזוהו כלא בשימוש במשך זמן רב. כך ניתן לעשות בהם שימוש חוזר לתהליכים אחרים.

JEP 353 יישם מחדש את ה-Socket API מדור קודם

שני יישומי ה-API java.net.Socketהם java.net.ServerSocketעדיין JDK 1.0. ביישום זה, ובכל ה-JDK שלאחר מכן, היישום של ממשקי API אלה משתמש במספר טכניקות (כגון שימוש ב-thread stack כמאגר I/O) שהופכות אותם לבלתי גמישים וקשים לתחזוקה. כדי לפתור בעיה זו, סופק יישום חדש ב-JDK 13 NioSocketImpl. זה כבר לא דורש קוד מקורי, מה שמקל על העברה לפלטפורמות שונות. מחלקה זו משתמשת גם במנגנון ה-buffer cache הקיים (הימנעות משימוש ב-thread stack למטרה זו) ובנעילה java.util.concurrentולא בשיטות מסונכרנות. זה יפשט את האינטגרציה עם סיבים מ- Project Loom .

ממשקי API חדשים

הזכרנו קודם לכן ש-Java 13 כולל 76 ממשקי API חדשים בספריות מחלקות הבסיס. הם מכסים את התחומים הבאים:
  • עדכוני תמיכה ב-Unicode.
  • שלוש שיטות חדשות Stringלתמיכה בלוקי טקסט (ראה תיאור JEP 255 למעלה).
  • לשיעורים java.nioיש כעת מוחלט (בניגוד ליחסי) getו לקבוע שיטות. הם, כמו המחלקה המופשטת הבסיסית Buffer, כוללים שיטה slice()לאחזור חלק מהמאגר.
  • שיטת force()המחלקה MappedByteBufferמאלצת קטע חיץ להיכתב לאחסון הגיבוי שלו.
  • nio.FileSystemמוסיף שלושה טפסים חדשים עמוסים מדי newFileSystem()לגישה לתוכן של קובץ כמערכת קבצים.
  • שיטה מעניינת חדשה הופיעה javax.annotation.processing.ProcessingEnvironment. isPreviewEnabled(). זה יגיד לך אם תכונות התצוגה המקדימה מופעלות. זה מעניין מכיוון שהביאור שהוזכר לעיל @PreviewFeatureלא יהיה זמין עד ש-JDK 14 ישוחרר.
  • DocumentBuilderFactoryוקבל SAXParserFactoryשלוש javax.xml.parsersשיטות חדשות ליצירת מופעים מודעים למרחב שמות.
החומר מבוסס על מאמר מאת סיימון ריטר ותיעוד רשמי .
הערות
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION