ಆರು ತಿಂಗಳ ಅಭಿವೃದ್ಧಿಯ ನಂತರ, Oracle ಜಾವಾ SE 22 (ಜಾವಾ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್, ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಆವೃತ್ತಿ 22) ಅನ್ನು ಬಿಡುಗಡೆ ಮಾಡಿತು, ಇದು ಓಪನ್ ಸೋರ್ಸ್ OpenJDK ಯೋಜನೆಯನ್ನು ಉಲ್ಲೇಖದ ಅನುಷ್ಠಾನವಾಗಿ ಬಳಸುತ್ತದೆ. ಕೆಲವು ಬಳಕೆಯಲ್ಲಿಲ್ಲದ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದನ್ನು ಹೊರತುಪಡಿಸಿ, Java SE 22 ಜಾವಾ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನ ಹಿಂದಿನ ಬಿಡುಗಡೆಗಳೊಂದಿಗೆ ಹಿಂದುಳಿದ ಹೊಂದಾಣಿಕೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ - ಹೊಸ ಆವೃತ್ತಿಯ ಅಡಿಯಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ಹೆಚ್ಚಿನ ಹಿಂದೆ ಬರೆದ ಜಾವಾ ಯೋಜನೆಗಳು ಬದಲಾವಣೆಗಳಿಲ್ಲದೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ಲಿನಕ್ಸ್ (x22_86, AArch64), Windows (x64_86) ಮತ್ತು macOS (x64_86, AArch64) ಗಾಗಿ Java SE 64 (JDK, JRE ಮತ್ತು ಸರ್ವರ್ JRE) ನ ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಲು ಸಿದ್ಧವಾಗಿದೆ. OpenJDK ಯೋಜನೆಯಿಂದ ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗಿದೆ, ಜಾವಾ 22 ಉಲ್ಲೇಖದ ಅನುಷ್ಠಾನವು GPLv2 ಪರವಾನಗಿ ಅಡಿಯಲ್ಲಿ ಸಂಪೂರ್ಣವಾಗಿ ಮುಕ್ತ ಮೂಲವಾಗಿದೆ, GNU ClassPath ವಿನಾಯಿತಿಗಳೊಂದಿಗೆ ವಾಣಿಜ್ಯ ಉತ್ಪನ್ನಗಳೊಂದಿಗೆ ಡೈನಾಮಿಕ್ ಲಿಂಕ್ ಅನ್ನು ಅನುಮತಿಸುತ್ತದೆ.
Java SE 22 ಅನ್ನು ಸಾಮಾನ್ಯ ಬೆಂಬಲ ಬಿಡುಗಡೆ ಎಂದು ವರ್ಗೀಕರಿಸಲಾಗಿದೆ ಮತ್ತು ಮುಂದಿನ ಬಿಡುಗಡೆಯವರೆಗೂ ನವೀಕರಣಗಳನ್ನು ಸ್ವೀಕರಿಸುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತದೆ. ದೀರ್ಘಾವಧಿಯ ಬೆಂಬಲ (LTS) ಶಾಖೆಯು Java SE 21 ಅಥವಾ Java SE 17 ಆಗಿರಬೇಕು, ಇದು ಕ್ರಮವಾಗಿ 2031 ಮತ್ತು 2029 ರವರೆಗೆ ನವೀಕರಣಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ (ಸಾಮಾನ್ಯವಾಗಿ 2028 ಮತ್ತು 2026 ರವರೆಗೆ ಲಭ್ಯವಿದೆ). Java SE 11 ನ LTS ಶಾಖೆಗೆ ಸಾರ್ವಜನಿಕ ಬೆಂಬಲವು ಕಳೆದ ಸೆಪ್ಟೆಂಬರ್‌ನಲ್ಲಿ ಕೊನೆಗೊಂಡಿತು, ಆದರೆ ವಿಸ್ತೃತ ಬೆಂಬಲವು 2032 ರವರೆಗೆ ಮುಂದುವರಿಯುತ್ತದೆ. Java SE 8 ನ LTS ಶಾಖೆಗೆ ವಿಸ್ತೃತ ಬೆಂಬಲವು 2030 ರವರೆಗೆ ಮುಂದುವರಿಯುತ್ತದೆ.
ಜಾವಾ 10 ರ ಬಿಡುಗಡೆಯಿಂದ ಪ್ರಾರಂಭಿಸಿ, ಯೋಜನೆಯು ಹೊಸ ಅಭಿವೃದ್ಧಿ ಪ್ರಕ್ರಿಯೆಗೆ ಬದಲಾಯಿತು, ಹೊಸ ಬಿಡುಗಡೆಗಳ ರಚನೆಗೆ ಕಡಿಮೆ ಚಕ್ರವನ್ನು ಸೂಚಿಸುತ್ತದೆ ಎಂದು ನಾವು ನಿಮಗೆ ನೆನಪಿಸೋಣ. ಹೊಸ ಕಾರ್ಯವನ್ನು ಈಗ ನಿರಂತರವಾಗಿ ನವೀಕರಿಸಿದ ಮಾಸ್ಟರ್ ಶಾಖೆಯಲ್ಲಿ ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗಿದೆ, ಇದು ಸಿದ್ಧ ಬದಲಾವಣೆಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ ಮತ್ತು ಹೊಸ ಬಿಡುಗಡೆಗಳನ್ನು ಸ್ಥಿರಗೊಳಿಸಲು ಪ್ರತಿ ಆರು ತಿಂಗಳಿಗೊಮ್ಮೆ ಶಾಖೆಗಳನ್ನು ಶಾಖೆ ಮಾಡಲಾಗುತ್ತದೆ.
Java 22 ನಲ್ಲಿನ ಹೊಸ ವೈಶಿಷ್ಟ್ಯಗಳು ಸೇರಿವೆ:
- G1 ಕಸ ಸಂಗ್ರಾಹಕವು ಪ್ರದೇಶ ಪಿನ್ನಿಂಗ್‌ಗೆ ಬೆಂಬಲವನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಇದು ಕಸ ಸಂಗ್ರಾಹಕರಿಂದ ಅವುಗಳನ್ನು ಸರಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ಮತ್ತು ಜಾವಾ ಮತ್ತು ಸ್ಥಳೀಯ ಕೋಡ್ ನಡುವೆ ಈ ವಸ್ತುಗಳ ಉಲ್ಲೇಖಗಳನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ರವಾನಿಸಲು ಅನುಮತಿಸಲು ಮೆಮೊರಿಯಲ್ಲಿ ಜಾವಾ ವಸ್ತುಗಳ ಸ್ಥಳವನ್ನು ತಾತ್ಕಾಲಿಕವಾಗಿ ಸರಿಪಡಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಸ್ಥಳೀಯ ಕೋಡ್‌ನೊಂದಿಗೆ JNI (ಜಾವಾ ಸ್ಥಳೀಯ ಇಂಟರ್ಫೇಸ್) ನ ನಿರ್ಣಾಯಕ ಪ್ರದೇಶಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ ಸುಪ್ತತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಮತ್ತು ಕಸ ಸಂಗ್ರಹವನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ಪಿನ್ನಿಂಗ್ ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ (ಈ ವಿಭಾಗಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ, ಜನಾಂಗದ ಪರಿಸ್ಥಿತಿಗಳನ್ನು ತಪ್ಪಿಸಲು JVM ಅವುಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ನಿರ್ಣಾಯಕ ವಸ್ತುಗಳನ್ನು ಚಲಿಸಬಾರದು). ಪಿನ್ನಿಂಗ್ ಕಸ ಸಂಗ್ರಾಹಕನ ನೋಟದಿಂದ ನಿರ್ಣಾಯಕ ವಸ್ತುಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ, ಇದು ಅನ್ಪಿನ್ ಮಾಡದ ಪ್ರದೇಶಗಳನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸಲು ಮುಂದುವರಿಯುತ್ತದೆ.
- ಸೂಪರ್(...) ಎಂದು ಕರೆಯುವ ಮೊದಲು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗಳಲ್ಲಿ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಒಂದು ಪ್ರಾಥಮಿಕ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಸೇರಿಸಲಾಗಿದೆ, ಆ ಅಭಿವ್ಯಕ್ತಿಗಳು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ರಚಿಸಿದ ನಿದರ್ಶನವನ್ನು ಉಲ್ಲೇಖಿಸದಿದ್ದರೆ ಆನುವಂಶಿಕ ವರ್ಗದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನಿಂದ ಪೋಷಕ ವರ್ಗದ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಕರೆಯಲು ಬಳಸಲಾಗುತ್ತದೆ. ಕ್ಲಾಸ್ ಔಟರ್ {ಶೂನ್ಯ ಹಲೋ() { System.out.println("ಹಲೋ"); } ವರ್ಗ ಒಳ {ಒಳ() {ಹಲೋ(); ಚೆನ್ನಾಗಿದೆ(); } } }
- FFM (ವಿದೇಶಿ ಕಾರ್ಯ ಮತ್ತು ಮೆಮೊರಿ) API ಅನ್ನು ಸ್ಥಿರಗೊಳಿಸಲಾಗಿದೆ, ಬಾಹ್ಯ ಲೈಬ್ರರಿಗಳಿಂದ ಕಾರ್ಯಗಳನ್ನು ಕರೆ ಮಾಡುವ ಮೂಲಕ ಮತ್ತು JNI (ಜಾವಾ ಸ್ಥಳೀಯ ಇಂಟರ್ಫೇಸ್) ಅನ್ನು ಬಳಸದೆಯೇ JVM ನ ಹೊರಗೆ ಮೆಮೊರಿಯನ್ನು ಪ್ರವೇಶಿಸುವ ಮೂಲಕ ಬಾಹ್ಯ ಕೋಡ್ ಮತ್ತು ಡೇಟಾದೊಂದಿಗೆ ಜಾವಾ ಕಾರ್ಯಕ್ರಮಗಳ ಪರಸ್ಪರ ಕ್ರಿಯೆಯನ್ನು ಅನುಮತಿಸುತ್ತದೆ.
- ಹೆಸರಿಸದ ವೇರಿಯಬಲ್‌ಗಳು ಮತ್ತು ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚಿಂಗ್‌ಗೆ ಬೆಂಬಲವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆ - ಬಳಕೆಯಾಗದ ಆದರೆ ಅಗತ್ಯವಿರುವ ವೇರಿಯಬಲ್‌ಗಳು ಮತ್ತು ಪ್ಯಾಟರ್ನ್‌ಗಳ ಬದಲಿಗೆ, ನೀವು ಈಗ “_” ಅಕ್ಷರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು. // was String pageName = ಸ್ವಿಚ್ (ಪುಟ) {case GitHubIssuePage(var url, var ವಿಷಯ, var ಲಿಂಕ್‌ಗಳು, int issueNumber) -> “ISSUE #” + issueNumber; ...}; // ಈಗ ನೀವು String pageName = ಬದಲಾಯಿಸಬಹುದು (ಪುಟ) {case GitHubIssuePage(_, _, _, int issueNumber) -> “ISSUE #” + issueNumber; };
- ಜಾವಾ ಕ್ಲಾಸ್ ಫೈಲ್‌ಗಳನ್ನು ಪಾರ್ಸಿಂಗ್ ಮಾಡಲು, ಉತ್ಪಾದಿಸಲು ಮತ್ತು ಪರಿವರ್ತಿಸಲು ಕ್ಲಾಸ್-ಫೈಲ್ API ನ ಪ್ರಾಥಮಿಕ ಅನುಷ್ಠಾನವನ್ನು ಪ್ರಸ್ತಾಪಿಸಲಾಗಿದೆ. ClassFile cf = ClassFile.of(); ClassModel classModel = cf.parse(bytes); byte[] newBytes = cf.build(classModel.thisClass().asSymbol(), classBuilder -> { for (ClassElement ce : classModel) { if (!(ce instance of MethodModel mm && mm.methodName().stringValue(). startsWith("debug"))) { classBuilder.with(ce);
- ಜಾವಾ ಉಪಯುಕ್ತತೆಯು ಈ ಫೈಲ್‌ಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಕಂಪೈಲ್ ಮಾಡದೆ ಮತ್ತು ಬಿಲ್ಡ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡದೆಯೇ ಹಲವಾರು ಕೋಡ್ ಫೈಲ್‌ಗಳು ಅಥವಾ ಪ್ರಿಕಂಪೈಲ್ಡ್ ಕ್ಲಾಸ್ ಲೈಬ್ರರಿಗಳ ರೂಪದಲ್ಲಿ ಒದಗಿಸಲಾದ ಜಾವಾ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಚಲಾಯಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಹೊಸ ವೈಶಿಷ್ಟ್ಯವು ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಚಲಾಯಿಸಲು ಸುಲಭಗೊಳಿಸುತ್ತದೆ, ಇದರಲ್ಲಿ ವಿವಿಧ ವರ್ಗಗಳ ಕೋಡ್ ಅನ್ನು ಪ್ರತ್ಯೇಕ ಫೈಲ್ಗಳಾಗಿ ವಿಂಗಡಿಸಲಾಗಿದೆ. Prog.java: ವರ್ಗ ಪ್ರೋಗ್ {ಸಾರ್ವಜನಿಕ ಸ್ಥಾಯೀ ಶೂನ್ಯ ಮುಖ್ಯ(ಸ್ಟ್ರಿಂಗ್[] ಆರ್ಗ್ಸ್) {Helper.run(); } } Helper.java: ವರ್ಗ ಸಹಾಯಕ {ಸ್ಥಿರ ಶೂನ್ಯ ರನ್() { System.out.println("Hello!"); } }
ಉದಾಹರಣೆಗೆ, "Prog.java" ಮತ್ತು "Helper.java" ಎಂಬ ಎರಡು ಫೈಲ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸಲು ಈಗ "java Prog.java" ಅನ್ನು ಚಲಾಯಿಸಲು ಸಾಕು, ಇದು ಪ್ರೋಗ್ ವರ್ಗವನ್ನು ಕಂಪೈಲ್ ಮಾಡುತ್ತದೆ, ಸಹಾಯಕ ವರ್ಗಕ್ಕೆ ಉಲ್ಲೇಖವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಹೆಲ್ಪರ್ ಫೈಲ್ ಅನ್ನು ಹುಡುಕಿ ಮತ್ತು ಕಂಪೈಲ್ ಮಾಡಿ ಮತ್ತು ಮುಖ್ಯ ವಿಧಾನವನ್ನು ಕರೆಯುವುದು.
- ಸ್ಟ್ರಿಂಗ್ ಟೆಂಪ್ಲೇಟ್‌ಗಳ ಎರಡನೇ ಪ್ರಾಥಮಿಕ ಅನುಷ್ಠಾನವನ್ನು ಸೇರಿಸಲಾಗಿದೆ, ಸ್ಟ್ರಿಂಗ್ ಲಿಟರಲ್ಸ್ ಮತ್ತು ಟೆಕ್ಸ್ಟ್ ಬ್ಲಾಕ್‌ಗಳ ಜೊತೆಗೆ ಅಳವಡಿಸಲಾಗಿದೆ. ಸ್ಟ್ರಿಂಗ್ ಟೆಂಪ್ಲೇಟ್‌ಗಳು + ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸದೆಯೇ ಲೆಕ್ಕ ಹಾಕಿದ ಅಭಿವ್ಯಕ್ತಿಗಳು ಮತ್ತು ಅಸ್ಥಿರಗಳೊಂದಿಗೆ ಪಠ್ಯವನ್ನು ಸಂಯೋಜಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಅಭಿವ್ಯಕ್ತಿಗಳ ಪರ್ಯಾಯವನ್ನು ಪರ್ಯಾಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಕೈಗೊಳ್ಳಲಾಗುತ್ತದೆ \{..}, ಮತ್ತು ಬದಲಿ ಮೌಲ್ಯಗಳ ಸರಿಯಾದತೆಯನ್ನು ಪರಿಶೀಲಿಸಲು ವಿಶೇಷ ನಿರ್ವಾಹಕರನ್ನು ಸಂಪರ್ಕಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, SQL ಇಂಜಿನ್ SQL ಕೋಡ್‌ಗೆ ಪರ್ಯಾಯವಾಗಿರುವ ಮೌಲ್ಯಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು java.sql. ಸ್ಟೇಟ್‌ಮೆಂಟ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಔಟ್‌ಪುಟ್ ಆಗಿ ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಆದರೆ JSON ಪ್ರೊಸೆಸರ್ JSON ಪರ್ಯಾಯಗಳ ಸರಿಯಾದತೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುತ್ತದೆ ಮತ್ತು JsonNode ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಸ್ಟ್ರಿಂಗ್ ಪ್ರಶ್ನೆ = "ಆಯ್ಕೆ * ವ್ಯಕ್ತಿಯಿಂದ p ಎಲ್ಲಿ p." + ಆಸ್ತಿ + " = '" + ಮೌಲ್ಯ + "'"; // ಆಗಿತ್ತು ಹೇಳಿಕೆ ಪ್ರಶ್ನೆ = SQL."""ಆಯ್ಕೆ * ವ್ಯಕ್ತಿಯಿಂದ p ಎಲ್ಲಿ p.\{property} = '\{value}'"""; // ಆಯಿತು
- ವೆಕ್ಟರ್ API ಯ ಏಳನೇ ಪೂರ್ವವೀಕ್ಷಣೆಯನ್ನು ಸೇರಿಸಲಾಗಿದೆ, x86_64 ಮತ್ತು AArch64 ಪ್ರೊಸೆಸರ್‌ಗಳಲ್ಲಿ ವೆಕ್ಟರ್ ಸೂಚನೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಿರ್ವಹಿಸುವ ವೆಕ್ಟರ್ ಲೆಕ್ಕಾಚಾರಗಳಿಗೆ ಕಾರ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ ಮತ್ತು ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಬಹು ಮೌಲ್ಯಗಳಿಗೆ (SIMD) ಏಕಕಾಲದಲ್ಲಿ ಅನ್ವಯಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಸ್ಕೇಲಾರ್ ಕಾರ್ಯಾಚರಣೆಗಳ ಸ್ವಯಂ-ವೆಕ್ಟರೈಸೇಶನ್‌ಗಾಗಿ ಹಾಟ್‌ಸ್ಪಾಟ್ ಜೆಐಟಿ ಕಂಪೈಲರ್‌ನಲ್ಲಿ ಒದಗಿಸಲಾದ ಸಾಮರ್ಥ್ಯಗಳಿಗಿಂತ ಭಿನ್ನವಾಗಿ, ಹೊಸ API ಸಮಾನಾಂತರ ಡೇಟಾ ಪ್ರಕ್ರಿಯೆಗಾಗಿ ವೆಕ್ಟರೈಸೇಶನ್ ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ನಿಯಂತ್ರಿಸಲು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ.
- ವಿಸ್ತೃತ ಸ್ಟ್ರೀಮ್ API ಯ ಪ್ರಾಥಮಿಕ ಅನುಷ್ಠಾನವನ್ನು ಸೇರಿಸಲಾಗಿದೆ, ಅದು ನಿಮ್ಮ ಸ್ವಂತ ಮಧ್ಯಂತರ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಬೆಂಬಲಿಸುತ್ತದೆ, ಅಪೇಕ್ಷಿತ ಡೇಟಾ ರೂಪಾಂತರಕ್ಕೆ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಅಂತರ್ನಿರ್ಮಿತ ಮಧ್ಯಂತರ ಕಾರ್ಯಾಚರಣೆಗಳು ಸಾಕಾಗದೇ ಇರುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಇದು ಉಪಯುಕ್ತವಾಗಿರುತ್ತದೆ. ಸ್ಥಳೀಯ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳನ್ನು ಹೊಸ ಮಧ್ಯಂತರ ಕಾರ್ಯಾಚರಣೆ ಸ್ಟ್ರೀಮ್ ಬಳಸಿ ಸಂಪರ್ಕಿಸಲಾಗಿದೆ::ಗ್ಯಾದರ್ (ಗ್ಯಾಥರರ್), ಇದು ಬಳಕೆದಾರ-ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಅನ್ವಯಿಸುವ ಮೂಲಕ ಸ್ಟ್ರೀಮ್ ಅಂಶಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ. jshell> Stream.of(1,2,3,4,5,6,7,8,9).gather(new WindowFixed(3)).toList() $1 ==> [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
- ಸ್ಟ್ರಕ್ಚರ್ಡ್ ಕನ್‌ಕರೆನ್ಸಿಗಾಗಿ ಪ್ರಾಯೋಗಿಕ API ಯ ಎರಡನೇ ಆವೃತ್ತಿಯನ್ನು ಪರೀಕ್ಷೆಗಾಗಿ ಪ್ರಸ್ತಾಪಿಸಲಾಗಿದೆ, ಇದು ಒಂದೇ ಬ್ಲಾಕ್‌ನಂತೆ ವಿವಿಧ ಥ್ರೆಡ್‌ಗಳಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾದ ಬಹು ಕಾರ್ಯಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಮೂಲಕ ಬಹು-ಥ್ರೆಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಅಭಿವೃದ್ಧಿಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.
- "ಮುಖ್ಯ" ವಿಧಾನದ ಸೂಚ್ಯವಾಗಿ ಘೋಷಿತ ತರಗತಿಗಳು ಮತ್ತು ಹೆಸರಿಸದ ನಿದರ್ಶನಗಳ ಎರಡನೇ ಪೂರ್ವಭಾವಿ ಅನುಷ್ಠಾನವನ್ನು ಸೇರಿಸಲಾಗಿದೆ, ಇದು ಸಾರ್ವಜನಿಕ/ಸ್ಥಿರ ಘೋಷಣೆಗಳು, ವಾದಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರವಾನಿಸುವುದು ಮತ್ತು ವರ್ಗ ಘೋಷಣೆಗೆ ಸಂಬಂಧಿಸಿದ ಇತರ ಘಟಕಗಳನ್ನು ತ್ಯಜಿಸಬಹುದು. // ಸಾರ್ವಜನಿಕ ವರ್ಗ HelloWorld {ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಶೂನ್ಯ ಮುಖ್ಯ (ಸ್ಟ್ರಿಂಗ್[] args) { System.out.println("ಹಲೋ ವರ್ಲ್ಡ್!"); } } // ಈಗ ನೀವು ಮುಖ್ಯ() ಅನ್ನು ಅನೂರ್ಜಿತಗೊಳಿಸಬಹುದು { System.out.println("ಹಲೋ, ವರ್ಲ್ಡ್!"); }
- ಸ್ಕೋಪ್ಡ್ ಮೌಲ್ಯಗಳ ಎರಡನೇ ಪೂರ್ವವೀಕ್ಷಣೆ ಅನುಷ್ಠಾನವನ್ನು ಸೇರಿಸಲಾಗಿದೆ, ಥ್ರೆಡ್‌ಗಳಾದ್ಯಂತ ಬದಲಾಯಿಸಲಾಗದ ಡೇಟಾವನ್ನು ಹಂಚಿಕೊಳ್ಳಲು ಮತ್ತು ಚೈಲ್ಡ್ ಥ್ರೆಡ್‌ಗಳ ನಡುವೆ ಡೇಟಾವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ವಿನಿಮಯ ಮಾಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ (ಮೌಲ್ಯಗಳು ಆನುವಂಶಿಕವಾಗಿರುತ್ತವೆ). ಥ್ರೆಡ್-ಸ್ಥಳೀಯ ಅಸ್ಥಿರ ಕಾರ್ಯವಿಧಾನವನ್ನು ಬದಲಿಸಲು ಸ್ಕೋಪ್ಡ್ ಮೌಲ್ಯಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗುತ್ತಿದೆ ಮತ್ತು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ವರ್ಚುವಲ್ ಥ್ರೆಡ್‌ಗಳನ್ನು (ಸಾವಿರಾರು ಅಥವಾ ಮಿಲಿಯನ್ ಥ್ರೆಡ್‌ಗಳು) ಬಳಸುವಾಗ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿರುತ್ತದೆ. ಸ್ಕೋಪ್ಡ್ ಮೌಲ್ಯಗಳು ಮತ್ತು ಥ್ರೆಡ್-ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳ ನಡುವಿನ ಪ್ರಮುಖ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಹಿಂದಿನದನ್ನು ಒಮ್ಮೆ ಬರೆಯಲಾಗುತ್ತದೆ, ಭವಿಷ್ಯದಲ್ಲಿ ಬದಲಾಯಿಸಲಾಗುವುದಿಲ್ಲ ಮತ್ತು ಥ್ರೆಡ್ನ ಮರಣದಂಡನೆಯ ಅವಧಿಗೆ ಮಾತ್ರ ಲಭ್ಯವಿರುತ್ತದೆ.
- ದೊಡ್ಡ ಶ್ರೇಣಿಯ ವಸ್ತುಗಳ ಜೊತೆ ಕೆಲಸ ಮಾಡುವಾಗ ಸಮಾನಾಂತರ ಕಸ ಸಂಗ್ರಾಹಕವು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಿದೆ. ಆಪ್ಟಿಮೈಸೇಶನ್ ಕೆಲವು ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ವಸ್ತುವಿನ ದೊಡ್ಡ ಶ್ರೇಣಿಗಳೊಂದಿಗೆ ವಸ್ತುವನ್ನು 20% ರಷ್ಟು ಹುಡುಕಲು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ವಿಳಂಬವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಸಾಧ್ಯವಾಗಿಸಿತು.
ಹೆಚ್ಚುವರಿಯಾಗಿ, ಗ್ರಾಫಿಕಲ್ ಇಂಟರ್ಫೇಸ್ JavaFX 22 ನೊಂದಿಗೆ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಲು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗೆ ನವೀಕರಣದ ಪ್ರಕಟಣೆಯನ್ನು ನೀವು ಗಮನಿಸಬಹುದು.
ಮೂಲ: opennet.ru