[Java efficace] Évitez de créer des objets inutiles

La propre interprétation efficace de Java. J'ai essayé d'interpréter le point 6 de la 3e édition en écrivant mon propre code.

Aperçu

• Soyez conscient de l'endroit où l'objet est créé.
• Connaître l'existence de l'objet préparé. --Objets constants qui sont réutilisés avec la même valeur encore et encore.
• Notez que la boxe crée des objets sans le vouloir.

Exemples et contre-mesures pour la génération d'objets inutiles

String

  String s = new String("hoge");  

Ce code crée d'abord un objet avec les lettres «» hoge »«, puis un «new String (« hoge »)» crée un autre objet avec les lettres «» hoge »«. En bref, les objets avec le même contenu sont créés deux fois. En procédant comme suit, vous ne pouvez créer l'objet qu'une seule fois.

  String s = "hoge";  

Boolean L'objet Boolean peut en fait être créé en prenant l'objet String comme argument, comme indiqué ci-dessous.

  Boolean b = new Boolean("true");  

Cependant, en premier lieu, «Boolean» ne prend que trois valeurs, «null», «true» et «false». Dans la classe Boolean, les objets true et false sont préparés à l'avance sous forme de constantes.

** Fait partie de la classe booléenne **

    public static final Boolean TRUE = new Boolean(true);
    public static final Boolean FALSE = new Boolean(false);

Il existe également une méthode valueOf qui renvoie ces constantes.

    public static Boolean valueOf(String s) {
        return parseBoolean(s) ? TRUE : FALSE;
    }

Donc, si vous déclarez un objet Boolean en utilisant la méthode valueOf comme indiqué ci-dessous, vous n'aurez pas besoin de faire référence à l'objet initialement préparé par la classe Boolean et d'en créer un nouveau.

  Boolean b = Boolean.valuOf("true");  

Un objet créé à chaque fois qu'une méthode est appelée

Considérez la méthode suivante pour déterminer si la chaîne est un nombre romain correct.

  static boolean isRomanNumeral(String s) {
    return s.matches("^(?=.)M*(C[MD]|D?C{0,3})"
              + "(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$");
  } 

Puisque String.matches crée en interne un objet Pattern, un nouvel objet Pattern sera créé chaque fois que cette méthode est appelée. Si l'objet Pattern est défini à l'avance comme une constante, l'objet Pattern ne peut être créé qu'une seule fois au moment de l'initialisation de la classe.

  public class RomanNumerals {
    private static final Pattern ROMAN = Pattern.compile(
              "^(?=.)M*(C[MD]|D?C{0,3})"
              + "(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$");
                
    static boolean isRomanNumeral(String s) {
      return ROMAN.matcher(s).matches();
    } 
  }

• String.matches crée en interne un objet Pattern et appelle.matcher (chaîne de caractères cible de jugement) .matches ()à partir de cet objet, donc la partie de génération d'objet Pattern entière est omise. Cela devient la forme qui a été faite.

Boxe inutile

Considérez le code suivant.

private static long sum() {
  Long sum = 0L;
  for (long i = 0; i <= Integer.MAX_VALUE; i++)
    sum += 1;
    
  return sum;
}

Puisque sum + = 1 est casté en interne et calculé comme Long sum = sum + (Long) 1 chaque fois, un objet Long est créé à chaque fois. En premier lieu, cette méthode ne nécessite pas que «somme» soit de type «Long», donc simplement déclarer «somme» de type «long» peut grandement améliorer la vitesse. C'est un exemple simple, mais vous devez toujours savoir si vous devez utiliser une classe wrapper (besoin de prendre null, situations possibles, etc.).

Mise en garde

L'idée est que l'objet d'un argument de méthode ne doit pas changer d'état à l'intérieur de la méthode. En effet, il est difficile de voir dans quoi se trouve l'objet maintenant et le risque de bugs augmente. À moins que les performances ne soient vraiment nécessaires, dans ce cas, nous devons prioriser la réduction du risque d'occurrence de bogue en créant un nouvel objet dans la méthode et en copiant le contenu de l'objet argument.