Systematische Erläuterung der neuen Funktionen des JDK von Version 1.5 bis 1.9 zum einfachen Vergleich

Beim Erlernen der Grundlagen von Java habe ich die neuen Funktionen von JDK von Version 1.5 bis 1.9 zusammengefasst. Sie können sie entsprechend Ihren Anforderungen auswählen kann jedem helfen. Apache PHP MySQL

Neue Funktionen von jdk1.5:

1. ArrayList list=new ArrayList( ) ------>ArrayListc0f559cc8d56b43654fcbe4aa9df7b4alist=new ArrayListc0f559cc8d56b43654fcbe4aa9df7b4a();
2 Autoboxing/Unboxing
nt i=list.get(0).parseInt(); ---- ---->int i=list.get(0); Es ist keine explizite Konvertierung zwischen dem Originaltyp und der entsprechenden Wrapper-Klasse erforderlich
3 for-each
i=0;ic2f78498fd7a67ccfd1422d3c5edcc07for(int i:a){......}
4 static import
Math.sqrt();- --- ----------->sqrt();
5 Parameter variabler Länge
int sum(int ...intlist) hat eine beliebige Anzahl von Parametern, behandeln Sie es als Array
🎜 = 0; >Summe + = Zahl;
2. Überwachung und VerwaltungJava SE 6 verfügt über verbesserte Analyse- und Diagnosefunktionen für Speicherlecks. Wenn Sie auf eine java.lang.OutOfMemory-Ausnahme stoßen, können Sie vollständige Stack-Informationen abrufen, und wenn der Heap voll ist, wird eine Protokolldatei generiert, um diesen schwerwiegenden Fehler aufzuzeichnen. Darüber hinaus hat die JVM eine Option hinzugefügt, die es Ihnen ermöglicht, Skripte auszuführen, wenn der Heap voll ist. 3. Plug-in-AnmerkungsverarbeitungPlug-in-Anmerkungsverarbeitungs-API (JSR 269) bietet eine Reihe von Standard-APIs zur Verarbeitung von Anmerkungen


Neu in jdk1 .7 Funktionen:


1. Modulare Funktionen
Java7 nutzt auch die Modulteilung, um die Geschwindigkeit zu erhöhen. Wenn die virtuelle Maschine sie benötigt, werden sie heruntergeladen . Das entsprechende Modul
verbessert auch die Startgeschwindigkeit erheblich.
2. Mehrsprachige Unterstützung
Die virtuelle Java7-Maschine bietet Unterstützung für eine Vielzahl dynamischer Programmiersprachen, wie zum Beispiel: Ruby, Python usw.
3. Die Entwicklungseffizienz der Entwickler wurde verbessert
Strings können im Switch verwendet werden
In Bezug auf Multi-Thread-Parallelität und -Kontrolle: leichtes Trennungs- und Zusammenführungs-Framework, eine HashMap, die gleichzeitigen Zugriff unterstützt usw.
Verbessern Sie die statische Überprüfung von Programmen durch Anmerkungen.
Bietet einige neue APIs für Dateisystemzugriff, asynchrone Eingabe- und Ausgabevorgänge, Socket-Kanalkonfiguration und -bindung, Mehrpunkt-Datenpaketübertragung usw. 4. Verbesserung der Ausführungseffizienz Die Technologie zum Komprimieren von Objektzeigern von 64-Bit auf passende 32-Bit-Zeiger reduziert den Verbrauch von Speicher und Speicherblöcken erheblich und verbessert dadurch die Ausführungseffizienz. Bietet einen neuen Garbage-Collection-Mechanismus (G1), um die Last der Garbage-Collection zu reduzieren und die Wirkung der Garbage-Collection zu verstärken.

