精华内容
下载资源
问答
  • List与数组占用字节数

    2010-07-17 19:03:37
    想看一下List序列化后占用多少个 字节,测试程序如下: [code="java"] public static void main(String[] args) throws IOException{ int n = 2000; List list = new LinkedList(); for (int i ...
    想看一下List序列化后占用多少个 字节,测试程序如下:
    	public static void main(String[] args) throws IOException{
    int n = 2000;
    List<Integer> list = new LinkedList<Integer>();
    for (int i = 0; i < n; i++) {
    list.add(i);
    }
    System.out.println("元素数:" + list.size());

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    ObjectOutputStream os = new ObjectOutputStream(baos);

    os.writeObject(list);
    os.close();


    System.out.println("字节数:" + baos.size());
    baos.close();
    }

    [b]输出结果:[/b]
    元素数:0
    字节数:48

    元素数:1
    字节数:125

    元素数:2
    字节数:135

    元素数:3
    字节数:145

    元素数:2000
    字节数:20115

    [color=red]可以看出超过一个元素后 每增加一个增加10个字节
    可简单的理解为每个整形占10字节[/color]
    ==============================
    [b]同样的程序改用int[], 整形数组测试结果如下[/b]:
    元素数:0
    字节数:27

    元素数:1
    字节数:31

    元素数:2
    字节数:35

    元素数:3
    字节数:39

    元素数:2000
    字节数:8027

    [color=red]每个元素占4个字节[/color]
    ===========================
    [color=red]可以看出int[]比List<Integer>节省很多的内存
    差不多2.5倍吧[/color]

    用memcached来缓存 的话
    用数组是比较合算的,可惜数组不能动态变化
    或者可采用字符串的方式,如‘1#2#3#4’这样
    展开全文
  • Java数组对象占用多少个字节?

    千次阅读 2020-12-15 17:40:27
    Length 数组占用4字节 实例数据(Instance Data) 对齐填充(Padding) 众所周知Object object = new Object()占用了16字节,然后看一下下面几个数组占用空间大小 int[] intArr = new IntArr[3]; St....

     

    Java内存模型基础知识

    内存占用详情通过openJDK打印

    // Pom文件
            <dependency>
                <groupId>org.openjdk.jol</groupId>
                <artifactId>jol-core</artifactId>
                <version>0.10</version>
            </dependency>
    // 打印语句
     Object[] objects = new Object[3];
    System.out.println(ClassLayout.parseInstance(objects).toPrintable());

    对象内存中可以分为三块区域:

    • 对象头(Header)

      • MarkWord占用8字节

      • Class Point占用4字节

      • Length 数组占用4字节

    • 实例数据(Instance Data)

    • 对齐填充(Padding)

    众所周知Object object = new Object()占用了16字节,然后看一下下面几个数组占用空间大小

    int[] intArr = new IntArr[3];

    String[] stringArr = new String[3];

    byte[] byteArr = new byte[3];

    long[] longArr = new long[3];

    对于上面几个数组来说,Mark Word, Class Point,Length占用的空间都是一样的(16),只有实例数据占用空间不相等,那么先看一下相同部分空间占用情况,

    Mark Word占用8个字节

    Class Point 占用4个字节

    Length 占用4个字节

    然后分别看一下每个数组实例数据占用的空间大小

    类型 头部占用 实例数据占用空间详情(字节) 补齐填充 总占用
    byte 16 3 5 24
    int 16 12 4 32
    long 16 24 0 40
    String 16 12 4 32

     

    对于上面的结果,我对byte,int,long的占用完全理解,因为实例数据占用 = 数组长度 * 类型占用字节数,但是对于String类型不甚理解,然后各种百度,最后终于榆木脑袋开了窍,对于String数组来说,每个元素就是存的一个对象的引用地址,而每个引用地址占4个字节,所以实例数据占用 = 数组长度 * 引用地址占用字节数

    在看下面两个例子:

    分别创建两个对象

    对象1

    public class Obj1 {
        private char[] value;
        private int count;
        private int offset;
        private int hashcode;
    }

     对象2

    public class Obj2 {
        String value;
    }

    Obj1[] arr1 = new Obj1[3];

    Obj2[] arr2 = new Obj2[3];

    可以预测一下上面两个对象占用的空间大小.

    实际结果: 两个对象占用空间大小是一样的

     

     

     

    展开全文
  • java对象的内存组成 ...实例数据:基础数据类型(按照java的基础字节数) + 引用数据类型(可能是4字节也可能是8字节,默认4字节) 对齐内存填充: 整个对象的字节数必须是8的倍数,不足则需要补充 其...

    java对象的内存组成

    java对象的内存以字节为单位,且必须是8的倍数,它的构成由3部分组成:

    1. 对象头: mark word(8字节/64bit)、oop指针(对象地址指针,可能是4字节也可能是8字节,默认4字节)
    2. 实例数据:基础数据类型(按照java的基础字节数) + 引用数据类型(可能是4字节也可能是8字节,默认4字节)
    3. 对齐内存填充: 整个对象的字节数必须是8的倍数,不足则需要补充

    其中: “oop指针"和实例数据中的"引用数据类型” 在开启压缩普通对象指针(-XX:+UseCompressedOops)时大小为4字节,关闭压缩普通对象指针(-XX:+UseCompressedOops)时为8字节。UseCompressedOops默认是开启的,只有虚拟机内存达到32G以上,4个字节已经无法满足寻址需求时,才需要关闭该参数。

    所以: java的普通对象: 对象头(8 + 4 = 12字节) + 实例数据(依据实际情况) + 对齐内存填充
    java的数组对象的组成: 对象头(8 + 4 + 4(多4字节的数组长度) = 16字节) + 实例数据(数组为引用类型: 4字节, 基础类型: 基础字节数) + 对齐内存填充
    在这里插入图片描述
    注: 1. 对齐内存填充: 分为内填充(internal)和外填充(external), 内填充是在对象存在父类时,优先存储父类的数据,然后填充内存;外填充是对象所有数据计算结束后,进行填充内存
    2. 单对象时,在计算完对象头和实例数据后,按照8倍数填充; 存在父类时,优先加载父类中的实例数据,并且优先加载基本数据类型,然后加载引用数据类型,在加载过程中,可能会存在内填充,尽量保证父类加载完,满足内存对齐。
    3. 若对象中存在数组,则数组因为是引用类型,计算数为4。
    4. 对象的内存分为: 自身内存大小和总内存大小。 自身内存大小不包括引用的实际指向,引用字段全部算4字节;总内存大小则包括引用指向的具体对象的大小。

    实际获取java对象的字节数

    需要首先引入 openJDK的jol包 jol

    import org.openjdk.jol.info.ClassLayout;
    import org.openjdk.jol.vm.VM;
    
    import java.util.Date;
    
    public class Test {
        public static void main(String[] args) throws Exception {
            System.out.println(VM.current().details());
            ClassLayout layout = ClassLayout.parseInstance(new A());
            ClassLayout layout1 = ClassLayout.parseInstance(new C());
            System.out.println(layout.toPrintable());
            System.out.println("======================================");
            System.out.println(layout1.toPrintable());
        }
    
        public static class A{
            long f;
            Date d;
        }
    
        static class C extends A {
            int ba;
            B[] as = new B[3];
    
            C() {
                for (int i = 0; i < as.length; i++) {
                    as[i] = new B();
                }
            }
        }
    
        static class B {
            int a;
            int b;
        }
    
    }
    

    实际获取java对象的字节数2

    采用java.lang.instrument.Instrumentation类的获取对象的大小

    
    // 1. 编写 SizeOfObject 类
    package com.sm.test1;
    
    import java.lang.instrument.Instrumentation;
    import java.lang.reflect.Array;
    import java.lang.reflect.Field;
    import java.lang.reflect.Modifier;
    import java.util.ArrayDeque;
    import java.util.Deque;
    import java.util.HashSet;
    import java.util.Set;
    
    /**
     * 〈一句话功能简述〉<br>
     *     对象占用字节大小工具
     *
     */
    public class SizeOfObject {
        static Instrumentation instrumentation;
    
        public static void premain(String args, Instrumentation instp) {
            instrumentation = instp;
        }
    
        /**
         *
         * 功能描述: <br>
         *     直接计算当前对象占用空间大小,包括当前类及超类的基本类型实例字段大小、<br></br>
         * 引用类型实例字段引用大小、实例基本类型数组总占用空间、实例引用类型数组引用本身占用空间大小; <br></br>
         * 但不包括超类继承下来的和当前类声明的实例引用字段的对象本身的大小、实例引用数组引用的对象本身大小<br></br>
         *
         * @param
         * @return
         */
        public static long sizeOf(Object obj) {
            return instrumentation.getObjectSize(obj);
        }
    
        /**
         *
         * 功能描述: <br>
         *     递归计算当前对象占用空间总大小,包括当前类和超类的实例字段大小以及实例字段引用对象大小
         *
         * @param
         * @return
         */
        public static long fullSizeOf(Object objP)
            throws IllegalAccessException {
            Set<Object> visited = new HashSet<Object>();
            Deque<Object> toBeQueue = new ArrayDeque<Object>();
            toBeQueue.add(objP);
            long size = 0L;
            while (toBeQueue.size() > 0) {
                Object obj = toBeQueue.poll();
                // sizeOf的时候已经计算基本类型和引用的长度,包括数组
                size += skipObject(visited, obj) ? 0L : sizeOf(obj);
                Class<?> tmpObjClass = obj.getClass();
                if (tmpObjClass.isArray()) {
                    // [I, [F基本类型名字长度是2
                    if (tmpObjClass.getName().length() > 2) {
                        for (int i = 0, len = Array.getLength(obj); i < len; i++) {
                            Object tmp = Array.get(obj, i);
                            if (tmp != null) {
                                toBeQueue.add(Array.get(obj, i));
                            }
                        }
                    }
                } else {
                    while (tmpObjClass != null) {
                        Field[] fields = tmpObjClass.getDeclaredFields();
                        for (Field field : fields) {
                            if (Modifier.isStatic(field.getModifiers()) // 静态不计
                                    || field.getType().isPrimitive()) { // 基本类型不重复记
                                continue;
                            }
                            field.setAccessible(true);
                            Object fieldValue = field.get(obj);
                            if (fieldValue == null) {
                                continue;
                            }
                            toBeQueue.add(fieldValue);
                        }
                        tmpObjClass = tmpObjClass.getSuperclass();
                    }
                }
            }
            return size;
        }
    
        /**
         *
         * 功能描述: <br>
         *     String.intern(类似于String a= "1")的对象不计算; 计算过的不计算,也避免死循环
         *
         * @param
         * @return
         */
        private static boolean skipObject(Set<Object> visited, Object obj) {
            if (obj instanceof String && obj == ((String)obj).intern()) {
                return true;
            }
            return visited.contains(obj);
        }
    }
    
    // 2. 编写MANIFEST.MF,并打包
    Manifest-Version: 1.0
    Created-By: my_self
    Premain-Class: com.sm.test1.SizeOfObject
    Can-Redefine-Classes: false
    
    // 3. 编写测试类,执行java命令 java -javaagent:sizeofObject.jar com.sm.test1.SizeOfObjectTest
    package com.sm.test1;
    
    import java.util.Date;
    
    /**
     * 〈一句话功能简述〉<br>
     * 〈功能详细描述〉
     *
     * @author 19039209
     * @date 2019/12/19
     * @see [相关类/方法](可选)
     * @since [产品/模块版本] (可选)
     */
    public class SizeOfObjectTest {
    
        /**
         * -XX:+UseCompressedOops: mark/4 + metedata/8 + 4 = 16
         * -XX:-UseCompressedOops: mark/8 + metedata/8 + 4 + padding/4 = 24
         */
        static class A {
            int a;
        }
    
        /**
         * -XX:+UseCompressedOops: mark/4 + metedata/8 + 4 + 4 + padding/4 = 24
         * -XX:-UseCompressedOops: mark/8 + metedata/8 + 4 + 4 = 24
         */
        static class B {
            int a;
            int b;
        }
    
        /**
         * -XX:+UseCompressedOops: mark/4 + metedata/8 + 4 + 4 + padding/4 = 24
         * -XX:-UseCompressedOops: mark/8 + metedata/8 + 8 + 4 + padding/4 = 32
         */
        static class B2 {
            int b2a;
            Integer b2b;
        }
    
        /**
         * 不考虑对象头:
         * 4 + 4 + 4 * 3 + 3 * sizeOf(B)
         */
        static class C extends A {
            int ba;
            B[] as = new B[3];
    
            C() {
                for (int i = 0; i < as.length; i++) {
                    as[i] = new B();
                }
            }
        }
    
        static class D extends B {
            int da;
            Integer[] di = new Integer[3];
        }
    
        /**
         * 会算上A的实例字段
         */
        static class E extends A {
            int ea;
            int eb;
        }
    
        static class Persion {
            int id;
            String name;
            int age;
            Date birthday;
            boolean school;
        }
        public static void main(String[] args) throws IllegalAccessException {
            System.out.println(SizeOfObject.sizeOf(new Persion()));
    
    //        System.out.println(new File("./target/classes").getAbsolutePath());
    //        System.out.println("sizeOf(new Object())=" + sizeOfObject.sizeOf(new Object()));
    //        System.out.println("sizeOf(new A())=" + sizeOfObject.sizeOf(new A()));
    //        System.out.println("sizeOf(new B())=" + sizeOfObject.sizeOf(new B()));
    //        System.out.println("sizeOf(new B2())=" + sizeOfObject.sizeOf(new B2()));
    //        System.out.println("sizeOf(new B2())=" + sizeOfObject.sizeOf(new B2[3]));
    //        System.out.println("sizeOf(new B[3])=" + sizeOfObject.sizeOf(new B[3]));
    //        System.out.println("sizeOf(new C())=" + sizeOfObject.sizeOf(new C()));
    //        System.out.println("fullSizeOf(new C())=" + sizeOfObject.fullSizeOf(new C()));
    //        System.out.println("sizeOf(new D())=" + sizeOfObject.sizeOf(new D()));
    //        System.out.println("fullSizeOf(new D())=" + sizeOfObject.fullSizeOf(new D()));
    //        System.out.println("sizeOf(new int[3])=" + sizeOfObject.sizeOf(new int[3]));
    //        System.out.println("sizeOf(new Integer(1)=" + sizeOfObject.sizeOf(new Integer(1)));
    //        System.out.println("sizeOf(new Integer[0])=" + sizeOfObject.sizeOf(new Integer[0]));
    //        System.out.println("sizeOf(new Integer[1])=" + sizeOfObject.sizeOf(new Integer[1]));
    //        System.out.println("sizeOf(new Integer[2])=" + sizeOfObject.sizeOf(new Integer[2]));
    //        System.out.println("sizeOf(new Integer[3])=" + sizeOfObject.sizeOf(new Integer[3]));
    //        System.out.println("sizeOf(new Integer[4])=" + sizeOfObject.sizeOf(new Integer[4]));
    //        System.out.println("sizeOf(new A[3])=" + sizeOfObject.sizeOf(new A[3]));
    //        System.out.println("sizeOf(new E())=" + sizeOfObject.sizeOf(new E()));
        }
    }
    
    
    

    知识参考: https://blog.csdn.net/productshop/article/details/50623626
    https://blog.csdn.net/weixin_34344403/article/details/92315247
    https://www.cnblogs.com/E-star/p/10222250.html
    https://www.iteye.com/blog/yueyemaitian-2033046

    展开全文
  • java 十六进制字符串 转成 byte 数组/字节数组,以及 字节数组 转成 16进制的字符串: // isEmpty public static boolean isEmpty( String str ){ if( str == null || str.equals( "" ) ){ return true; ...

    java 十六进制字符串 转成 byte 数组/字节数组,以及 字节数组 转成 16进制的字符串:

            // isEmpty
    	public static boolean isEmpty( String str ){
    		if( str == null || str.equals( "" ) ){
    			return true;
    		}else{
    			return false;
    		}
    	}
    
    
    	/**
    	 * 16进制的字符串表示转成字节数组
    	 *
    	 * @param hexString     16进制格式的字符串,注意字符之间不要有空格
    	 * @return    转换后的字节数组
    	 */
    	public static byte[] toByteArray(String hexString){
    		if( isEmpty( hexString ) ){
    			throw new IllegalArgumentException("this hexString must not be empty");
    		}
    
    		hexString = hexString.toLowerCase();
    		final byte[] byteArray = new byte[hexString.length() / 2];
    		int k = 0;
    
    		for( int i = 0; i < byteArray.length; i++ ){   //因为是16进制,最多只会占用4位,转换成字节需要两个16进制的字符,高位在先
    			byte high = (byte) (Character.digit(hexString.charAt(k), 16) & 0xff);
    			byte low = (byte) (Character.digit(hexString.charAt(k + 1), 16) & 0xff);
    			byteArray[i] = (byte) ( high << 4 | low);
    			k += 2;
    		}
    
    		return byteArray;
    	}
    
    
    	/**
    	 * 字节数组转成16进制表示格式的字符串
    	 *
    	 * @param byteArray    需要转换的字节数组
    	 * @return    16进制表示格式的字符串
    	 */
    	public static String toHexString(byte[] byteArray) {
    		if( byteArray == null || byteArray.length < 1 ){
    			throw new IllegalArgumentException( "this byteArray must not be null or empty" );
    		}
    
    		final StringBuilder hexString = new StringBuilder();
    
    		for( int i = 0; i < byteArray.length; i++ ){
    			if ( ( byteArray[ i ] & 0xff ) < 0x10 ) { //0~F前面不零
    				hexString.append( "0" );
    			}
    
    			hexString.append( Integer.toHexString( 0xFF & byteArray[ i ] ) );
    		}
    
    		return hexString.toString().toLowerCase();
    	}

     

    展开全文
  • 计算一个Java对象占用字节数的方法

    千次阅读 2016-03-10 20:56:02
    本文实例讲述了如何计算(或者说,估算)一个Java对象占用的内存数量的方法。分享给大家供大家参考。具体分析如下: 通常,我们谈论的堆内存使用的前提是以“一般情况”为背景的。不包括下面两种情形:   某些...
  • java 整形数组字节流的互转

    千次阅读 2011-11-01 18:18:22
    字符串格式,占用空间太多,在java里,以上字符串至少条占16*2=32Byte不管是读取,还是写入,都 要把字符串转化为整形或相反,大家都应该知道字符串的操作对性能的影响还是挺大的 那么我们把它直接用整形的字
  • Java数组

    千次阅读 多人点赞 2018-07-28 09:59:47
    Java 语言中提供的数组是用来存储固定大小的同类型元素。 数组中的元素可以是任何数据类型,包括基本数据类型和引用数据类型。 数组属引用类型,数组型数据是对象(object),数组中的每个元素相当于该对象的成员...
  • Java整形数组 字节流的互转  前言  某些时候,我们想存储一些整形、长整形的内容到一些地方。当然你可能会用“,”分隔来存,比如:  123,35,23533,234  这种形式并没有错,但存以几个缺点:  字符串...
  • java 创建1字节数组 Java代理是一个Java程序,它在另一个Java应用程序(“目标”应用程序)启动之前执行,从而为该代理提供了修改目标应用程序或其运行环境的机会。 在本文中,我们将从基础知识开始,逐步使用字节...
  • Java数组的内存管理

    2013-07-31 17:49:35
    Java数组的内存管理
  • 1.定义方式 java定义数组的方式: int a[]=new int[2]  int b[]={1,2}  int c[]=new int[]{1,2} ...java数组值存在堆中,毕竟堆的内存较大,而引用存在栈中,仅占用4字节。并且数组必须指定长度...
  • 所谓的占用字节数,就是申请内存的时候所占的空间大小 类型 字节数 最小值 最大值 boolean 未指定,至少1字节,仅定义为取字面值true或false - - byte 1 -128(-2^7) 127(2^7-1) short 2 -...
  • Java 数组的基本知识

    2019-11-30 19:34:37
    数组 数组是一种线性的结构 在数据中的内存地址是连续的,这也就是在数组中为什么要指定数组的大小,只有在...由于int 在Java占用4个字节。可以看到 每个空间都占用4个字节。 当数组进行插入操作时,需要将插...
  • java 数组的学习

    2017-07-24 12:09:05
     数据类型[] 数组名 = new 数据类型 [元素个]  例如: int[] array = new int [10];    占用的内存空间 array 占了8个字节(引用数据类型全是八个字节),  数据占用了 10 * 4(int类型)个字节,一共48个...
  • Java基本类型占用字节数: 1字节: byte , boolean 2字节: short , char 4字节: int , float 8字节: long , double 注:1字节(byte)=8位(bits) 附录: 1.编码与中文: Unicode/GBK: 中文2字节 ...
  • Java字节数组byte b[]与byte[] b

    千次阅读 2020-12-25 15:16:06
    Java中的字节数组 Java字节数组仅用于存储字节数据类型值。字节数组中元素的默认值为0。 通过以下Java字节数组示例,您可以学习 如何声明Java字节数组? 如何为Java字节数组分配值? 如何从Java字节数组获取值...
  • Java数组的概念

    千次阅读 2014-04-06 23:55:28
    // 数组是一组数据的集合,数组也是java对象,数组中的元素可以是任意类型(包括...// 都是int类型,占用4个字节,因此整个数组对象在内存中占用400个字节,为数组中的每个元素赋予其数据 // 类型的默认值,int是0,boo
  • Java数组之内存分析

    2018-10-13 20:40:41
    Java数组只是一个引用,数组在内存中的存储可以理解为由两部分组成一部分是数组引用存储在栈(stack)内存中,另一部分是实际数组存储在堆(heap)内存中。引用变量可以指向任何有效的内存,只有当该引用指向...
  • java数组最大长度

    千次阅读 2019-06-18 11:45:55
    Java数组的最大长度是多少呢?看一下它的length属性就可以了。length属性是32位的有符号整数,它的最大值是2的31次幂,就是2G。为何有这个限制呢?为什么length的属性不是long型呢?我们假设一下,如果它是long型...
  • 10JAVA数组详解

    2013-11-18 21:44:17
    比如String、数组,以及其它一切的Java类的类型的变量。 引用类似的变量,本质是指针。存的就是被赋值对象的内存首地址。 引用类型和基本类型区别: 1.基本类型声明的时候,已经确定了内存的大小。比如int是...
  • Java数组和链表的区别

    千次阅读 2017-03-08 11:29:04
    Java数组和链表的区别从数据结构上说,数组的内存空间是连续的,我们创建数组的时候系统就会为我们开辟固定数目的内存空间,如果内存不足,就会创建失败,例如创建数组的两种方式: int[] a=new int[3]; int[] b=...
  • java数组存储压缩原理

    2019-06-03 10:18:39
    一个存储单元可以存储4KB,一个int类型32位,是4个字节(4B),所有一个存储单元可以存储1024个int类型。 int int int int… 由于一个int类型占用一个存储单元太浪费空间了,所以采用压缩来进行数据...
  • 我们知道在java中一个整型是占用四个字节32位的,而一 个byte类型占用一个字节8位的。所以我们可以用一个整型来最多表示一个长度为4的byte数组,同样我们可以用一个长度为4的byte数组来表示一个整型。下面我们就 ...
  • 本文中,我们讨论一个问题:如何计算(或者说,估算)一个Java对象占用的内存数量? 通常,我们谈论的堆内存使用的前提是以“一般情况”为背景的。不包括下面两种情形: 某些情况下,JVM根本就没有把Objec
  • 1,怎样将一个字符串转换为字节数组: 2,将数字转换为字节数组: 3,将字节数组转化为字符串: 4,字节数组转化为数字: 5,返回16进制字符串对应的16进制对应的...6,字节对应的16进制转成对应的16进制的字符串:
  • 本文中,我们讨论一个问题:如何计算(或者说,估算)一个Java对象占用的内存数量? 通常,我们谈论的堆内存使用的前提是以“一般情况”为背景的。不包括下面两种情形:   某些情况下,JVM根本就没有把Object放入...
  • 通过Java代码实现对象、List类集、数组、Map及常用数据类型等占用字节大小的代码示例,详情参见代码示例部分。 package Test; import java.io.ByteArrayOutputStream; import java.io.ObjectOutputStream; import ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 79,920
精华内容 31,968
关键字:

java数组占用字节数

java 订阅