L'efficacité de Java “Double Croisillon d'Initialisation”?

Voici le problème quand je suis trop loin avec les classes internes anonymes:

2009/05/27  16:35             1,602 DemoApp2$1.class
2009/05/27  16:35             1,976 DemoApp2$10.class
2009/05/27  16:35             1,919 DemoApp2$11.class
2009/05/27  16:35             2,404 DemoApp2$12.class
2009/05/27  16:35             1,197 DemoApp2$13.class
/* snip */
2009/05/27  16:35             1,953 DemoApp2$30.class
2009/05/27  16:35             1,910 DemoApp2$31.class
2009/05/27  16:35             2,007 DemoApp2$32.class
2009/05/27  16:35               926 DemoApp2$33$1$1.class
2009/05/27  16:35             4,104 DemoApp2$33$1.class
2009/05/27  16:35             2,849 DemoApp2$33.class
2009/05/27  16:35               926 DemoApp2$34$1$1.class
2009/05/27  16:35             4,234 DemoApp2$34$1.class
2009/05/27  16:35             2,849 DemoApp2$34.class
/* snip */
2009/05/27  16:35               614 DemoApp2$40.class
2009/05/27  16:35             2,344 DemoApp2$5.class
2009/05/27  16:35             1,551 DemoApp2$6.class
2009/05/27  16:35             1,604 DemoApp2$7.class
2009/05/27  16:35             1,809 DemoApp2$8.class
2009/05/27  16:35             2,022 DemoApp2$9.class

Ce sont toutes les classes qui ont été générés, quand je faisais une application simple, et utilisé de grandes quantités d'anonymous inner classes: chaque classe seront compilées dans un class fichier.

La "double croisillon d'initialisation", comme déjà mentionné, est un anonyme intérieur de la classe avec un exemple d'initialisation du bloc, ce qui signifie qu'une nouvelle classe est créée pour chaque "initialisation", tous dans le but de faire un objet unique.

Considérant que la Machine Virtuelle Java aurez besoin de lire toutes les classes lors de leur utilisation, qui peut conduire à un certain temps dans le la vérification de bytecode processus et ces. Pour ne pas mentionner l'augmentation de l'espace disque nécessaire pour stocker tous ces class fichiers.

Il me semble que si il ya un peu de surcharge lors de l'utilisation de la double accolade de l'initialisation, donc c'est probablement pas une bonne idée d'aller trop trop loin avec elle. Mais comme Eddie a noté dans les commentaires, il n'est pas possible d'être absolument sûr de l'impact.

---

Juste pour la référence, double croisillon d'initialisation est la suivante:

List<String> list = new ArrayList<String>() {{
add("Hello");
add("World!");
}};

Il ressemble à un "caché" de Java, mais c'est juste une réécriture de:

List<String> list = new ArrayList<String>() {
//Instance initialization block
{
add("Hello");
add("World!");
}
};

C'est en fait une exemple d'initialisation du bloc qui fait partie d'un anonyme intérieur de la classe.

---

Joshua Bloch de La collecte des Littéraux de proposition pour Projet De Pièce De Monnaie a été le long des lignes de:

List<Integer> intList = [1, 2, 3, 4];
Set<String> strSet = {"Apple", "Banana", "Cactus"};
Map<String, Integer> truthMap = { "answer" : 42 };

Malheureusement, il ne pas faire son chemin dans ni de Java 7 ni 8 et a été abandonné indéfiniment.

---

Expérience

Voici la simple expérience, j'ai testé-faire 1000 ArrayLists avec les éléments "Hello" et "World!" ajouté par add méthode, à l'aide de deux méthodes:

Méthode 1: Double Croisillon Initialisation

List<String> l = new ArrayList<String>() {{
add("Hello");
add("World!");
}};

Méthode 2: Instancier un ArrayList et add

List<String> l = new ArrayList<String>();
l.add("Hello");
l.add("World!");

J'ai créé un programme simple d'écrire un fichier source de Java pour effectuer 1000 initialisation à l'aide de deux méthodes:

Test 1:

class Test1 {
public static void main(String[] s) {
long st = System.currentTimeMillis();
List<String> l0 = new ArrayList<String>() {{
add("Hello");
add("World!");
}};
List<String> l1 = new ArrayList<String>() {{
add("Hello");
add("World!");
}};
/* snip */
List<String> l999 = new ArrayList<String>() {{
add("Hello");
add("World!");
}};
System.out.println(System.currentTimeMillis() - st);
}
}

Test 2:

class Test2 {
public static void main(String[] s) {
long st = System.currentTimeMillis();
List<String> l0 = new ArrayList<String>();
l0.add("Hello");
l0.add("World!");
List<String> l1 = new ArrayList<String>();
l1.add("Hello");
l1.add("World!");
/* snip */
List<String> l999 = new ArrayList<String>();
l999.add("Hello");
l999.add("World!");
System.out.println(System.currentTimeMillis() - st);
}
}

