Comment éviter la création inutile d'objets en Java ?

Introduction

Dans le développement Java, les programmeurs doivent faire de leur mieux pour éviter de créer des objets avec les mêmes fonctions, car cela consomme non seulement de la mémoire, mais affecte également la vitesse d'exécution du programme. Pensez à réutiliser les objets dans ce cas.

Ensuite, donnons quelques exemples de scénarios dans lesquels des objets sont réutilisés pour voir si nous avons été trompés. Si c'est le cas, nous devrions rapidement le changer discrètement avant qu'il ne soit découvert, nous serons dénoncés !

1. String et Boolean

Il ne semble y avoir aucune différence entre les deux méthodes d'écriture suivantes, mais si nous comprenons profondément le jvm sous-jacent, nous pouvons utiliser les caractéristiques du pool de constantes d'exécution jvm pour éviter de créer des objets String avec les mêmes fonctions (notamment dans Created inside the loop) peuvent apporter une optimisation considérable des performances et économiser de la mémoire.

Manière incorrecte d'écrire

// 每次都会创建一个新的String对象，且不会加入常量池
String name2 = new String("李子捌");

Manière correcte d'écrire

// 正确写法
String name1 = "李子捌";

De plus, les programmeurs qui viennent d'écrire du code Java doivent également choisir l'utilisation correcte des classes String, StringBuilder et StringBuffer. String est un objet immuable et est généralement utilisé pour définir des chaînes immuables ; StringBuilder et StringBuffer sont utilisés dans des scénarios d'opérations de chaînes variables, tels que l'épissage de chaînes ; StringBuffer est thread-safe et utilise le mot clé Synchronized pour réaliser la synchronisation des threads.

// StringBuffer中的append()方法
public synchronized StringBuffer append(String str) {
    toStringCache = null;
    super.append(str);
    return this;
}

// StringBuilder中的append()方法
public StringBuilder append(String str) {
    super.append(str);
    return this;
}

Boolean est un type couramment utilisé. Boolean.valueof() doit également être utilisé à la place de new Boolean() dans le développement. Il ressort du code source de Boolean que la classe Boolean définit deux propriétés statiques finales, et Boolean. .valueof() renvoie directement les deux propriétés définies, tandis que new Boolean() crée un nouvel objet.

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

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

2. Unboxing et boxing automatiques

Java fournit des fonctions de unboxing et de boxing automatiques pour les types de données de base. Cela signifie-t-il que nous pouvons utiliser ces deux types librement dans le code ? En fait, en théorie, il n’y a pas de problème au niveau du code, mais il y a encore une marge d’optimisation en termes de performances spécifiques ! ! !

Testons les performances

long start = System.currentTimeMillis();
Integer sum = 0;
for (int i = 0; i < 100000; i++) {
    sum += i;
}
System.out.println(System.currentTimeMillis() - start);

L'utilisation d'Integer prend 3 millisecondes

long start = System.currentTimeMillis();
// 修改Integer 为 int 
int sum = 0;
for (int i = 0; i < 100000; i++) {
    sum += i;
}
System.out.println(System.currentTimeMillis() - start);

L'utilisation de int prend 0 milliseconde

Donc, en ce qui concerne l'utilisation du déballage et de la boxe automatiques, nous pouvons en fait le faire de manière appropriée. Pensez-y, après tout, parfois les performances du code sont réduites petit à petit ! ! !

3. Expressions régulières

Les expressions régulières sont souvent utilisées pour vérifier si les chaînes sont légales. Regardons d'abord un code simple (voyez-vous le problème en un coup d'œil ? Je pense que vous avez dû le voir) !

public static void main(String[] args) {

    String email = "1057301174@qq.com";
    String regex = "^([a-z0-9A-Z]+[-|\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\.)+[a-zA-Z]{2,}$";

    long start = System.currentTimeMillis();
    for (int i = 0; i < 10000; i++) {
        email.matches(regex);
    }

    System.out.println(System.currentTimeMillis() - start);

}

Le temps d'exécution de ce code est de 71 millisecondes, ce qui semble assez rapide !

Mais nous faisons une optimisation très simple. Le code optimisé est le suivant :

public static void main(String[] args) {

    String email = "1057301174@qq.com";
    String regex = "^([a-z0-9A-Z]+[-|\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\.)+[a-zA-Z]{2,}$";
    Pattern pattern = Pattern.compile(regex);

    long start = System.currentTimeMillis();
    for (int i = 0; i < 10000; i++) {
        //email.matches(regex);
        pattern.matcher(email);
    }

    System.out.println(System.currentTimeMillis() - start);

}

La nouvelle exécution du code prend 1 milliseconde au total, ce qui est 70 fois plus rapide ! ! !

Cela est dû au fait que la méthode String.matches() doit exécuter Pattern.compile(regex) à chaque fois qu'elle est créée dans la boucle, et le coût de création d'une instance Patter est élevé car l'expression régulière doit être compilé dans une machine à états finis. Dans ce cas, nous ignorons souvent les considérations de performances, car l'API Java fournit des appels de méthode plus pratiques et n'est souvent pas facile à trouver.

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!