Quelle est la taille d'une variable booléenne en Java?

Quelqu'un peut-il dire la taille en bits de booléen en Java?

Cela dépend de la machine virtuelle.

Cela dépend de la machine virtuelle, mais il est facile d'adapter le code à partir d'une question similaire concernant les octets en Java :

class LotsOfBooleans
{
    boolean a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af;
    boolean b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd, be, bf;
    boolean c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, ca, cb, cc, cd, ce, cf;
    boolean d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, da, db, dc, dd, de, df;
    boolean e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, ea, eb, ec, ed, ee, ef;
}

class LotsOfInts
{
    int a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af;
    int b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd, be, bf;
    int c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, ca, cb, cc, cd, ce, cf;
    int d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, da, db, dc, dd, de, df;
    int e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, ea, eb, ec, ed, ee, ef;
}


public class Test
{
    private static final int SIZE = 1000000;

    public static void main(String[] args) throws Exception
    {        
        LotsOfBooleans[] first = new LotsOfBooleans[SIZE];
        LotsOfInts[] second = new LotsOfInts[SIZE];

        System.gc();
        long startMem = getMemory();

        for (int i=0; i < SIZE; i++)
        {
            first[i] = new LotsOfBooleans();
        }

        System.gc();
        long endMem = getMemory();

        System.out.println ("Size for LotsOfBooleans: " + (endMem-startMem));
        System.out.println ("Average size: " + ((endMem-startMem) / ((double)SIZE)));

        System.gc();
        startMem = getMemory();
        for (int i=0; i < SIZE; i++)
        {
            second[i] = new LotsOfInts();
        }
        System.gc();
        endMem = getMemory();

        System.out.println ("Size for LotsOfInts: " + (endMem-startMem));
        System.out.println ("Average size: " + ((endMem-startMem) / ((double)SIZE)));

        // Make sure nothing gets collected
        long total = 0;
        for (int i=0; i < SIZE; i++)
        {
            total += (first[i].a0 ? 1 : 0) + second[i].a0;
        }
        System.out.println(total);
    }

    private static long getMemory()
    {
        Runtime runtime = Runtime.getRuntime();
        return runtime.totalMemory() - runtime.freeMemory();
    }
}

Pour réitérer, cela dépend de la VM, mais sur mon ordinateur portable Windows exécutant le JDK build 1.6.0_11 de Sun, j'ai obtenu les résultats suivants:

Size for LotsOfBooleans: 87978576
Average size: 87.978576
Size for LotsOfInts: 328000000
Average size: 328.0

Cela suggère que les booléens peuvent fondamentalement être regroupés dans un octet chacun par la JVM de Sun.

Les informations réelles représentées par une valeur booléenne en Java sont d'un bit: 1 pour vrai, 0 pour faux. Cependant, la taille réelle d'une variable booléenne en mémoire n'est pas définie avec précision par la spécification Java. Voir Types de données primitifs en Java .

Le type de données booléen n'a que deux valeurs possibles: true et false. Utilisez ce type de données pour les indicateurs simples qui suivent les conditions vrai / faux. Ce type de données représente un bit d'information, mais sa "taille" n'est pas définie avec précision.

En passant ...

Si vous envisagez d'utiliser un tableau d'objets booléens, ne le faites pas. Utilisez plutôt un BitSet - il a quelques optimisations de performances (et quelques méthodes supplémentaires intéressantes, vous permettant d'obtenir le prochain bit set / unset).

J'ai lu que Java réserve un octet pour un booleantype de données, mais il n'utilise qu'un seul bit. Cependant, la documentation dit que "sa" taille "n'est pas quelque chose qui est précisément défini" . Vois ici.

Les booleanvaleurs sont compilées en inttype de données dans JVM. Regardez ici .

La taille du booléen en java dépend de la machine virtuelle. mais tout objet Java est aligné sur une granularité de 8 octets. Un booléen a 8 octets d'en-tête, plus 1 octet de charge utile, pour un total de 9 octets d'informations. La JVM l'arrondit ensuite au multiple suivant de 8. Ainsi, la seule instance de java.lang.Boolean occupe 16 octets de mémoire.

Ce n'est pas défini; faire des choses comme Jon Skeet l'a suggéré vous donnera une approximation sur une plate-forme donnée, mais le moyen de savoir précisément pour une plate-forme spécifique est d'utiliser un profileur.