Pourquoi l'impression «B» est-elle beaucoup plus lente que l'impression «#»?

J'ai généré deux matrices de 1000x 1000:

Première matrice: Oet #.
Deuxième matrice: Oet B.

En utilisant le code suivant, la première matrice a pris 8,52 secondes pour terminer:

Random r = new Random();
for (int i = 0; i < 1000; i++) {
    for (int j = 0; j < 1000; j++) {
        if(r.nextInt(4) == 0) {
            System.out.print("O");
        } else {
            System.out.print("#");
        }
    }

   System.out.println("");
 }

Avec ce code, la deuxième matrice a mis 259,152 secondes pour terminer:

Random r = new Random();
for (int i = 0; i < 1000; i++) {
    for (int j = 0; j < 1000; j++) {
        if(r.nextInt(4) == 0) {
            System.out.print("O");
        } else {
            System.out.print("B"); //only line changed
        }
    }

    System.out.println("");
}

Quelle est la raison derrière les temps d'exécution radicalement différents?

Comme suggéré dans les commentaires, l'impression ne System.out.print("#");prend que 7.8871quelques secondes, tandis que System.out.print("B");donne still printing....

Comme d'autres qui ont souligné que cela fonctionne normalement pour eux, j'ai essayé Ideone.com par exemple, et les deux morceaux de code s'exécutent à la même vitesse.

Conditions de test:

• J'ai exécuté ce test à partir de Netbeans 7.2 , avec la sortie dans sa console
• J'ai utilisé System.nanoTime()pour les mesures

La spéculation pure est que vous utilisez un terminal qui essaie de faire un habillage de mots plutôt qu'un habillage de caractères, et traite Bcomme un caractère de mot mais #comme un caractère non-mot. Ainsi, quand il atteint la fin d'une ligne et recherche un endroit pour rompre la ligne, il y voit #presque immédiatement et heureusement une pause; alors qu'avec le B, il doit continuer à chercher plus longtemps, et peut avoir plus de texte à encapsuler (ce qui peut être coûteux sur certains terminaux, par exemple, la sortie des espaces arrière, puis la sortie des espaces pour remplacer les lettres encapsulées).

Mais c'est de la pure spéculation.

J'ai effectué des tests sur Eclipse vs Netbeans 8.0.2, tous deux avec Java version 1.8; J'ai utilisé System.nanoTime()pour les mesures.

Éclipse:

J'ai eu le même temps sur les deux cas - environ 1,564 secondes .

Netbeans:

• Utilisation de "#": 1,536 secondes
• Utilisation de "B": 44,164 secondes

Ainsi, il semble que Netbeans ait de mauvaises performances d'impression sur la console.

Après plus de recherches, j'ai réalisé que le problème est le retour à la ligne du tampon max de Netbeans (il n'est pas limité à la System.out.printlncommande), démontré par ce code:

for (int i = 0; i < 1000; i++) {
    long t1 = System.nanoTime();
    System.out.print("BBB......BBB"); \\<-contain 1000 "B"
    long t2 = System.nanoTime();
    System.out.println(t2-t1);
    System.out.println("");
}

Les résultats temporels sont inférieurs à 1 milliseconde à chaque itération, sauf à chaque cinquième itération , lorsque le résultat temporel est d'environ 225 millisecondes. Quelque chose comme (en nanosecondes):

BBB...31744
BBB...31744
BBB...31744
BBB...31744
BBB...226365807
BBB...31744
BBB...31744
BBB...31744
BBB...31744
BBB...226365807
.
.
.

Etc..

Sommaire:

1. Eclipse fonctionne parfaitement avec "B"
2. Netbeans a un problème de retour à la ligne qui peut être résolu (car le problème ne se produit pas dans l'éclipse) (sans ajouter d'espace après B ("B")).

Oui, le coupable est définitivement le coup de mots. Lorsque j'ai testé vos deux programmes, NetBeans IDE 8.2 m'a donné le résultat suivant.

1. Première matrice: O et # = 6,03 secondes
2. Deuxième matrice: O et B = 50,97 secondes

En regardant attentivement votre code, vous avez utilisé un saut de ligne à la fin de la première boucle. Mais vous n'avez utilisé aucun saut de ligne dans la deuxième boucle. Vous allez donc imprimer un mot de 1000 caractères dans la deuxième boucle. Cela provoque un problème de retour à la ligne. Si nous utilisons un caractère non mot "" après B, il ne faut que 5,35 secondes pour compiler le programme. Et si nous utilisons un saut de ligne dans la deuxième boucle après avoir passé 100 valeurs ou 50 valeurs, cela ne prend que 8,56 secondes et 7,05 secondes respectivement.

Random r = new Random();
for (int i = 0; i < 1000; i++) {
    for (int j = 0; j < 1000; j++) {
        if(r.nextInt(4) == 0) {
            System.out.print("O");
        } else {
            System.out.print("B");
        }
        if(j%100==0){               //Adding a line break in second loop      
            System.out.println();
        }                    
    }
    System.out.println("");                
}

Un autre conseil est de changer les paramètres de l'EDI NetBeans. Tout d'abord, allez dans Outils NetBeans et cliquez sur Options . Après cela, cliquez sur Editeur et accédez à l' onglet Formatage . Sélectionnez ensuite l' option N'importe où dans le retour à la ligne . Il faudra près de 6,24% moins de temps pour compiler le programme.