Neue Funktionen von JDK1.8:
1. Standardmethode der Schnittstelle
Java 8 ermöglicht es uns, der Schnittstelle eine nicht abstrakte Methodenimplementierung hinzuzufügen. Verwenden Sie einfach das Standardschlüsselwort. Diese Funktion wird auch als Erweiterungsmethode bezeichnet.
2. Lambda-Ausdruck
In Java 8 müssen Sie diese traditionelle Methode für anonyme Objekte nicht mehr verwenden. Java 8 bietet eine prägnantere Syntax, den Lambda-Ausdruck:
Collections.sort( Namen, (String a, String b) -> {
return b.compareTo(a);
});
3. Funktionsschnittstelle
Wie sind Lambda-Ausdrücke Typen in Java? Was wird im System dargestellt? Jeder Lambda-Ausdruck entspricht einem Typ, normalerweise einem Schnittstellentyp. „Funktionale Schnittstelle“ bezieht sich auf eine Schnittstelle, die nur eine abstrakte Methode enthält. Jeder Lambda-Ausdruck dieses Typs wird dieser abstrakten Methode zugeordnet. Da Standardmethoden nicht als abstrakte Methoden gelten, können Sie Ihrer funktionalen Schnittstelle auch Standardmethoden hinzufügen.
4. Methoden- und Konstruktorreferenzen
In Java 8 können Sie das Schlüsselwort :: verwenden, um Methoden- oder Konstruktorreferenzen zu übergeben. Wir können auch auf die Methode eines Objekts verweisen.
converter = Something::startsWith;
String Converted = Converter.convert("Java");
System.out.println(converted);
5. Lambda-Bereich
im Lambda-Zugriff Der äußere Bereich in Ausdrücken ähnelt dem in älteren Versionen anonymer Objekte. Sie können direkt auf äußere lokale Variablen zugreifen, die als „final“ gekennzeichnet sind, oder auf Instanzfelder und statische Variablen.
6. Auf lokale Variablen zugreifen
Sie können direkt auf äußere lokale Variablen in Lambda-Ausdrücken zugreifen:
7. Auf Objektfelder und statische Variablen zugreifen
Der Unterschied zu lokalen Variablen besteht darin, dass die Instanz innerhalb von Lambda-Feldern und statisch ist Variablen sind sowohl lesbar als auch beschreibbar. Dieses Verhalten stimmt mit anonymen Objekten überein:
8. Standardmethode für den Zugriff auf die Schnittstelle
Die JDK 1.8-API enthält viele integrierte Funktionsschnittstellen, wie z. B. Comparator- oder Runnable-Schnittstellen, die häufig in altem Java verwendet werden Die Annotation @FunctionalInterface wurde hinzugefügt, damit sie für Lambdas verwendet werden kann.
Java 8 API bietet auch viele neue funktionale Schnittstellen, um die Arbeit komfortabler zu gestalten. Auch wenn Sie mit diesen vertraut sind, müssen Sie dennoch sehen, wie diese auf Lambda erweitert werden können .

Neue Funktionen von JDK1.9

Java 7 wurde 2011 veröffentlicht, Java 8 wurde 2014 veröffentlicht und Java9 wurde am 21. September 2017 veröffentlicht. Sie haben vielleicht schon vom Modulsystem von Java 9 gehört, aber diese neue Version enthält noch viele weitere Updates. Hier sind neun aufregende neue Funktionen, die mit Java 9 kommen.

1. Java-Modulsystem auf Plattformebene

Das bestimmende Merkmal von Java 9 ist ein brandneues Modulsystem. Mit zunehmender Codebasis steigt die Wahrscheinlichkeit, komplexen, verschachtelten „Spaghetti-Code“ zu erstellen, exponentiell. Zu diesem Zeitpunkt müssen Sie sich zwei grundlegenden Problemen stellen: Es ist schwierig, den Code wirklich zu kapseln, und das System verfügt über kein klares Konzept für die Abhängigkeiten zwischen verschiedenen Teilen (d. h. JAR-Dateien). Auf jede öffentliche Klasse kann von jeder anderen öffentlichen Klasse im Klassenpfad zugegriffen werden, was zur unbeabsichtigten Verwendung von APIs führen kann, die nicht für den öffentlichen Zugriff vorgesehen sind. Darüber hinaus gibt es Probleme mit dem Klassenpfad selbst: Woher wissen Sie, dass alle erforderlichen JARs bereits vorhanden sind oder ob doppelte Einträge vorhanden sind? Das Modulsystem löst beide Probleme.

