java 如何查看全局变量占用内存大小

在strut2 的action中可以定义几个变量,也可以吧字段放到entity中例如:

在entity中定义变量,
class entity{
private String s1;
private String s2;
private String s3;
get set方法
}

action中调用entity
class action{
private Entity entity;

get set方法

}

在action中直接定义变量
class action{
private String s1;
private String s2;
private String s3;
get set方法
}

我想问那种方式占用内存大,

[b]最主要是想知道,如何写程序查看占用内存的大小[/b][color=red][/color][size=x-small][/size].

Java程序计算各种对象所占内存的大小的方法。

基类：

[code="java"]public abstract class SizeOf {

private final Runtime s_runtime = Runtime.getRuntime();

/**
 *
 * 子类负责覆盖该方法以提供被测试类的实例
 *
 * @return 被测试类的实例
 */
protected abstract Object newInstance();

/**
 *
 * 计算实例的大小（字节数）
 *
 * @return 实例所占内存的字节数
 * @throws Exception
 */
public int size() throws Exception {

    // 垃圾回收
    runGC();

    // 提供尽可能多（10万）的实例以使计算结果更精确
    final int count = 100000;
    Object[] objects = new Object[count];

    // 实例化前堆已使用大小
    long heap1 = usedMemory();
    // 多实例化一个对象
    for (int i = -1; i < count; ++i) {
        Object object = null;

        // 实例化对象
        object = newInstance();

        if (i >= 0) {
            objects[i] = object;
        } else {
            // 释放第一个对象
            object = null;
            // 垃圾收集
            runGC();
            // 实例化之前堆已使用大小
            heap1 = usedMemory();
        }
    }

    runGC();
    // 实例化之后堆已使用大小
    long heap2 = usedMemory();
    final int size = Math.round(((float) (heap2 - heap1)) / count);

    // 释放内存
    for (int i = 0; i < count; ++i) {
        objects[i] = null;
    }
    objects = null;
    return size;
}

private void runGC() throws Exception {
    // 执行多次以使内存收集更有效
    for (int r = 0; r < 4; ++r) {
        _runGC();
    }
}

private void _runGC() throws Exception {
    long usedMem1 = usedMemory();
    long usedMem2 = Long.MAX_VALUE;
    for (int i = 0; (usedMem1 < usedMem2) && (i < 500); ++i) {
        s_runtime.runFinalization();
        s_runtime.gc();
        Thread.currentThread().yield();
        usedMem2 = usedMem1;
        usedMem1 = usedMemory();
    }
}

/**
 *
 * 堆中已使用内存
 *
 * @return 堆中已使用内存
 */
private long usedMemory() {
    return s_runtime.totalMemory() - s_runtime.freeMemory();
}

}[/code]

子类：

[code="java"]public class SizeOfObject extends SizeOf {

@Override
protected Object newInstance() {
    return new Object();
}

public static void main(String[] args) throws Exception {
    SizeOf sizeOf = new SizeOfObject();
    System.out.println("所占内存：" + sizeOf.size() + "字节");
}

}[/code]

输出为：所占内存：8字节

利用序列化(Serializable)计算对象的大小
下面代码可以计算session的大小:
将session中的所有对象输出到文件中,文件的大小就是对象的大小.

[code="java"]try {
FileOutputStream f = new FileOutputStream("c:/sessionFiles");
ObjectOutputStream s = new ObjectOutputStream(f);
s.writeObject("session:");
HttpSession session = request.getSession(false);
Enumeration names = session.getAttributeNames();
while(names.hasMoreElements()){
s.writeObject(session.getAttribute((String) names.nextElement()));
}
s.flush();
s.close();
f.close();
} catch (Exception e) {
e.printStackTrace();
}[/code]

也可以看看这个

java对象占内存大小

[url]http://329937021.iteye.com/blog/547779[/url]

1.Runtime.getRuntime().gc();

2.long start = Runtime.getRuntime().freeMemory();

3.Object object=(Object)request.getSession().getAttribute("object");

4.

5.Runtime.getRuntime().gc();

6.long end = Runtime.getRuntime().freeMemory();

7.long difference = ( start - end );

8.System.out.println( difference + " bytes be used!" );

分析一下两者action的不同，后者多了一个对象（包含三个String的引用）。
我们知道对象需要在堆中占一定的空间。
多一个对象，必然多占内存。

所以后者占内存大。

如果你想亲自验证一下这个推理，很简单，查看JVM内存的使用情况。
使用Runtime对象中的静态方法。更多java运行环境信息参看（http://www.jingningedu.com/manage/java_api/java/lang/Runtime.html）

查看JVM内存使用情况的简单代码如下：
[code="java"]
System.out.print("当前虚拟机最大可用内存为:");

System.out.println(Runtime.getRuntime().maxMemory()/1024/1024+"M");

System.out.print("当前，虚拟机已占用内存:");

System.out.println(Runtime.getRuntime().totalMemory()/1024/1024+"M");
[/code]