Veuillez noter que le temps nécessaire à l'initialisation de la 1000 ArrayLists et le 1000 anonyme intérieure classes de l'extension de ArrayList est vérifiée à l'aide de la System.currentTimeMillis, de sorte que la minuterie n'a pas une très haute résolution. Sur mon système Windows, la résolution est d'environ 15 à 16 millisecondes.

Les résultats pour les 10 pistes des deux épreuves sont les suivantes:

Test1 Times (ms)           Test2 Times (ms)
----------------           ----------------
187                          0
203                          0
203                          0
188                          0
188                          0
187                          0
203                          0
188                          0
188                          0
203                          0

Comme on peut le voir, le double croisillon initialisation d'un notable du temps d'exécution d'environ 190 ms.

Pendant ce temps, le ArrayList de l'initialisation de temps d'exécution est sorti à 0 ms. Bien sûr, la résolution du timer doit être pris en compte, mais il est susceptible d'être sous 15 ms.

Donc, il semble y avoir une différence notable dans le temps d'exécution des deux méthodes. Il semble en effet qu'il existe une surcharge dans les deux méthodes d'initialisation.

Et oui, il y avait 1000 .class les fichiers générés par la compilation de la Test1 double accolade de l'initialisation du programme de test.

Chaque fois que quelqu'un utilise la double accolade de l'initialisation, un chaton se fait tuer.

En dehors de la syntaxe plutôt inhabituel et pas vraiment idiomatiques (le goût est discutable, bien sûr), vous êtes inutilement la création de deux problèmes importants dans votre application, qui j'ai tout récemment blogué au sujet plus en détail ici.

1. Vous êtes en train de créer trop de anonyme classes

Chaque fois que vous utilisez une double accolade de l'initialisation d'une nouvelle classe est faite. E. g. cet exemple:

Map source = new HashMap(){{
put("firstName", "John");
put("lastName", "Smith");
put("organizations", new HashMap(){{
put("0", new HashMap(){{
put("id", "1234");
}});
put("abc", new HashMap(){{
put("id", "5678");
}});
}});
}};

... va produire ces classes:

Test$1$1$1.class
Test$1$1$2.class
Test$1$1.class
Test$1.class
Test.class

C'est tout à fait un peu de surcharge de votre chargeur de classe - pour rien! Bien sûr, il ne prendra pas beaucoup de temps d'initialisation si vous le faites une fois. Mais si vous faites cela 20'000 de fois tout au long de votre application d'entreprise... tout ce que la mémoire du tas juste pour un peu de syntaxe "sucre"?

2. Vous êtes potentiellement la création d'une fuite de mémoire!

Si vous prenez le code ci-dessus et retourner cette carte à partir d'une méthode, les appelants de la méthode, peut-être sans s'en douter, se tenant à de très lourdes ressources qui ne peuvent être nettoyés. Considérons l'exemple suivant:

public class ReallyHeavyObject {
//Just to illustrate...
private int[] tonsOfValues;
private Resource[] tonsOfResources;
//This method almost does nothing
public Map quickHarmlessMethod() {
Map source = new HashMap(){{
put("firstName", "John");
put("lastName", "Smith");
put("organizations", new HashMap(){{
put("0", new HashMap(){{
put("id", "1234");
}});
put("abc", new HashMap(){{
put("id", "5678");
}});
}});
}};
return source;
}
}

Le retour de l' Map contient maintenant une référence à la enfermant instance de ReallyHeavyObject. Vous ne voulez probablement pas à risque:

_{Image de http://blog.jooq.org/2014/12/08/dont-be-clever-the-double-curly-braces-anti-pattern/}

3. Vous pouvez prétendre que Java a la carte littéraux

Pour répondre à votre question, les gens ont été en utilisant cette syntaxe pour faire semblant que Java a quelque chose comme une carte de littéraux, semblable à la matrice de littéraux:

String[] array = { "John", "Doe" };
Map map = new HashMap() {{ put("John", "Doe"); }};

Certaines personnes peuvent trouver cela un point de vue syntaxique stimulant.

fuite sujettes

J'ai décidé de carillon. L'impact de la performance comprend: opération de disque + décompresser (jar), la classe de vérification, perm-gen de l'espace (pour le Soleil de la JVM Hotspot).
Cependant, le pire de tous: c'est une fuite sur le ventre. Vous ne pouvez pas il suffit de le retourner.

Set<String> getFlavors(){
return Collections.unmodifiableSet(flavors)
}

Donc, si l'ensemble échappe à toute autre partie chargée par un chargeur de classes différentes et une référence y est conservé, l'ensemble de l'arborescence de classes+chargeur de classe sera coulé. Pour éviter cela, une copie de HashMap est nécessaire, new LinkedHashSet(new ArrayList(){{add("xxx);add("yyy");}}). Pas très joli, pas plus.
Je n'utilise pas le langage, moi-même, c'est plutôt comme new LinkedHashSet(Arrays.asList("xxx","YYY"));

Pour créer des jeux, vous pouvez utiliser un varargs usine méthode au lieu de double-brace initialisation:

public static Set<T> setOf(T ... elements) {
return new HashSet<T>(Arrays.asList(elements));
}

Google Collections de la bibliothèque a beaucoup de méthodes pratiques de ce genre, ainsi que des tas d'autres fonctions utiles.

Comme pour l'idiome de l'obscurité, je rencontre et l'utiliser dans la production de code de tous les temps. Je serais plus préoccupé par les programmeurs qui se confondre par l'idiome d'être autorisé à écrire du code de production.

Il n'y a généralement rien de particulièrement inefficace à ce sujet. Il n'est généralement pas la question de la JVM que vous avez fait une sous-classe et de l'ajout d'un constructeur à cela, c'est normal, tous les jours de chose à faire dans un langage orienté-objet. Je pense tout à fait artificiel cas où vous pourrait entraîner une inefficacité en faisant cela (par exemple, vous avez a à plusieurs reprises appelé méthode qui prend un mélange de différentes classes en raison de la présente sous-classe, alors que l'ordinaire de la classe passée en serait totalement prévisible-- dans ce dernier cas, le compilateur JIT pourrait faire des optimisations qui ne sont pas réalisables dans le premier). Mais vraiment, je pense que le cas où il va la matière sont très artificiel.

