Java基础类型占用几个字节

Java基本数据类型占用字节数

数据类型	占用字节数
byte	1
boolean	1
char	2
short	2
int	4
float	4
double	8
long	8

  昂，按理说这是极其极其简单并且基础的问题，但是…前几天做一个题做错了…碰巧这两天get到了获取一个数是n的几次幂的方法，于是我决定仔细研究一下基本数据类型的大小。然后，我更加不知所措了…事情是这样的：

public class Easy {
//    public static int a = 0;
    public static void main(String[] args) {
        Byte b = new Byte("127");
        Short s = new Short("1");
        Integer a = new Integer("1");
        Long l = new Long("1");
        Character c = new Character('1');
        Float f = new Float("1");
        Double d = new Double("1");
        Boolean bool = new Boolean("0");

        System.out.println(b + " -- Byte : " + Math.log(Byte.MAX_VALUE + 1)/Math.log(2));
        System.out.println(s + " -- Short : " + Math.log(Short.MAX_VALUE + 1)/Math.log(2));
        System.out.println(a + " -- Integer : " + Math.log(Integer.MAX_VALUE + 1)/Math.log(2));
        System.out.println(l + " -- Long : " + Math.log(Long.MAX_VALUE + 1)/Math.log(2));
        System.out.println(c + " -- Character : " + Math.log(Character.MAX_VALUE + 1)/Math.log(2));
        System.out.println(f + " -- Float : " + Math.log(Float.MAX_VALUE + 1)/Math.log(2));
        System.out.println(d + " -- Double : " + Math.log(Double.MAX_VALUE + 1)/Math.log(2));
        System.out.println(bool);
    }
}

输出是这样的：

127 – Byte : 7.0
1 – Short : 15.0
1 – Integer : NaN
1 – Long : NaN
1 – Character : 16.0
1.0 – Float : 127.99999991400867
1.0 – Double : 1024.0
false

哎？Integer和Long咋NaN？我点点点，源码成了native，这样说的：

/**
     * Returns the natural logarithm (base <i>e</i>) of a {@code double}
     * value. Special cases:
     * <ul><li>If the argument is NaN or less than zero, then the result
     * is NaN.
     * <li>If the argument is positive infinity, then the result is
     * positive infinity.
     * <li>If the argument is positive zero or negative zero, then the
     * result is negative infinity.</ul>
     *
     * @param   a   a value
     * @return  the value ln&nbsp;{@code a}, the natural logarithm of
     *          {@code a}.
     */
    public static native double log(double a);

就是说我传进来的就不是个数字，难道是数太大？改吧改吧把+1去掉

System.out.println(a + " -- Integer : " + Math.log(Integer.MAX_VALUE)/Math.log(2));
System.out.println(l + " -- Long : " + Math.log(Long.MAX_VALUE)/Math.log(2));

1 – Integer : 30.999999999328196
1 – Long : 63.0

看起来不直观哎，再改吧改吧

System.out.println(b + " -- Byte : " + Math.log(Byte.MAX_VALUE + 1)/Math.log(2)/8);
System.out.println(s + " -- Short : " + Math.log(Short.MAX_VALUE + 1)/Math.log(2)/8);
System.out.println(a + " -- Integer : " + Math.log(Integer.MAX_VALUE)/Math.log(2)/8);
System.out.println(l + " -- Long : " + Math.log(Long.MAX_VALUE)/Math.log(2)/8);
System.out.println(c + " -- Character : " + Math.log(Character.MAX_VALUE + 1)/Math.log(2)/8);
System.out.println(f + " -- Float : " + Math.log(Float.MAX_VALUE + 1)/Math.log(2)/8);
System.out.println(d + " -- Double : " + Math.log(Double.MAX_VALUE)/Math.log(2)/8);
System.out.println(bool);

127 – Byte : 0.875
1 – Short : 1.875
1 – Integer : 3.8749999999160245
1 – Long : 7.875
1 – Character : 2.0
1.0 – Float : 15.999999989251084
1.0 – Double : 128.0
false

嗯~不错不错，都跟预想的比较接近…咦等一下！Double是啥情况？为啥这么大！

还有Character，说好的四个字节呢？咋只有2？难道是Character最小值比较小？我改改改

System.out.println(c + " -- Character : " + Math.log(Character.MAX_VALUE - Character.MIN_VALUE + 1)/Math.log(2)/8);

1 – Character : 2.0

e…干得漂亮，我被打败了…那是为啥捏？而且Double总不能占128个字节吧？Double不是64位嘛？即便在64位的电脑上它是128位（瞎猜的应该不是吧），那也是位啊我已经把算出来的结果除以8了哎！难道是因为double不能进行精确计算？可是…我看128这个数倒是挺精确的…

public static final double MAX_VALUE = 0x1.fffffffffffffP+1023; // 1.7976931348623157e+308

嗯…确实是2^1024，所以才能开出来1024嘛，这么大的数…不是只有64个二进制位存储嘛？这超出了我的知识范畴…

又去搜了一下，翻了官方文档，但是好像没有解释这个哎，又去搜了一些博客

这个看起来挺靠谱的~

百度标准答案是这样子的：

double是n*2^m(n乘以2的m次方)这种形式存储的，只需要记录n和m两个数就行了，m的值影响范围大，所以表示的范围比long大。
但是m越大，n的精度就越小，所以double并不能把它所表示的范围里的所有数都能精确表示出来，而long就可以。

但是我看了半天都没理解啥意思，然后查了一些资料。个人整理如下：
贴上一些整数类型的范围：
1.整型 (一个字节占8位)
类型 存储需求 bit数 取值范围 备注
int 4字节 48 (32) -2^31~231-1
short 2字节 28 (16) -2^15~215-1
long 8字节 88 (64) -2^63~263-1
byte 1字节 18 (8) -2^7~27-1 = -128~127

    2.浮点型
    类型              存储需求     bit数            取值范围                        备注
    float              4字节        4*8 (32)         3.4028235E38             ~= 3.4*10^38
    double             8字节        8*8 (64)      1.7976931348623157E308         ~=1.7*10^308

噢~~~~~ 好像有那么一点点计算机课老师讲过的印象了…好像还是我的男神张平老师讲的呢…吧！哼！你不配做张平老师的迷妹！反思去吧！！

嗷！对了，基础类型的包装类里头还有这样两个字段：

 /**
     * The number of bits used to represent a {@code double} value.
     *
     * @since 1.5
     */
    public static final int SIZE = 64;

    /**
     * The number of bytes used to represent a {@code double} value.
     *
     * @since 1.8
     */
    public static final int BYTES = SIZE / Byte.SIZE;

噢~ 所以这才是人家定的位数呢，不过自己验证一下也莫得问题~ok睡觉吧！
啊！Character那个还没有搞明白呢！不行太困了-.-明天再说吧！

啊！又检查了一遍，发现Float是15.多…也跟预想的不一样啊，解释上面已经跟Double一起复制过来啦！哎呀哎呀十分钟又过去了…睡觉睡觉（是时候找本计算机基础知识翻一翻了，前两天买了深入理解计算机系统，感觉很复杂很沉重的一本书，啊瞎说，是很充实！最近还忙着看其他东西，看完了就忘了…是时候启动投简历程序了哎！要不啥时候是个头啊！睡了睡了！呀还没护肤呢！）
啊！来自第二天的更正！Character本来就是占两个字节的！不是4个字节！