¿Cuál es el tamaño de una variable booleana en Java?

¿Alguien puede decir el tamaño de bit de boolean en Java?

Depende de la máquina virtual.

Depende de la máquina virtual, pero es fácil adaptar el código de una pregunta similar sobre bytes 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();
    }
}

Para reiterar, esto depende de la VM, pero en mi computadora portátil con Windows que ejecuta Sun's JDK build 1.6.0_11 obtuve los siguientes resultados:

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

Eso sugiere que los valores booleanos se pueden empaquetar básicamente en un byte cada uno mediante la JVM de Sun.

La información real representada por un valor booleano en Java es un bit: 1 para verdadero, 0 para falso. Sin embargo, el tamaño real de una variable booleana en la memoria no está definido con precisión por la especificación de Java. Consulte Tipos de datos primitivos en Java .

El tipo de datos booleano solo tiene dos valores posibles: verdadero y falso. Utilice este tipo de datos para indicadores simples que rastrean condiciones verdaderas / falsas. Este tipo de datos representa un bit de información, pero su "tamaño" no es algo que esté definido con precisión.

En otros comentarios...

Si está pensando en utilizar una matriz de objetos booleanos, no lo haga. En su lugar, utilice un BitSet: tiene algunas optimizaciones de rendimiento (y algunos métodos extra agradables que le permiten obtener el siguiente bit activado / desactivado).

Leí que Java reserva un byte para un booleantipo de datos, pero usa solo un bit. Sin embargo, la documentación dice que "su" tamaño "no es algo que esté definido con precisión" . Mira aquí.

Los booleanvalores se compilan en intel tipo de datos en JVM. Vea aquí .

El tamaño del booleano en Java depende de la máquina virtual. pero cualquier objeto Java está alineado con una granularidad de 8 bytes. Un booleano tiene 8 bytes de encabezado, más 1 byte de carga útil, para un total de 9 bytes de información. La JVM luego lo redondea al siguiente múltiplo de 8. por lo que la única instancia de java.lang.Boolean ocupa 16 bytes de memoria.

No está definido; Hacer cosas como las que sugirió Jon Skeet le dará una aproximación en una plataforma determinada, pero la forma de saberlo con precisión para una plataforma específica es usar un generador de perfiles.