Le cycle de publication de Java a changé et, depuis janvier 2019, la dernière version de Java date de 11. Les améliorations de la grammaire progressent également et les styles Java modernes changent. Dans cet article, je voudrais résumer le style moderne de la programmation Java à l'ère de Java 11.

Veuillez noter qu'il inclut probablement la subjectivité de l'auteur.

var (inférence de type de variables locales)

Utilisez var.

La déclaration de type des variables locales par var introduite dans Java 10, mais en gros, il est bon de l'utiliser de manière positive quand elle peut être utilisée. De nombreuses langues modernes utilisent une inférence de type similaire, mais je n'ai pas entendu dire que c'était un problème.

Pour les programmeurs Java hautement qualifiés, il y a une opinion que l'EDI complète automatiquement la définition de type sur le côté gauche, donc ce n'est pas pratique, mais seulement lors de la lecture du code, le nombre de caractères sur le côté gauche de Java Il existe une redondance dans le grand nombre qui nuit considérablement à la lisibilité.

// before
Owner owner = new Owner();
List<Pet> pets = List.of(new Pet("pochi"), new Pet("tama"));

// after
var owner = new Owner();
var pets = List.of(new Pet("pochi"), new Pet("tama"));

L'exemple ci-dessus n'est pas un gros problème, mais les noms de classe Java ont tendance à être longs si vous incluez des génériques, il est donc souvent plus facile à lire si vous utilisez var pour réduire la quantité d'informations.

Opération de collecte

unmodifiable

Rendre la collection aussi immuable que possible là où elle peut être rendue immuable.

La bibliothèque de collection standard de Java n'a pas d'interface immuable comme ʻImmutableList`, mais vous pouvez faire une exception lorsque vous essayez de changer un élément. Afin d'éviter des changements inattendus d'éléments, il est préférable de rendre les parties qui peuvent être rendues immuables aussi immuables que possible.

//Les méthodes d'usine ajoutées dans Java 9 génèrent des collections immuables
List.of(1, 2, 3); // unmodifiable
Set.of(1, 2, 3); // unmodifiable
Map.of("keyA", "valueA", "keyB", "ValueB"); // unmodifiable

//La classe Collections fournit une méthode qui renvoie une vue immuable de la collection.
Collections.unmodifiableList(modifiableList); // unmodifiable

//Les méthodes d'usine ajoutées dans Java 10 vous permettent également de créer des vues immuables des collections existantes
List.copyOf(modifiableList); // unmodifiable

//Java 10 ajoute une méthode pour convertir en une collection immuable en tant que Stream Collector
modifiableList.stream().collect(Collectors.toUnmodifiableList());

Stream API

--Processer par l'API Stream sans utiliser l'instruction for autant que possible.

Avec l'avènement de l'API Stream dans Java 8, l'instruction for a presque disparu. La description déclarative de l'API Stream est lisible et conviviale lorsqu'elle est bien utilisée, il est donc préférable d'utiliser l'API Stream pour les opérations de collecte, sauf dans des cas exceptionnels.

var beforeList = List.of("a", "b", "c");

// before
var afterList1 = new ArrayList<String>();
for (var str : beforeList) {
  afterList.add(str.toUpperCase());
}

// after
var afterList2 = beforeList
    .stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList());

Null

Optional

--Si null peut être retourné comme valeur de retour de la méthode, renvoyez-le comme type ʻOptional`.

Java 8 a ajouté le type ʻOptional pour indiquer que la valeur peut être null. Il n'y a aucune raison de ne pas l'utiliser, donc si null peut être retourné, retournez-le toujours comme type ʻOptional au lieu de renvoyer null directement.

Optional<String> getName() {
    return Optional.ofNullable(this.name);
}

Il semble que ʻOptonal` soit principalement censé être utilisé comme valeur de retour de la méthode, il vaut donc mieux ne pas l'utiliser dans l'argument ou le champ de la méthode.

Nullability

--null La possibilité est exprimée par une annotation.

L'un des avantages de l'introduction de Kotlin est qu'il est sans danger pour les valeurs nulles, mais Java dispose également d'un mécanisme pour le réaliser partiellement, qui est une déclaration de possibilité nulle par annotation. Il s'agit d'un mécanisme largement utilisé, bien qu'il nécessite l'introduction d'une bibliothèque tierce car il n'a jamais été adopté en tant que fonctionnalité standard Java.

Par exemple, en utilisant les annotations fournies par Spring Framework à partir de la version 5, les expressions suivantes sont possibles.

public @Nullable Pet getPetByName(@NonNull String name) {
    //Ne passez pas null pour le nom de l'argument
    //La valeur de retour Pet peut être nulle (généralement facultative)<Pet>Est mieux)
}

Cela permet à l'EDI de vérifier statiquement d'éventuelles valeurs nulles à l'avance.

À propos, même lors de l'utilisation du code Java de Kotlin, il y a un avantage à déterminer qu'il s'agit d'un type non autorisé null en ajoutant ces annotations.

Nullability annotations - Calling Java from Kotlin - Kotlin Programming Language

Je ne peux pas dire avec certitude quelle annotation de bibliothèque doit être utilisée. Je pense que le JSR 305 est probablement le plus utilisé pour le moment, mais ce JSR est en hibernation et il est peu probable qu'il soit adopté à l'avenir, il n'est donc pas recommandé de l'utiliser à des fins de licence. Je pense que Checker Framework pourrait être une option puissante, mais il existe d'autres options que vous devrez comparer et décider laquelle utiliser.

référence)

Objects.requireNonNull

--Method null Les arguments non autorisés sont vérifiés pour null à un moment précoce en utilisant la méthode ʻObjects.requireNonNull`.