Modulare JAR-Dateien enthalten einen zusätzlichen Moduldeskriptor. In diesem Moduldeskriptor werden Abhängigkeiten zu anderen Modulen durch „requires“ ausgedrückt. Darüber hinaus steuert die „exports“-Anweisung, auf welche Pakete andere Module zugreifen können. Alle Pakete, die nicht exportiert werden, sind standardmäßig in Modulen gekapselt. Das Folgende ist ein Beispiel für einen Moduldeskriptor, der in der Datei „module-info.java“ vorhanden ist:

module
blog {
  
exports
com.pluralsight.blog;
 
  
requires
cms;
}

Wir können das Modul wie folgt anzeigen:

Bitte beachten Sie, dass beide Module gekapselte Pakete enthalten, da diese nicht exportiert werden (angezeigt durch ein orangefarbenes Schild). Niemand verwendet versehentlich Klassen aus diesen Paketen. Auch die Java-Plattform selbst ist über ein eigenes Modulsystem modularisiert. Durch die Kapselung der internen Klassen des JDK ist die Plattform sicherer und eine kontinuierliche Verbesserung ist einfacher.

Beim Starten einer modularen Anwendung überprüft die JVM anhand der „requires“-Anweisung, ob alle Module verfügbar sind – ein großer Fortschritt gegenüber dem fragilen Klassenpfad. Mithilfe von Modulen können Sie die strukturelle Kapselung Ihrer Anwendung besser durchsetzen und Abhängigkeiten explizit machen. In diesem Kurs erfahren Sie mehr über die Arbeit mit Modulen in Java 9.

2. Linking

当你使用具有显式依赖关系的模块和模块化的 JDK 时，新的可能性出现了。你的应用程序模块现在将声明其对其他应用程序模块的依赖以及对其所使用的 JDK 模块的依赖。为什么不使用这些信息创建一个最小的运行时环境，其中只包含运行应用程序所需的那些模块呢？ 这可以通过 Java 9 中的新的 jlink 工具实现。你可以创建针对应用程序进行优化的最小运行时映像而不需要使用完全加载 JDK 安装版本。

3. JShell : 交互式 Java REPL

许多语言已经具有交互式编程环境，Java 现在加入了这个俱乐部。您可以从控制台启动 jshell ，并直接启动输入和执行 Java 代码。 jshell 的即时反馈使它成为探索 API 和尝试语言特性的好工具。

测试一个 Java 正则表达式是一个很好的说明 jshell 如何使您的生活更轻松的例子。 交互式 shell 还可以提供良好的教学环境以及提高生产力，您可以在此了解更多信息。在教人们如何编写 Java 的过程中，不再需要解释 “public static void main（String [] args）” 这句废话。

4. 改进的 Javadoc

有时一些小事情可以带来很大的不同。你是否就像我一样在一直使用 Google 来查找正确的 Javadoc 页面呢？ 这不再需要了。Javadoc 现在支持在 API 文档中的进行搜索。另外，Javadoc 的输出现在符合兼容 HTML5 标准。此外，你会注意到，每个 Javadoc 页面都包含有关 JDK 模块类或接口来源的信息。

5. 集合工厂方法

通常，您希望在代码中创建一个集合（例如，List 或 Set ），并直接用一些元素填充它。 实例化集合，几个 “add” 调用，使得代码重复。 Java 9，添加了几种集合工厂方法：

Set<Integer>
ints = Set.of(
1
,
2
,
3
);
List<String>
strings = List.of(
"first"
,
"second"
);

除了更短和更好阅读之外，这些方法也可以避免您选择特定的集合实现。 事实上，从工厂方法返回已放入数个元素的集合实现是高度优化的。这是可能的，因为它们是不可变的：在创建后，继续添加元素到这些集合会导致 “UnsupportedOperationException” 。

6. 改进的 Stream API

长期以来，Stream API 都是 Java 标准库最好的改进之一。通过这套 API 可以在集合上建立用于转换的申明管道。在 Java 9 中它会变得更好。Stream 接口中添加了 4 个新的方法：dropWhile, takeWhile, ofNullable。还有个 iterate 方法的新重载方法，可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代：

IntStream.iterate(
1
,
i -> i <
100
,
i -> i +
1
).forEach(System.out::println);

