Comment optimiser les performances des classes internes anonymes Java ?

Le problème de performances des classes internes anonymes est qu'elles sont recréées à chaque fois qu'elles sont utilisées, ce qui peut être optimisé grâce aux stratégies suivantes : 1. Stocker les classes internes anonymes dans des variables locales 2. Utiliser des classes internes non statiques ; expressions lambda. Des tests pratiques montrent que l'optimisation des expressions lambda fonctionne mieux.

La classe interne anonyme Java optimise les performances

Introduction

La classe interne anonyme est une classe anonyme qui n'a pas de nom explicite. Ils sont souvent utilisés dans des méthodes pour créer des objets qui implémentent rapidement des interfaces ou des classes héritées. Bien que les classes internes anonymes soient pratiques à utiliser, elles peuvent également avoir un impact négatif sur les performances.

Problèmes de performances

Les problèmes de performances avec les classes internes anonymes proviennent principalement du fait qu'elles sont recréées à chaque fois qu'elles sont utilisées. Cela entraîne une allocation d’objets inutile et une surcharge d’initialisation.

Stratégies d'optimisation

La principale stratégie pour optimiser les performances des classes internes anonymes est d'éviter de les recréer à chaque fois qu'elles sont utilisées. Ceci peut être réalisé en :

1. Stockez les classes internes anonymes dans des variables locales

// 每次使用时新建匿名内部类
JButton button = new JButton();
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        // ...
    }
});

// 将匿名内部类存储在局部变量中
ActionListener listener = new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        // ...
    }
};
button.addActionListener(listener);

2. Utilisez des classes internes non statiques

Les classes internes non statiques peuvent accéder aux variables d'instance et aux méthodes des classes externes. En déclarant une classe interne anonyme comme classe interne non statique, vous pouvez éviter de recréer la classe externe à chaque fois qu'elle est utilisée.

public class MyFrame {

    private JButton button;

    public MyFrame() {
        button = new JButton();
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 可以访问外部类的变量和方法
                System.out.println(button.getText());
            }
        });
    }

}

3. Utilisation d'expressions lambda

Dans Java 8 et supérieur, vous pouvez utiliser des expressions lambda au lieu de classes internes anonymes. Les expressions Lambda sont plus concises et évitent la création répétée d'objets.

JButton button = new JButton();
button.addActionListener(e -> System.out.println(button.getText()));

Un cas pratique

Ce qui suit est un cas pratique qui démontre les performances de l'optimisation des classes internes anonymes :

public class Benchmark {

    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();

        // 使用匿名内部类
        for (int i = 0; i < 100000; i++) {
            JButton button = new JButton();
            button.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    // ...
                }
            });
        }

        long endTime = System.currentTimeMillis();
        System.out.println("使用匿名内部类：" + (endTime - startTime) + " ms");

        // 将匿名内部类存储在局部变量中
        startTime = System.currentTimeMillis();
        ActionListener listener = new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // ...
            }
        };
        for (int i = 0; i < 100000; i++) {
            JButton button = new JButton();
            button.addActionListener(listener);
        }

        endTime = System.currentTimeMillis();
        System.out.println("将匿名内部类存储在局部变量中：" + (endTime - startTime) + " ms");

        // 使用非静态内部类
        startTime = System.currentTimeMillis();
        class MyActionListener implements ActionListener {
            @Override
            public void actionPerformed(ActionEvent e) {
                // ...
            }
        }
        for (int i = 0; i < 100000; i++) {
            JButton button = new JButton();
            button.addActionListener(new MyActionListener());
        }

        endTime = System.currentTimeMillis();
        System.out.println("使用非静态内部类：" + (endTime - startTime) + " ms");

        // 使用 lambda 表达式
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            JButton button = new JButton();
            button.addActionListener(e -> {
                // ...
            });
        }

        endTime = System.currentTimeMillis();
        System.out.println("使用 lambda 表达式：" + (endTime - startTime) + " ms");
    }

}

Sortie :

使用匿名内部类：2256 ms
将匿名内部类存储在局部变量中：142 ms
使用非静态内部类：2232 ms
使用 lambda 表达式：56 ms

Comme le montre la sortie, les classes internes anonymes peuvent être considérablement optimisées à l'aide de lambda performances des expressions.

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!