Une annotation qui indique Nullability peut empêcher les valeurs nulles d'être mélangées dans une certaine mesure, mais comme il ne s'agit que d'une analyse statique, elle est impuissante si les valeurs nulles sont mélangées au moment de l'exécution. Afin de détecter une contamination nulle au moment de l'exécution tôt, une vérification nulle à l'intérieur de la méthode est nécessaire après tout.

Avec ʻObjects.requireNonNull` introduit dans Java 7, vous pouvez effectuer une inspection nulle de manière concise, c'est donc une bonne idée de l'utiliser activement.

Pet(@NonNull String name, @NonNull LocalDate birthdate) {
    this.name = Objects.requireNonNull(name);
    this.birthdate = Objects.requireNonNull(birthdate);
}

Au fait, avec IntelliJ, si vous appuyez sur Option + Entrée sur une variable avec une annotation telle que @ NonNull, l'option qui l'englobe automatiquement dans ʻObjects.requireNonNull` sera affichée, alors utilisez ceci. C'est efficace à faire. aaa

try-with-resources

--Utilisez try-with-resources partout où des ressources doivent être fermées.

Java 7 a introduit un mécanisme d'essai avec les ressources pour faciliter la fermeture des ressources. Pour les ressources qui doivent être fermées indépendamment de la réussite ou de l'échec du processus, telles que les connexions à la base de données, il est toujours préférable d'utiliser le mécanisme try-with-resource pour effectuer le processus de fermeture.

// before
FileInputStream inputStream1 = null;
try {
  inputStream1 = new FileInputStream("foo.txt");
  inputStream1.read();
} finally {
  if (inputStream1 != null) {
    try {
      inputStream1.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

// after
try (var inputStream2 = Files.newInputStream(Path.of("foo.txt"))) {
  inputStream2.read();
}

Date et l'heure

--Utilisez l'API de date et d'heure.

N'utilisez pas d'anciennes classes telles que la classe Date, la classe Calendar, la classe SimpleDateFormat, sauf en cas de raison particulière.

L'API Date et heure introduite dans Java 8 remplace désormais presque toutes les anciennes classes Date, Calendar et SimpleDateFormatter. Sauf si vous avez une raison spécifique, vous ne devriez pas utiliser l'ancienne classe.

// before
var date = new Date();
var simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd");
System.out.println(simpleDateFormat.format(date));

// after
var localDate = LocalDate.now();
var dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");
System.out.println(dateTimeFormatter.format(localDate));

On peut dire que des bibliothèques comme Joda-Time, qui permettait d'éliminer la difficulté d'utiliser les anciennes classes, ont également terminé leur rôle.

Date et heure API Review-Qiita

Opération de fichier

Utilisez de préférence la classe de package java.nio.file (NIO2) sur la classe de package java.io (E / S Java).

Avec NIO2 introduit dans Java 7, l'API de manipulation de fichiers de Java est nouvelle. Fondamentalement, il vaut mieux suivre la politique d'utilisation de la nouvelle API au lieu d'utiliser l'ancienne API autant que possible.

// before
var dir = new File("/tmp/dir");
var succeeded = dir.mkdir();
if (succeeded) {
  try {
    new File(dir, "foo.txt").createNewFile();
  } catch (IOException e) {
    e.printStackTrace();
  }
}

// after
try {
  var directory = Files.createDirectory(Path.of("/tmp/dir2"));
  Files.createFile(directory.resolve("foo.txt"));
} catch (IOException e) {
  e.printStackTrace();
}

Essayez d'utiliser Path.of (..) et Files.xxx au lieu de new File (..).

module

Ajouté dès que j'ai compris ...

Guide de style de programmation Java pour l'ère Java 11

var (inférence de type de variables locales)

Opération de collecte

Date et l'heure

Opération de fichier

module