La différence d'efficacité entre l'utilisation de constructeurs et l'utilisation de setters en Java

Lors de l'optimisation du code Java, essayez tous les moyens pour améliorer l'efficacité globale. Utilisez JProfiler pour examiner la proportion de temps du code, puis voyez quelles parties peuvent être optimisées pour réduire le temps d'exécution. Il y a plusieurs directions ci-dessous.

1. Si vous pouvez utiliser le constructeur pour réussir en une seule étape, essayez d'utiliser le constructeur au lieu d'utiliser les fonctions de définition une par une

2. Si vous pouvez utiliser le tableau, utilisez simplement un tableau. Au lieu de listes, les tableaux sont très rapides.

3. Lorsque vous utilisez une boucle for, utilisez la boucle for i pour la collection d'interfaces de liste au lieu de la boucle for each. Lorsque la boucle for i est exécutée, la valeur de longueur est mentionnée en dehors de la boucle for.

4. Certaines variables peuvent être extraites une fois et utilisées plusieurs fois. Ne recevez pas fréquemment. Même une simple valeur int.

5. Si vous pouvez utiliser des classes internes, vous pouvez utiliser des classes internes, ce qui peut économiser l'utilisation des méthodes getter et setter.

6. Pour la sérialisation et la désérialisation json, ne dites pas que fastjson est plus rapide en théorie, utilisez simplement fastjson, car en fonction de la simplicité et de la complexité de la structure des données, vous devez choisir la désérialisation et la désérialisation à utiliser. . Vous devez réellement le tester avant de parler. Vous ne pouvez pas simplement copier la théorie directement, car parfois Gson est très rapide.

Ce qui suit est une comparaison de l'efficacité de cette construction et de cet ensemble

Ensuite, le code utilisé est le suivant suit :

package com.lxk.fast;
 
import com.google.common.collect.Lists;
import com.lxk.model.Car;
import com.lxk.model.Dog;
 
/**
 * 测试谁快 直接构造或者一个个set，他们的效率差多少
 *
 * @author LiXuekai on 2019/6/18
 */
public class FastIsConstructOrSet {
    public static void main(String[] args) {
        testFast();
    }
 
    /**
     * 使用JProfiler看时间占比
     */
    private static void testFast() {
        while (true) {
            //27.4%
            set();
            //72.6%
            construct();
        }
    }
 
    /**
     * 构造函数来给属性赋值
     */
    private static void construct() {
        Car car = new Car("oooo", 100, Lists.newArrayList(new Dog("aaa", true, true)));
    }
 
    /**
     * set来给属性赋值
     */
    private static void set() {
        Car car = new Car();
        car.setSign("oooo");
        car.setPrice(100);
        Dog dog = new Dog();
        dog.setName("aaa");
        dog.setAlive(true);
        dog.setLoyal(true);
        car.setMyDog(Lists.newArrayList(dog));
    }
}

Vous pouvez constater que la construction est beaucoup plus rapide que de la définir un par un. Par conséquent, lorsque vous pouvez définir la valeur de l'attribut en une seule étape, compte tenu du problème d'efficacité, vous devriez le faire. fais-le comme ça

( 2019-07-16 nouvellement ajouté)

Un vieil homme n'a-t-il pas parlé du mode constructeur ?

J'étais curieux alors je l'ai testé, juste au cas où ce mode constructeur serait plus rapide.

Ce qui suit est le code du constructeur

   /**
     * 使用JProfiler看时间占比
     */
    @Test
    public void testFast2() {
        while (true) {
            //33%
            set();
            //12.4%
            construct();
            //54.6%
            builder();
        }
    }
 
    /**
     * 使用lombok的 builder 模式来赋值
     */
    private static void builder() {
        Car car = Car.builder()
                .sign("0000")
                .price(100)
                .myDog(Lists.newArrayList(Dog.builder().name("aaa").alive(true).isLoyal(true).build()))
                .build();
    }

Les annotations de Lombok utilisées.

Puis les résultats du suivi de JProfiler

Le résultat :

Comme vous pouvez le voir, le constructeur est toujours génial, il est toujours plus rapide. De plus, le ratio ci-dessus : 72,6 : 27,4 = 33 : 12,4 = 2,64

Le rapport de temps entre la construction et le set n'a pas changé.

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!