精华内容
下载资源
问答
  • Java中各种基本类型大小

    千次阅读 2018-06-21 21:54:11
    java中有两个方法分别是求最大值最小值最小值MIN_VALUE最大值MAX_VALUE注意大小写,java语言区分大小写,这里是大写整型Integer如下:如果超过最大值那么编译器会输出最小值,如上图的s,其他类型都可以进行测试,...

    在java中有两个方法分别是求最大值最小值

    最小值MIN_VALUE

    最大值MAX_VALUE

    注意大小写,java语言区分大小写,这里是大写

    整型Integer

    如下:


    如果超过最大值那么编译器会输出最小值,如上图的s,其他类型都可以进行测试,就不一一举例了。

    浮点型双精度Double

    如下:


    可以看出Double类型使用的是科学记数法,看得出来Double类型很强大。

    长整型Long



    短整型Short


    字节型Byte


    浮点型单精度Float


    字符串类型String的大小使用户给定的,所以没有固定的最大最小值。

    在java中字符类型char是占两个字节的,因为需要满足汉字以及Unico编码(一个汉字在计算机占两个字节)。


    展开全文
  • Java 8种数据类型大小

    万次阅读 2018-03-28 14:56:04
    Java语言提供了八种基本类型。六种数字类型(四个整数型,两个浮点型),一种字符类型,还有一种布尔型。   基本类型 大小 取值范围 装箱基本类型 int 4个字节 -2^31 ~ 2^31-1 Integer ...

    Java语言提供了八种基本类型。六种数字类型(四个整数型,两个浮点型),一种字符类型,还有一种布尔型。

     

    基本类型大小取值范围装箱基本类型
    int4个字节-2^31 ~ 2^31-1Integer
    char2个字节 Character
    byte1个字节-2^7 ~ 2^7-1Byte
    short2个字节-2^15 ~ 2^15-1Short
    long8个字节-2^63 ~ 2^63-1Long
    float4个字节 Float
    double8个字节 Double
    boolean1或者4个字节true ~ falseBoolean

     

    1byte = 1字节 = 8 bit(位)

     

    展开全文
  • Java的八种基本数据类型及其大小

    千次阅读 2020-07-16 12:46:45
    Java的八种基本数据类型: 数据类型 名称 大小(B) 注:1B = 8b 包装器 byte 字节型 1 Byte short 字符型 2 Short int 短整型 4 Integer long 整形 8 Long ...

     

    Java的八种基本数据类型:

    数据类型名称大小(B) 注:1B = 8b包装器
    byte字节型1Byte
    short字符型2Short
    int短整型4Integer
    long整形8Long
    float单精度浮点型4Float
    double双精度浮点型8Double
    char字符型2Character
    boolean布尔不同情况下不同Boolean

      注:布尔类型不同情况下使用的空间不一致,大致有如下几种情况:

     1.单个的boolean 类型变量在编译的时候是使用的int 类型

    boolean a=true;//这个a在JVM中占4个字节即:32位。

     2.boolean 类型的数组时,在编译的时候是作为byte array来编译的所以boolean 数组里面的每一个元件占一个字节

    boolean[] b = new boolean[10];//数组时,每一个boolean在JVM中占一个字节。

    理由:

    1)JAVA规范中没有定义boolean类型的大小。

    2)但是:在JVM规范第2版中讲得十分清楚。我上边的结论就是从它当中取出来的。

    根据:(JVM规范第2版 3.3.4节)

    Instead, expressions in the Java programming language that operate on boolean values are compiled to use values of the Java virtual machine int data type.  

    Where Java programming language boolean values are mapped by compilers to values of Java virtual machine type int, the compilers must use the same encoding. 而:Java virtual machine type int, whose values are 32-bit signed two's-complement integers。

    Arrays of type boolean are accessed and modified using the byte array instructions  

    In Sun's JDK releases 1.0 and 1.1, and the Java 2 SDK, Standard Edition, v1.2, boolean arrays in the Java programming language are encoded as Java virtual machine byte arrays, using 8 bits per boolean element.

    3. 也有说都是1bit的,仁者见仁智者见智,具体还是要看JVM是不是按照他的说明来做的。

     

    基本数据类型的运算和转换:

    基本数据类型进行运算时分为自动转换和强制转换:

    1.自动转换 (小 -> 大)

    当范围‘小’的数据和字节‘大’的数据运算时,系统自动将小数据转换成大数据进行运算。这些类型由"小"到"大"分别为 (byte,short,char)--int--long--float—double;

    byte b;int i=b; long l=b; float f=b; double d=b;//此语句可以在Java中直接通过:

    注意char -> int 时,int 将会保存其ASCII码。

    2.强制转换 (大 -> 小)

    short i=99 ;
    char c=(char)i;
    System.out.println("output:"+c);
    //对于byte,short,char三种类型而言,他们是平级的

    注意:

    ①所有的byte,short,char型的值将被提升为int型;

    ②如果有一个操作数是long型,计算结果是long型;

    ③如果有一个操作数是float型,计算结果是float型;

    ④如果有一个操作数是double型,计算结果是double型;

    例, byte b; b=3; b=(byte)(b*3);//必须声明byte。

     

    学完了,给大家补全个细节性问题:

    提问:short b = 3; 操作1: b = b + 1; 操作2:b += 1;这两种操作方式都正确?

    解答:操作1不正确,因为b时short,b + 1的1是int, 赋值给b的时候会出现类型问题(int ->long).所以要对运算后值进行类型强转;

    short b = 2;
    b = (short)(b + 1);
    

    操作2正确:

    后面一句没有错是因为Java语言规范中讲到,复合赋值(E1 op=E2)等价于简单赋值(E1=(T)((E1) op (E2))),而(s1 += 1)表达式使用的是复合赋值操作符,复合赋值表达式自动地将所执行计算的结果转型为其左侧变量的类型。如果结果的类型与该变量的类型相同,那么这个转型不会造成任何影响。

     

     

    展开全文
  • Java中包装类型大小比较

    千次阅读 2019-03-29 14:19:00
    31: invokestatic #2 // Method java/lang/Integer.valueOf: (I)Ljava/lang/Integer; 34: astore_1 35: sipush 128 38: invokestatic #2 // Method java/lang/Integer.valueOf: (I)Ljava/lang/Integer; 41: a...

    一、案例

    我们先来看下这个例子:

    public class IntegerTest {
    
        public static void main(String[] args) {
            Integer a = 127;
            Integer b = 127;
            System.out.println(a == b);
    
            a = 128;
            b = 128;
            System.out.println(a == b);
    
            a = -128;
            b = -128;
            System.out.println(a == b);
    
            a = -129;
            b = -129;
            System.out.println(a == b);
        }
    
    }

    程序运行结果:

    true
    false
    true
    false

    看到这个结果,是不是很疑惑,不应该都是true吗?

    二、剖析

    要弄懂这其中的缘由,我们要先明白上面的程序到底做了什么?

    javap是JDK自带的反汇编器,可以查看java编译器为我们生成的字节码。通过它,我们可以对照源代码和字节码,从而了解很多编译器内部的工作。

    于是,我们通过javap命令反编译IntegerTest.class字节码文件,得到结果如下:

    $ javap -c IntegerTest
    ▒▒▒▒: ▒▒▒▒▒▒▒ļ▒IntegerTest▒▒▒▒com.lian.demo.IntegerTest
    Compiled from "IntegerTest.java"
    public class com.lian.demo.IntegerTest {
      public com.lian.demo.IntegerTest();
        Code:
           0: aload_0
           1: invokespecial #1                  // Method java/lang/Object."<init>":                                                                                                              ()V
           4: return
    
      public static void main(java.lang.String[]);
        Code:
           0: bipush        127
           2: invokestatic  #2                  // Method java/lang/Integer.valueOf:                                                                                                              (I)Ljava/lang/Integer;
           5: astore_1
           6: bipush        127
           8: invokestatic  #2                  // Method java/lang/Integer.valueOf:                                                                                                              (I)Ljava/lang/Integer;
          11: astore_2
          12: getstatic     #3                  // Field java/lang/System.out:Ljava/                                                                                                              io/PrintStream;
          15: aload_1
          16: aload_2
          17: if_acmpne     24
          20: iconst_1
          21: goto          25
          24: iconst_0
          25: invokevirtual #4                  // Method java/io/PrintStream.printl                                                                                                              n:(Z)V
          28: sipush        128
          31: invokestatic  #2                  // Method java/lang/Integer.valueOf:                                                                                                              (I)Ljava/lang/Integer;
          34: astore_1
          35: sipush        128
          38: invokestatic  #2                  // Method java/lang/Integer.valueOf:                                                                                                              (I)Ljava/lang/Integer;
          41: astore_2
          42: getstatic     #3                  // Field java/lang/System.out:Ljava/                                                                                                              io/PrintStream;
          45: aload_1
          46: aload_2
          47: if_acmpne     54
          50: iconst_1
          51: goto          55
          54: iconst_0
          55: invokevirtual #4                  // Method java/io/PrintStream.printl                                                                                                              n:(Z)V
          58: bipush        -128
          60: invokestatic  #2                  // Method java/lang/Integer.valueOf:                                                                                                              (I)Ljava/lang/Integer;
          63: astore_1
          64: bipush        -128
          66: invokestatic  #2                  // Method java/lang/Integer.valueOf:                                                                                                              (I)Ljava/lang/Integer;
          69: astore_2
          70: getstatic     #3                  // Field java/lang/System.out:Ljava/                                                                                                              io/PrintStream;
          73: aload_1
          74: aload_2
          75: if_acmpne     82
          78: iconst_1
          79: goto          83
          82: iconst_0
          83: invokevirtual #4                  // Method java/io/PrintStream.printl                                                                                                              n:(Z)V
          86: sipush        -129
          89: invokestatic  #2                  // Method java/lang/Integer.valueOf:                                                                                                              (I)Ljava/lang/Integer;
          92: astore_1
          93: sipush        -129
          96: invokestatic  #2                  // Method java/lang/Integer.valueOf:                                                                                                              (I)Ljava/lang/Integer;
          99: astore_2
         100: getstatic     #3                  // Field java/lang/System.out:Ljava/                                                                                                              io/PrintStream;
         103: aload_1
         104: aload_2
         105: if_acmpne     112
         108: iconst_1
         109: goto          113
         112: iconst_0
         113: invokevirtual #4                  // Method java/io/PrintStream.printl                                                                                                              n:(Z)V
         116: return
    }
    

    标号2的code调用了静态的valueOf方法解析Integer实例,也就是说Integer a = 127; 在编辑期进行了自动装箱,即把基本数据类型转换为包装类型。

    从JDK1.5就开始引入了自动拆装箱的语法功能,也就是系统将自动进行基本数据类型和与之相对应的包装类型之间的转换,这使得程序员书写代码更加方便。

    • 装箱过程是通过调用包装器的valueOf方法实现的。
    • 拆箱过程是通过调用包装器的xxxValue方法实现的(xxx表示对应的基本数据类型)

    当给a赋值时,实际上是调用了Integer.valueOf(int i)方法。其JDK 8源码如下:

    public static Integer valueOf(int i) {
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }

    继续看IntegerCache源码:

    private static class IntegerCache {
            static final int low = -128;
            static final int high;
            static final Integer cache[];
    
            static {
                // high value may be configured by property
                int h = 127;
                String integerCacheHighPropValue =
                    sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
                if (integerCacheHighPropValue != null) {
                    try {
                        int i = parseInt(integerCacheHighPropValue);
                        i = Math.max(i, 127);
                        // Maximum array size is Integer.MAX_VALUE
                        h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                    } catch( NumberFormatException nfe) {
                        // If the property cannot be parsed into an int, ignore it.
                    }
                }
                high = h;
    
                cache = new Integer[(high - low) + 1];
                int j = low;
                for(int k = 0; k < cache.length; k++)
                    cache[k] = new Integer(j++);
    
                // range [-128, 127] must be interned (JLS7 5.1.7)
                assert IntegerCache.high >= 127;
            }
    
            private IntegerCache() {}
        }

    看到了没,当赋的基本数据类型值不在[-128, 127]之间,会去Java堆内存中new一个对象出来,显然它们不是两个不同的对象,所以结果false;

    而值在[-128, 127]之间,会直接从IntegerCache中获取,也就是从缓存中取值,不用再创建新的对象,即同一个对象,所以结果true。

    关系操作符“==”生成的是一个boolean结果,它们计算的是操作数的值之间的关系。如果是基本类型则直接判断其值是否相等,如果是对象则判断是否是同一个对象的引用,即其引用变量所指向的对象的地址是否相同。

    三、结论

    在阿里巴巴Java开发手册中,它是这么描述的:

    【强制】所有的相同类型的包装类对象之间值的比较,全部使用equals方法比较。

    说明:对于Integer var = ? 在-128 至 127范围内的赋值,Integer对象是在IntegerCache.cache产生,会复用己有对象,这个区间内的Integer值可以直接使用==进行判断,但是这个区间之外的所有数据,都会在堆上产生,并不会复用己有对象,这是一个大坑,推荐使用equals方法进行判断。

    可能你还会问,问啥是equals方法?这就要看equals方法到底做了什么?可以参考《Java中关系操作符“==”和equals()方法的区别

    我们来看下Integer类中equals源码:

    public boolean equals(Object obj) {
            if (obj instanceof Integer) {
                return value == ((Integer)obj).intValue();
            }
            return false;
        }

    直接通过intValue()方法拆箱,即将包类型转换为基本数据类型。所以equals方法比较的是它们的值了。

    四、注意事项

    包装类型缓存赋值范围基本数据类型二进制数

    Boolean

    全部缓存

    boolean1

    Byte

    [-128, 127]

    byte8

    Character

    <=127

    char16

    Short

    [-128, 127]

    short16

    Integer

    [-128, 127]

    int32

    Long

    [-128, 127]

    long64

    Float

    没有缓存

    float32

    Double

    没有缓存

    double64

    所以两个同类型的Float或Double类型的==比较永远都是返回false。

    转载于:https://my.oschina.net/lienson/blog/3029667

    展开全文
  • Java之基本数据类型 Sizeof 大小
  • Java 基本数据类型大小

    千次阅读 2018-11-28 16:18:29
    Java基本数据类型 byte 8bit short 16bit int 32bit long 64bit float 32bit double 64bit char 16bit private static void calSize() { System.out.println("Integer...
  • JAVA 8种基本数据类型大小

    千次阅读 2020-10-18 19:29:22
    Java中,基础数据类型大小在所有机器上都是一样的 public class DataTypeByte { public static void main(String[] args) { // TODO Auto-generated method stub System.out.println(“byte所占位数” + Byte...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些...Java和C++的区别Oracle JDK 和 OpenJDK 的对比基础语法数据类型Java有哪些数据类型switc...
  • java常用数据类型比较大小

    千次阅读 2018-02-03 17:03:57
    java个数据类型比较大小
  • java BigDecimal类型 比较大小

    千次阅读 2018-04-09 13:58:24
    一般我们进行类型比较有.equals()、==、.compareTo()但是当比较bigdecimal类型时最好使用.compareTo()来比较大小BigDecimal a=BigDecimal.ZERO;BigDecimal b=BigDecimal.valueOf(0.000);BigDecimal c=BigDecimal....
  • java 各种类型比较大小

    千次阅读 2018-10-15 15:18:20
    1、float浮点型 float f=1.0f; String a="1.2"; float f2=Float.parseFloat(a);//将String转为float Math.abs(f - 0) &gt; Float.parseFloat(a)  
  • Java 基本数据类型大小

    千次阅读 2018-08-01 10:02:24
    在c与c++中,基本数据类型大小在不同机器上可能是不同的,所以,提供sizeof()用于获取实际大小,但是,在Java中,基础数据类型大小在所有机器上都是一样的,所以Java没有sizeof()方法。 基本类型 大小...
  • java压缩图片文件大小

    热门讨论 2014-05-14 11:10:20
    java 开发压缩图片文件大小,2m-->200k 不是压缩宽高的
  • Java基本数据类型大小

    千次阅读 2019-05-20 19:43:40
    boolean 1位 byte 8位 short 16位 char 16位 int 32位 float 32位 long 64位 double 64位 ...
  • Java基本类型所占存储空间大小

    千次阅读 2018-07-20 17:21:57
    大小 最小值 最大值 包装器类型 boolean ———— ———— ———— Boolean char 两个字节 Unicode 0 Unicode 2^16-1 Character byte 一个字节 -128 127 ...
  • JAVA double类型比较大小

    万次阅读 2018-01-16 16:15:00
    一、问题描述 把从数据库里查询出来的数据,金额小于...先把他们转成BigDecimal类型,然后在利用BigDecimal中的compareTo方法去比较大小,实现如下: @org.junit.Test public void Test(){ BigDecimal big
  • Java的数据类型分为基本数据类型和引用数据类型 基本数据类型(四类八种) 名称 范围 字节大小 byte -2^7~2^7-1 1字节 short -2^15~2^15-1 2字节 int -2^31~2^31-1 4字节 long ...
  • java基本类型大小(从小到大)

    千次阅读 2019-10-28 08:36:17
    boolean 不知道几个字节 byte 1个字节 chart 2个字节 short 2个字节 int 4个字节 float 4个字节 long 8个字节 double 8个字节
  • java基础——基本数据类型大小

    千次阅读 2018-03-03 09:32:09
    Java语言提供了八种基本类型。六种数字类型(四个整数型(默认是int 型),两个浮点型(默认是double 型)),一种字符类型,还有一种布尔型。byte:byte数据类型是8位、有符号的,以二进制补码表示的整数;(256个...
  • java比较String类型日期的大小

    千次阅读 2019-03-25 15:01:29
    import java.text.DateFormat; import java.text.NumberFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.*; public class DateUtils { /** * 字...
  • java中Date日期类型大小比较

    万次阅读 多人点赞 2018-07-28 15:29:53
    java.util.Date类实现了Comparable接口,可以直接调用Date的compareTo()方法来比较大小 String beginTime = "2018-07-28 14:42:32"; String endTime = "2018-07-29 12:26:32"; ...
  • Java之 string 类型大小

    万次阅读 2018-10-25 15:13:23
    compare To: String的compareTo其实就是依次比较两个字符串ASC码。如果两个字符的ASC码相等则继续后续比较,否则直接返回两个ASC的差值。如果两个字符串完全一样,则返回0。来看一下代码。 ...
  • Java基础笔记(14)—— Java的基础类型和字节大小 Java基础笔记(14)—— Java的基础类型和字节大小 Java语言提供了八种基本类型。六种数字类型(四个整数型(默认是int 型),两个浮点型(默认是double 型)),...
  • Java 数据类型(基本数据类型、引用数据类型)

    千次阅读 多人点赞 2013-12-11 23:40:11
    Java 数据类型(基本数据类型、引用数据类型) 简单的介绍
  • Java的程序里date类型怎么比较大小

    千次阅读 2019-06-08 09:20:35
    java的程序里比较date类型的方法如下: 1、java.util.Date类实现了Comparable接口,可以直接调用Date的compareTo()方法来比较大小,compareTo()方法的返回值,date1小于date2返回-1,date1大于date2返回1,相等...
  • Java中int类型数据的大小比较可以使用双等号,double类型则不能使用双等号来比较大小,如果使用的话得到的结果将永远是不相等,即使两者的精度是相同的也不可以。下面介绍两种比较double数据是否相等的方法。 第一...
  • byte:1个字节,8位,-128~127 最大存储数据量 255short:2个字节,16位,-32768~32767 最大存储数据量 65535char:2个字节,16位,存储Unicode编码,用‘’int:4个字节,32位,负的2的31次方~2的31次方-1 最大...
  • 一枚java小白在上路阶段遇到这样一个问题(大佬可以直接点右上角的小叉叉),简单描述如下: 注释即为输出结果,对...java对每个原始类型都提供了封装类(大写开头),封装类与原始类型有很多不同,blablablabla…...
  • java中Long类型和long类型大小比较

    千次阅读 2017-10-20 16:44:28
    今天遇到这样一个问题,我用 "=="来比较两个Long类型的数据,明明数值都相等,可是结果就是false,后来仔细想想,Long在java中是一个引用类型,而long类型java中的一个基本数据类型,用来表示数值。如果用'=='去比较...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 594,601
精华内容 237,840
关键字:

java类型大小

java 订阅