第二个参数是一个 Lambda，它会在当前 IntStream 中的元素到达 100 的时候返回 true。因此这个简单的示例是向控制台打印 1 到 99。

除了对 Stream 本身的扩展，Optional 和 Stream 之间的结合也得到了改进。现在可以通过 Optional 的新方法 `stram` 将一个 Optional 对象转换为一个(可能是空的) Stream 对象：

Stream<Integer>
s = Optional.of(
1
).stream();

在组合复杂的 Stream 管道时，将 Optional 转换为 Stream 非常有用。

7. 私有接口方法

Java 8 为我们带来了接口的默认方法。 接口现在也可以包含行为，而不仅仅是方法签名。 但是，如果在接口上有几个默认方法，代码几乎相同，会发生什么情况？ 通常，您将重构这些方法，调用一个可复用的私有方法。 但默认方法不能是私有的。 将复用代码创建为一个默认方法不是一个解决方案，因为该辅助方法会成为公共API的一部分。 使用 Java 9，您可以向接口添加私有辅助方法来解决此问题：

public
interface
 
MyInterface
{
 
    
void
normalInterfaceMethod();
 
    
default
void
 
interfaceMethodWithDefault()
{  init(); }
 
    
default
void
 
anotherDefaultMethod()
{ init(); }
 
    
//
This method is not part of the public API exposed by MyInterface
    
private
void
 
init()
{ System.out.println(
"Initializing"
);
}
}

8. HTTP/2

Java 9 中有新的方式来处理 HTTP 调用。这个迟到的特性用于代替老旧的 `HttpURLConnection` API，并提供对 WebSocket 和 HTTP/2 的支持。注意：新的 HttpClient API 在 Java 9 中以所谓的孵化器模块交付。也就是说，这套 API 不能保证 100% 完成。不过你可以在 Java 9 中开始使用这套 API：

HttpClient
client = HttpClient.newHttpClient();
 
HttpRequest
req =
   
HttpRequest.newBuilder(URI.create(
"http://www.google.com"
))
              
.header(
"User-Agent"
,
"Java"
)
              
.GET()
              
.build();
 
 
HttpResponse<String>
resp = client.send(req, HttpResponse.BodyHandler.asString());

HttpResponsef7e83be87db5cd2d9a8a0b8117b38cd4 resp = client.send(req, HttpResponse.BodyHandler.asString());
除了这个简单的请求/响应模型之外，HttpClient 还提供了新的 API 来处理 HTTP/2 的特性，比如流和服务端推送。

9. 多版本兼容 JAR

我们最后要来着重介绍的这个特性对于库的维护者而言是个特别好的消息。当一个新版本的 Java 出现的时候，你的库用户要花费数年时间才会切换到这个新的版本。这就意味着库得去向后兼容你想要支持的最老的 Java 版本 (许多情况下就是 Java 6 或者 7)。这实际上意味着未来的很长一段时间，你都不能在库中运用 Java 9 所提供的新特性。幸运的是，多版本兼容 JAR 功能能让你创建仅在特定版本的 Java 环境中运行库程序时选择使用的 class 版本：

multirelease.jar
├──
META-INF
│  
└── versions
│      
└──
9
│          
└── multirelease
│              
└── Helper.
class
├──
multirelease
    
├──
Helper.
class
    
└──
Main.
class

在上述场景中， multirelease.jar 可以在 Java 9 中使用, 不过 Helper 这个类使用的不是顶层的 multirelease.Helper 这个 class, 而是处在“META-INF/versions/9”下面的这个。这是特别为 Java 9 准备的 class 版本，可以运用 Java 9 所提供的特性和库。同时，在早期的 Java 诸版本中使用这个 JAR 也是能运行的，因为较老版本的 Java 只会看到顶层的这个 Helper 类。

end:写的有点长，内容也比较多，可能也掺杂很多废话，希望多多谅解哈，大家多多鼓励，我会持续更新更多优质的文章，分享使我快乐！

相关文章：

JDK 1.5之Generics

相关视频：

极客学院Java8新特性视频教程

Das obige ist der detaillierte Inhalt vonSystematische Erläuterung der neuen Funktionen des JDK von Version 1.5 bis 1.9 zum einfachen Vergleich. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!