J'ai vu l'émission de plus, du point de vue de savoir si vous voulez "le désordre des choses" avec beaucoup de classes anonymes. À titre indicatif, pensez à utiliser l'idiome pas plus que vous ne l'utiliser, disons, anonyme classes pour les gestionnaires d'événements.

Dans (2), vous êtes à l'intérieur, le constructeur d'un objet, de sorte que "cela" se réfère à l'objet que vous êtes la construction. Ce n'est pas différent de n'importe quel autre constructeur.

Que pour (3), qui dépend vraiment de qui est le maintien de votre code, je suppose. Si vous ne savez pas à l'avance, puis une référence que je conseille est "avez-vous le voir dans le code source du JDK?" (dans ce cas, je ne me souviens pas avoir vu de nombreux anonymes initialisers, et certainement pas dans les cas où c'est le seulement contenu de la classe anonyme). Dans la plupart de taille modérée projets, je dirais que vous allez vraiment avoir besoin de vos programmeurs à comprendre le JDK source à un moment ou un autre, de sorte que toute la syntaxe ou l'idiome utilisé, il est "fair game". Au-delà, je dirais, de former les gens sur cette syntaxe si vous avez le contrôle de l'oms pour maintenir le code, d'autre commentaire ou à éviter.

Je faisais des recherches sur ce et a décidé de faire un plus dans le test de profondeur que celle fournie par la réponse valable.

Voici le code: https://gist.github.com/4368924

et c'est ma conclusion

J'ai été surpris de constater que dans la plupart de l'exécution des tests à l'interne de l'initiation s'est effectivement plus rapide (presque le double dans certains cas). Lorsque vous travaillez avec un grand nombre au profit semble s'estomper.

Fait intéressant, le cas qui crée 3 objets sur la boucle perd de sa prestation rans plus tôt que sur les autres cas. Je ne suis pas sûr de savoir pourquoi cela se passe et plus les tests doivent être fait pour parvenir à des conclusions. Créer des implémentations concrètes peuvent aider à éviter la définition de classe pour être rechargé (si c'est ce qui se passe)

Cependant, il est clair que pas beaucoup de frais généraux, elle a observé dans la plupart des cas, le seul élément de construction, même avec un grand nombre.

Un ensemble serait le fait que chaque de la double croisillon initiations crée un nouveau fichier de classe qui ajoute un ensemble de bloc de disque de la taille de notre application (ou environ 1k lors de la compression). Une petite empreinte de pas, mais si c'est utilisé dans de nombreux endroits, il pourrait potentiellement avoir un impact. Utilisez cette 1000 fois, et vous êtes peut-être ajouter un ensemble de MiB pour vous application, ce qui peut être relatif à un environnement embarqué.

Ma conclusion? Il peut être ok pour l'utiliser tant qu'il n'est pas abusé.

Laissez-moi savoir ce que vous en pensez 🙂

Bien que cette syntaxe peut être pratique, elle ajoute également beaucoup de ce$0 références qu'elles sont imbriquées et il peut être difficile de l'étape de débogage dans les initialiseurs de moins que les points d'arrêt sont réglés sur chacun d'eux. Pour cette raison, je ne recommande l'utilisation de ce banal pour les setters, en particulier de définir des constantes, et les lieux où l'anonyme sous-classes n'a pas d'importance (pas comme la sérialisation impliqués).

1. Cela appel add() pour chaque membre. Si vous pouvez trouver un moyen plus efficace de mettre les éléments dans une table de hachage ensemble, puis l'utiliser. Notez que l'intérieur de la classe sera susceptible de générer des ordures, si vous êtes sensibles à ce sujet.

2. Il me semble que si le contexte est l'objet renvoyé par new, qui est le HashSet.

3. Si vous devez demander à... Plus de chances: les gens qui viennent après vous savez cela ou non? Est-il facile à comprendre et à expliquer? Si vous pouvez répondre "oui" à la fois, n'hésitez pas à l'utiliser.