基本类型中的boolean占用多少内存？

Question

是由jvm规范决定的，还是由jvm实现来决定？

Answer 1

何苦来着？本来boolean类型占用1个bit就可以了，为什么非要设计的占用1个byte。

Answer 2

如果boolean只用一个bit的话，那指向它的指针或者引用怎么办？ 指针可是没办法指向一个bit的啊！

Answer 3

jvm规范,至于占用一个字节，我估计是jvm的内部是按照字节进行运算的。

Answer 4

和int一样参考《深入java虚拟机》

Answer 5

jokerjava(冷血) ( ) 信誉：96  2006-07-20 17:10:00  得分: 0  
 
 
   好像是28个字节
  
 
---------------你指的一个Boolean对象实例？

Answer 6

java 1.5不分Boolean 和 boolean了吧

Answer 7

错，不是1个byte而是2个byte，
Java对数据的处理要么是2位要么是4位，即使你只需要1个bit

Answer 8

jokerjava(冷血) ( ) 信誉：96  2006-7-20 17:45:54  得分: 0  
 
 
   
java 1.5不分Boolean 和 boolean了吧  
 
----------------------------
嗯？还有这事？一个是基本类型，一个是对象，怎么可能统一起来了？

Answer 9

一个是基本类型，一个是对象，怎么可能统一起来了？
1.5能自动拆包封包 所以写程序 Boolean <-> boolean可以互换 
具体怎么统一的  是不是按对象统一的  不清楚

Answer 10

jokerjava(冷血) ( ) 信誉：96  2006-07-21 15:07:00  得分: 0  
 
 
   一个是基本类型，一个是对象，怎么可能统一起来了？
1.5能自动拆包封包 所以写程序 Boolean <-> boolean可以互换 
具体怎么统一的  是不是按对象统一的  不清楚
  
 
---------------------------------自动拆包封包和具体占用多少个内存应该没有关系，如果这样也算是统一的话，那也只是动态的，表象的统一。

Answer 11

天啦.什么基本功啊? 都成星的人了~~~居然说基本类型只要一个bit就行了? 汗~~~~java又不是c编程.c的基本类型最小也要8bit啊~~~否则cpu怎么寻址啊????????????????????操作bit位要两个时钟周期,32位cpu的按照32bit录址.8位cpu按8bit寻址.没见过1位的cpu

Answer 12

package test;import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.util.IdentityHashMap;
import java.util.Map;public class CacheSizes {
    private static class NullOutputStream extends OutputStream {        public void write(int b) throws IOException {
            size++;
        }        public void write(byte b[]) throws IOException {
            size += b.length;
        }        public void write(byte b[], int off, int len) {
            size += len;
        }        public int size() {
            return size;
        }        int size;        private NullOutputStream() {
            size = 0;
        }    }
    private CacheSizes() {
    }    public static int sizeOfInt() {
        return ((Integer) primitiveSizes.get(Integer.TYPE)).intValue();
    }    public static int sizeOfChar() {
        return ((Integer) primitiveSizes.get(Character.TYPE)).intValue();
    }    public static int sizeOfBoolean() {
        return ((Integer) primitiveSizes.get(Boolean.TYPE)).intValue();
    }    public static int sizeOfLong() {
        return ((Integer) primitiveSizes.get(Long.TYPE)).intValue();
    }    public static int sizeOfDouble() {
        return ((Integer) primitiveSizes.get(Double.TYPE)).intValue();
    }    private static int getSize(Class clazz) {
        int size = 0;
        try {
            NullOutputStream out = new NullOutputStream();
            ObjectOutputStream outObj = new ObjectOutputStream(out);
            outObj.writeObject(clazz);
            size = out.size();
        } catch (IOException ioe) {
        }
        return size;
    }    private static final Map primitiveSizes = new IdentityHashMap() {
        {
            put(Boolean.TYPE, new Integer(CacheSizes.getSize(Boolean.TYPE)));
            put(Byte.TYPE, new Integer(CacheSizes.getSize(Byte.TYPE)));
            put(Character.TYPE, new Integer(CacheSizes.getSize(Character.TYPE)));
            put(Short.TYPE, new Integer(CacheSizes.getSize(Short.TYPE)));
            put(Integer.TYPE, new Integer(CacheSizes.getSize(Integer.TYPE)));
            put(Float.TYPE, new Integer(CacheSizes.getSize(Float.TYPE)));
            put(Double.TYPE, new Integer(CacheSizes.getSize(Double.TYPE)));
            put(Long.TYPE, new Integer(CacheSizes.getSize(Long.TYPE)));
        }
    };    public static void main(String[] args) {
        System.out.println(sizeOfBoolean());
        System.out.println(sizeOfInt());
        System.out.println(sizeOfLong());
        System.out.println(sizeOfChar());
        System.out.println(sizeOfDouble());
    }
}自动拆包封包具体怎么实现 不清楚    
很可能Boolean 和 boolean实现一样 占用内存也一样

Answer 13

我认为自动拆箱装箱是由编译器来动态实现的，否则这个代价也太大了。
因为照这样说，int和Integer等等占用内存也是一样的了

Answer 14

int的长度是最自然的，又不是有海量的boolean，浪费一点空间，换来的是效率，难道不值得吗？能按bit寻址的CPU是有的，但是效率绝对比按字或字节来寻址低得多得多，而且我敢肯定JVM不能按bit导址。

Answer 15

以前没有想过这个问题，最近做嵌入式开发，处理图片（主要是黑白二值Tiff文件），tiff里图像数据是用byte数组来保存，一个byte代表8个点（每行的dot数如果不是8的倍数，最有一个byte就只是用前几位）。后来为了程序简单明了，就把它转化为boolean矩阵了，这样数组占用内存就比原来大多了，经常抛出内存不够的异常。所以才想到boolean到底用了多少内存。