Lors de l'apprentissage des bases de Java, j'ai résumé les nouvelles fonctionnalités de jdk de la version 1.5 à 1.9. Leurs utilisations sont répertoriées ci-dessous pour une comparaison facile. Chaque version est différente. peut aider tout le monde. apache php mysql
Nouvelles fonctionnalités de jdk1.5 :
Génériques
ArrayList list=new ArrayList( ) ------>ArrayList
2 Autoboxing/unboxing
nt i=list.get(0).parseInt(); ---->int i=list.get(0); Aucune conversion explicite n'est requise entre le type d'origine et la classe wrapper correspondante
3 for-each
i=0;i
4 importation statique
Math.sqrt();- --- ---------->sqrt();
5 paramètres de longueur variable
int sum(int ...intlist) a un nombre quelconque de paramètres, traitez-le comme un tableau
Nouvelles fonctionnalités de jdk1.6 :
1 Instruction de boucle for améliorée
Integer[] number = calculateNumbers();
for (int i. =0; je < nombres.longueur ; i++)
somme += nombres[i];
||
int somme = 0;
pour ( nombre int : calculerNombres() )
somme + = nombre;
2. Surveillance et gestion
Java SE 6 a des capacités améliorées d'analyse et de diagnostic pour les fuites de mémoire. Lorsque vous rencontrez une exception java.lang.OutOfMemory, vous pouvez obtenir des informations complètes sur la pile,
et lorsque le tas est plein, un fichier journal sera généré pour enregistrer cette erreur fatale. De plus, la JVM a ajouté une option qui vous permet d'exécuter des scripts lorsque le tas est plein.
3. Traitement des annotations de plug-in
API de traitement des annotations de plug-in (JSR 269) fournit un ensemble d'API standard pour gérer les annotations
4.
Nouveau dans jdk1. .7 Fonctionnalités :
1. Fonctionnalités modulaires
Java7 utilise également la division des modules pour accélérer. Certains modules non essentiels ne sont pas téléchargés et installés lorsque la machine virtuelle en a besoin, ils sont téléchargés. . Le module correspondant
améliore également grandement la vitesse de démarrage.
2. Prise en charge multilingue
La machine virtuelle Java7 ajoute la prise en charge d'une variété de langages de programmation dynamiques, tels que : Ruby, Python, etc.
3. L'efficacité du développement des développeurs a été améliorée
Les chaînes peuvent être utilisées dans le commutateur
En termes de concurrence et de contrôle multi-thread : cadre léger de séparation et de fusion, un HashMap qui prend en charge l'accès simultané, etc.
Améliorez la vérification statique des programmes grâce aux annotations.
Fournit de nouvelles API pour l'accès au système de fichiers, les opérations d'entrée et de sortie asynchrones, la configuration et la liaison du canal Socket, la transmission de paquets de données multipoints, etc.
4. Amélioration de l'efficacité d'exécution
La technologie de compression des pointeurs d'objet de 64 bits vers des pointeurs correspondants de 32 bits réduit considérablement la consommation de mémoire et de blocs de mémoire, améliorant ainsi l'efficacité d'exécution.
Fournit un nouveau mécanisme de collecte des ordures (G1) pour réduire la charge de collecte des ordures et améliorer l'effet de la collecte des ordures.
Nouvelles fonctionnalités du JDK1.8 :
1. Méthode d'interface par défaut
Java 8 nous permet d'ajouter une implémentation de méthode non abstraite à l'interface, utilisez simplement le mot-clé par défaut. Cette fonctionnalité est également appelée méthode d'extension.
2. Expression lambda
Dans Java 8, vous n'avez plus besoin d'utiliser cette méthode d'objet anonyme traditionnelle. Java 8 fournit une syntaxe plus concise, l'expression lambda :
Collections.sort( noms, (String a, String b) -> {
return b.compareTo(a);
});
3.Interface fonctionnelle
Comment les expressions Lambda sont des types en Java Qu'est-ce qui est représenté dans le système ? Chaque expression lambda correspond à un type, généralement un type d'interface. « Interface fonctionnelle » fait référence à une interface qui ne contient qu'une seule méthode abstraite. Chaque expression lambda de ce type sera mise en correspondance avec cette méthode abstraite. Étant donné que les méthodes par défaut ne sont pas considérées comme des méthodes abstraites, vous pouvez également ajouter des méthodes par défaut à votre interface fonctionnelle.
4. Références de méthode et de constructeur
Java 8 vous permet d'utiliser le mot-clé :: pour passer des références de méthode ou de constructeur. Le code ci-dessus montre comment référencer une méthode statique.
converter = Something::startsWith;
String converti = converter.convert("Java");
System.out.println(converted);
Portée Lambda
dans l'accès lambda. la portée externe des expressions est similaire à celle des anciennes versions d'objets anonymes. Vous pouvez accéder directement aux variables locales externes marquées comme finales, ou aux champs d'instance et aux variables statiques.
6. Accéder aux variables locales
Vous pouvez accéder directement aux variables locales externes dans les expressions lambda :
7. Accéder aux champs d'objet et aux variables statiques
La différence avec les variables locales est que l'instance se trouve à l'intérieur des champs lambda et des variables statiques. les variables sont à la fois lisibles et inscriptibles. Ce comportement est cohérent avec les objets anonymes :
8. Méthode par défaut d'accès à l'interface
L'API JDK 1.8 contient de nombreuses interfaces fonctionnelles intégrées, telles que les interfaces Comparator ou Runnable qui sont couramment utilisées dans l'ancien Java. L'annotation @FunctionalInterface a été ajoutée afin qu'elle puisse être utilisée sur les lambdas.
L'API Java 8 fournit également de nombreuses nouvelles interfaces fonctionnelles pour rendre le travail plus pratique. Certaines interfaces sont issues de la bibliothèque Google Guava. Même si vous les connaissez, il faut quand même voir comment celles-ci peuvent être utilisées sur lambda. .
java 7 est sorti en 2011, Java 8 est sorti en 2014 et java9 est sorti le 21 septembre 2017. Vous avez peut-être entendu parler du système de modules de Java 9, mais cette nouvelle version contient de nombreuses autres mises à jour. Voici neuf nouvelles fonctionnalités intéressantes fournies avec Java 9.
La caractéristique déterminante de Java 9 est un tout nouveau système de modules. À mesure que les bases de code s’agrandissent, les chances de créer un « code spaghetti » complexe et alambiqué augmentent de façon exponentielle. À l’heure actuelle, vous devez faire face à deux problèmes fondamentaux : il est difficile d’encapsuler véritablement le code et le système n’a pas une idée claire des dépendances entre les différentes parties (c’est-à-dire les fichiers JAR). Chaque classe publique est accessible par n'importe quelle autre classe publique sur le chemin de classe, ce qui peut conduire à une utilisation par inadvertance d'API qui ne sont pas destinées à être accessibles au public. De plus, il y a des problèmes avec le chemin de classe lui-même : comment savoir que tous les JAR requis sont déjà là, ou s'il y a des entrées en double ? Le système de modules résout les deux problèmes ?
Les fichiers JAR modulaires contiennent un descripteur de module supplémentaire. Dans ce descripteur de module, les dépendances sur d'autres modules sont exprimées par des "requires". De plus, l'instruction "exports" contrôle quels packages sont accessibles par d'autres modules. Tous les packages qui ne sont pas exportés sont encapsulés dans des modules par défaut. Voici un exemple de descripteur de module, présent dans le fichier « module-info.java » :
module
blog {
exports
com.pluralsight.blog;
requires
cms;
}On peut afficher le module comme suit :
Notez que les deux modules contiennent des packages encapsulés puisqu'ils ne sont pas exportés (visualisés avec un bouclier orange). Personne n'utilise les classes de ces packages par accident. La plateforme Java elle-même est également modularisée à l'aide de son propre système de modules. En encapsulant les classes internes du JDK, la plateforme est plus sécurisée et l'amélioration continue est plus facile.
Lors du démarrage d'une application modulaire, la JVM vérifiera que tous les modules sont disponibles, sur la base de l'instruction `requires` - un grand pas en avant par rapport au chemin de classe fragile. Les modules vous permettent de mieux appliquer l'encapsulation structurelle de votre application et de rendre les dépendances explicites. Vous pouvez en apprendre davantage sur l'utilisation des modules dans Java 9 dans ce cours.
当你使用具有显式依赖关系的模块和模块化的 JDK 时，新的可能性出现了。你的应用程序模块现在将声明其对其他应用程序模块的依赖以及对其所使用的 JDK 模块的依赖。为什么不使用这些信息创建一个最小的运行时环境，其中只包含运行应用程序所需的那些模块呢？ 这可以通过 Java 9 中的新的 jlink 工具实现。你可以创建针对应用程序进行优化的最小运行时映像而不需要使用完全加载 JDK 安装版本。
许多语言已经具有交互式编程环境，Java 现在加入了这个俱乐部。您可以从控制台启动 jshell ，并直接启动输入和执行 Java 代码。 jshell 的即时反馈使它成为探索 API 和尝试语言特性的好工具。
测试一个 Java 正则表达式是一个很好的说明 jshell 如何使您的生活更轻松的例子。 交互式 shell 还可以提供良好的教学环境以及提高生产力，您可以在此了解更多信息。在教人们如何编写 Java 的过程中，不再需要解释 “public static void main（String [] args）” 这句废话。
有时一些小事情可以带来很大的不同。你是否就像我一样在一直使用 Google 来查找正确的 Javadoc 页面呢？ 这不再需要了。Javadoc 现在支持在 API 文档中的进行搜索。另外，Javadoc 的输出现在符合兼容 HTML5 标准。此外，你会注意到，每个 Javadoc 页面都包含有关 JDK 模块类或接口来源的信息。
通常，您希望在代码中创建一个集合（例如，List 或 Set ），并直接用一些元素填充它。 实例化集合，几个 “add” 调用，使得代码重复。 Java 9，添加了几种集合工厂方法：
Set<Integer> ints = Set.of( 1 , 2 , 3 ); List<String> strings = List.of( "first" , "second" );
除了更短和更好阅读之外，这些方法也可以避免您选择特定的集合实现。 事实上，从工厂方法返回已放入数个元素的集合实现是高度优化的。这是可能的，因为它们是不可变的：在创建后，继续添加元素到这些集合会导致 “UnsupportedOperationException” 。
长期以来，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 非常有用。
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"
);
}
}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());HttpResponse
除了这个简单的请求/响应模型之外，HttpClient 还提供了新的 API 来处理 HTTP/2 的特性，比如流和服务端推送。
我们最后要来着重介绍的这个特性对于库的维护者而言是个特别好的消息。当一个新版本的 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:写的有点长，内容也比较多，可能也掺杂很多废话，希望多多谅解哈，大家多多鼓励，我会持续更新更多优质的文章，分享使我快乐！
相关文章：
相关视频：
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
supprimer des moyens
Comment configurer l'ordinateur pour qu'il se connecte automatiquement au WiFi
Comment utiliser HTML pour la navigation Web
Quelles sont les méthodes pour implémenter la surcharge d'opérateurs en langage Go ?
Explication détaillée de la configuration de nginx
Introduction au code d'effets spéciaux javascript
Ordre recommandé pour apprendre le langage C++ et C
Comment acheter du Bitcoin
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
