Mémo de modèle Java

Puisqu'il s'agit d'un mémo personnel, il peut être ajouté de manière appropriée ou laissé sans surveillance.

List.of plutôt que Arrays.asList

À partir de JDK9, il vaut mieux utiliser «List.of» que «Arrays.asList». La List retournée par ʻArrays.asListest juste un wrapper pour le tableau, dont la taille est fixe mais vous permet de changer les éléments. D'un autre côté, laList retournée par List.of` ne peut pas changer l'élément et devient immuable.

n-> new int [n] est int [] :: new

Cela ressemble à une syntaxe mystérieuse, mais c'est ce que c'est. Tout comme new String (data) peut être écrit comme String :: new.

N'utilisez pas les champs d'interface fonctionnelle

final Function<String, Price> CONVERT_STRING_TO_PRICE = 
  str -> str.substring(0, str.length() - 1).transfer(Price::of);

Définir le champ

return inputs.stream()
  .map(CONVERT_STRING_TO_PRICE)
  .collect(toList());

Il peut être utilisé comme ça.

Mais cela définit normalement une méthode,

Price stringToPrice(String str) {
  return str.substring(0, str.length() - 1).transfer(Price::of);
}

Il est préférable d'utiliser des références de méthode.

return inputs.stream()
  .map(Converters::stringToPrice)
  .collect(toList());

Vous pouvez écrire correctement des commentaires dans JavaDoc et les méthodes sont plus faciles à lire que les fonctions d'ordre supérieur. De plus, les lambdas sont finalement compilées en définitions de méthodes et références de méthodes, ce qui est un peu un gaspillage.

Ne pas utiliser facultatif pour les champs

Puisqu'il n'est pas «sérialisable», il est préférable d'utiliser une valeur normale avec «@ Nullable».

N'utilisez pas Stream comme valeur de retour

À moins que ce ne soit une méthode qui fonctionne sur Stream lui-même, il est préférable de ne pas renvoyer Stream. En standard, vous pouvez retourner Stream <T>, mais quelque chose qui retourne un type concret tel que Stream <String> n'est pas très bon. Ou lorsque vous souhaitez effectuer un "traitement de flux" avec des E / S comme Files.lines.

Modèle de flux

Utilisez IntStream lorsque vous souhaitez diffuser boolean [] ou char []

IntStream.range(0, chars.length)->mapToObject(i -> chars[i])

anyMatch

for (var a : list) {
  if (condition(a)) {
    return true;
  }
}
return false

↓

return list.stream().anyMatch(this::condition);

allMatch

for (var a : list) {
  if (!condition(a)) {
    return false;
  }
}
return true

↓

return list.stream().allMatch(this::condition);

noneMatch

for (var a : list) {
  if (condition(a)) {
    return false;
  }
}
return true

↓

return list.stream().noneMatch(this::condition);

Ne mettez pas le flux ou la liste en option

ʻOptional` est une collection spéciale d'éléments 0 ou 1, donc vous n'avez pas besoin d'englober davantage Stream ou List et vous devriez pouvoir le gérer avec Stream.of () ou emptyList ().

if

Système normal et système anormal

Puis le système normal, sinon le système anormal

if (cond) {
  proc
} else {
  error
}

Cependant, lorsque le système anormal revient / jette sur une ligne, mettez le système anormal en if et échappez-vous tôt.

if (!cond) {
  throw error
}
proc

!(aa && bb)

Il vaut mieux éviter l'inversion en le mettant entre de grandes parenthèses comme ! (Aa && bb)

if (!(hasValue && isValid)) {
  error
}

Que

if (!hasValue || !isValid) {
  error
}

Vous n'avez pas à mettre en cache les résultats dans votre cerveau. Cependant, si ʻelse` est attaché

if (!hasValue || !isValid) {
  error
} else {
  proc
}

Que

if (hasValue && isValid) {
  proc
} else {
  error
}

N'a pas besoin d'être inversé. Dans ce cas, la politique consistant à changer le système normal en alors est également suivie. De plus, il vaut mieux ne pas le faire à la main car l'EDI devrait faire ce genre d'inversion logique.

enum

Lorsqu'il a des paramètres, ajoutez @ AllArgsConstructor et @ Getter. @ Value ne peut pas être utilisé pour ʻenum`.

@AllArgsConstructor
@Getter
enum Hoge {
  A("a-desu"),
  B("b-dayo");

  private String message;
}

Integer.valueOf renvoie Integer

ʻInteger et Long valueOf` renvoient un objet wrapper. Donc, un code comme celui-ci est inutile

int n = Integer.valueOf(str);

Utilisez parseInt si vous voulez l'utiliser comme primitive

int n = Integer.parseInt(str);

Utilisez UncheckedIOException pour faire d'IOException une exception non cochée

catch (IOException ex) {
  throw new UncehckedIOException(ex);
}

Ajouter Visible pour les tests lors de l'utilisation du package privé pour les tests

@VisibleForTesting
String createId(String seed) {
}