这个答案与对象大小无关，而是当你使用数组来容纳对象时;它将为对象分配多少内存大小。

所以数组，列表，或map所有这些集合不会真正存储对象(只有在使用原语时，需要实际对象的内存大小)，它只存储这些对象的引用。

现在在集合中使用的堆内存= sizeOfObj + sizeOfRef(* 4字节)

(4/8字节)取决于(32/64位)操作系统

原语

int   [] intArray    = new int   [1]; will require 4 bytes.
long  [] longArray   = new long  [1]; will require 8 bytes.

对象

Object[] objectArray = new Object[1]; will require 4 bytes. The object can be any user defined Object.
Long  [] longArray   = new Long  [1]; will require 4 bytes.

我的意思是说，所有对象REFERENCE只需要4个字节的内存。它可能是字符串引用或双对象引用，但根据对象创建所需的内存会有所不同。

例)如果我为下面的类ReferenceMemoryTest创建对象，那么将创建4 + 4 + 4 = 12字节的内存。当您尝试初始化引用时，内存可能会有所不同。

 class ReferenceMemoryTest {
    public String refStr;
    public Object refObj;
    public Double refDoub; 
}

因此，当创建对象/引用数组时，它的所有内容都将被NULL引用占用。我们知道每个引用需要4个字节。

最后，下面代码的内存分配为20字节。

参考内存测试ref1 = new参考内存测试();(4(ref1) + 12 = 16字节) 参考内存测试ref2 = ref1;(4(ref2) + 16 = 20字节)

我的答案是基于Nick提供的代码。该代码测量被序列化对象占用的字节总数。因此，这实际上衡量的是序列化的东西+普通对象的内存占用(只要序列化，例如int，你会看到序列化的字节总数不是4)。所以，如果你想获得对象使用的原始字节数，你需要修改一下代码。像这样:

import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class ObjectSizeCalculator {
    private Object getFirstObjectReference(Object o) {
        String objectType = o.getClass().getTypeName();

        if (objectType.substring(objectType.length()-2).equals("[]")) {
            try {
                if (objectType.equals("java.lang.Object[]"))
                    return ((Object[])o)[0];
                else if (objectType.equals("int[]"))
                    return ((int[])o)[0];
                else
                    throw new RuntimeException("Not Implemented !");
            } catch (IndexOutOfBoundsException e) {
                return null;
            }
        }

        return o;
    } 

    public int getObjectSizeInBytes(Object o) {
        final String STRING_JAVA_TYPE_NAME = "java.lang.String";

        if (o == null)
            return 0;

        String objectType = o.getClass().getTypeName();
        boolean isArray = objectType.substring(objectType.length()-2).equals("[]");

        Object objRef = getFirstObjectReference(o);
        if (objRef != null && !(objRef instanceof Serializable))
            throw new RuntimeException("Object must be serializable for measuring it's memory footprint using this method !");

        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(o);
            oos.close();
            byte[] bytes = baos.toByteArray();

            for (int i = bytes.length - 1, j = 0; i != 0; i--, j++) {
                if (objectType != STRING_JAVA_TYPE_NAME) {
                    if (bytes[i] == 112)
                        if (isArray)
                            return j - 4;
                        else
                            return j;
                } else {
                    if (bytes[i] == 0)
                        return j - 1;
                }
            }
        } catch (Exception e) {
            return -1;
        }

        return -1;
    }    

}

我已经用基本类型String和一些普通类测试了这个解决方案。可能也有不包括在内的情况。

更新:示例修改为支持数组对象的内存占用计算。

首先，“对象的大小”在Java中并不是一个定义明确的概念。你可以指对象本身，包括它的成员、对象和它引用的所有对象(引用图)。您可以指内存中的大小或磁盘上的大小。JVM可以优化字符串之类的东西。

所以唯一正确的方法是用一个好的分析器(我使用YourKit)询问JVM，这可能不是你想要的。

然而，从上面的描述来看，似乎每一行都是自包含的，没有很大的依赖树，因此序列化方法在大多数jvm上可能是一个很好的近似方法。最简单的方法如下:

 Serializable ser;
 ByteArrayOutputStream baos = new ByteArrayOutputStream();
 ObjectOutputStream oos = new ObjectOutputStream(baos);
 oos.writeObject(ser);
 oos.close();
 return baos.size();

请记住，如果对象具有公共引用，这将不会给出正确的结果，并且序列化的大小并不总是与内存中的大小匹配，但这是一个很好的近似值。如果您将ByteArrayOutputStream大小初始化为一个合理的值，代码将会更有效。

许多其他答案提供了浅的大小——例如，没有任何键或值的HashMap的大小，这可能不是您想要的。

jamm项目使用上面的java.lang.instrumentation包，但是遍历树，因此可以为您提供深层内存使用。

new MemoryMeter().measureDeep(myHashMap);

https://github.com/jbellis/jamm

要使用MemoryMeter，请使用“-javaagent:/jam .jar”启动JVM

如果你只是想知道在你的JVM中有多少内存被使用，有多少是空闲的，你可以尝试这样做:

// Get current size of heap in bytes
long heapSize = Runtime.getRuntime().totalMemory();

// Get maximum size of heap in bytes. The heap cannot grow beyond this size.
// Any attempt will result in an OutOfMemoryException.
long heapMaxSize = Runtime.getRuntime().maxMemory();

// Get amount of free memory within the heap in bytes. This size will increase
// after garbage collection and decrease as new objects are created.
long heapFreeSize = Runtime.getRuntime().freeMemory();

edit:我认为这可能会有帮助，因为问题作者还表示，他希望有处理“读取尽可能多的行，直到我使用了32MB内存”的逻辑。

对于JSONObject，下面的代码可以帮助您。

`JSONObject.toString().getBytes("UTF-8").length`

返回以字节为单位的大小

我通过将JSONArray对象写入文件来检查它。它给出了对象的大小。