1. Java代码   
  2. System.out.println("--- Memory Usage:"); /*打印一行字符串---Memory Usage*/    
  3.  
  4.      Runtime rt=Runtime.getRuntime( ); //获得系统的Runtime对象rt    
  5.  
  6.      System.out.println("Total Memory= " + rt.totalMemory( )+//打印总内存大小    
  7.  
  8.              " Free Memory = "+rt.freeMemory( ));  //打印空闲内存大小    
  9.  
  10. 基类:  
  11. Java代码   
  12. public abstract class SizeOf {      
  13.  
  14.     private final Runtime s_runtime = Runtime.getRuntime();      
  15.     /**    
  16.      *    
  17.      * 子类负责覆盖该方法以提供被测试类的实例    
  18.      *   
  19.      * @return 被测试类的实例    
  20.      */     
  21.  
  22.     protected abstract Object newInstance();      
  23.     /**    
  24.      *    
  25.      * 计算实例的大小(字节数)    
  26.      *    
  27.      * @return 实例所占内存的字节数    
  28.      * @throws Exception    
  29.      */     
  30.  
  31.     public int size() throws Exception {      
  32.         // 垃圾回收      
  33.         runGC();      
  34.         // 提供尽可能多(10万)的实例以使计算结果更精确      
  35.         final int count = 100000;      
  36.         Object[] objects = new Object[count];      
  37.         // 实例化前堆已使用大小      
  38.         long heap1 = usedMemory();      
  39.         // 多实例化一个对象      
  40.         for (int i = -1; i < count; ++i) {      
  41.             Object object = null;      
  42.             // 实例化对象      
  43.             object = newInstance();      
  44.             if (i >= 0) {      
  45.                 objects[i] = object;      
  46.             } else {      
  47.                 // 释放第一个对象      
  48.                 object = null;      
  49.                 // 垃圾收集      
  50.                 runGC();      
  51.                 // 实例化之前堆已使用大小      
  52.                 heap1 = usedMemory();      
  53.             }      
  54.         }      
  55.         runGC();      
  56.         // 实例化之后堆已使用大小      
  57.         long heap2 = usedMemory();      
  58.         final int size = Math.round(((float) (heap2 - heap1)) / count);      
  59.         // 释放内存      
  60.         for (int i = 0; i < count; ++i) {      
  61.             objects[i] = null;      
  62.         }      
  63.         objects = null;      
  64.         return size;      
  65.     }      
  66.     private void runGC() throws Exception {      
  67.         // 执行多次以使内存收集更有效      
  68.         for (int r = 0; r < 4; ++r) {      
  69.             _runGC();      
  70.         }      
  71.     }      
  72.     private void _runGC() throws Exception {      
  73.         long usedMem1 = usedMemory();      
  74.         long usedMem2 = Long.MAX_VALUE;      
  75.         for (int i = 0; (usedMem1 < usedMem2) && (i < 500); ++i) {      
  76.             s_runtime.runFinalization();      
  77.             s_runtime.gc();      
  78.             Thread.currentThread().yield();      
  79.             usedMem2 = usedMem1;      
  80.             usedMem1 = usedMemory();      
  81.         }      
  82.     }      
  83.     /**    
  84.      *    
  85.      * 堆中已使用内存    
  86.      *    
  87.      * @return 堆中已使用内存    
  88.      */     
  89.     private long usedMemory() {      
  90.         return s_runtime.totalMemory() - s_runtime.freeMemory();      
  91.     }      
  92. }     
  93.  
  94. 子类:  
  95. Java代码   
  96. public class SizeOfObject extends SizeOf {  
  97.     @Override     
  98.     protected Object newInstance() {      
  99.         return new Object();      
  100.     }     
  101.     public static void main(String[] args) throws Exception {      
  102.         SizeOf sizeOf = new SizeOfObject();      
  103.         System.out.println("所占内存:" + sizeOf.size() + "字节");      
  104.     }      
  105. }     
  106.  
  107. public class SizeOfObject extends SizeOf {   
  108.     @Override   
  109.     protected Object newInstance() {   
  110.         return new Object();   
  111.     }   
  112.  
  113.     public static void main(String[] args) throws Exception {   
  114.         SizeOf sizeOf = new SizeOfObject();   
  115.         System.out.println("所占内存:" + sizeOf.size() + "字节");   
  116.     }   
  117. }   
  118.  
  119.  
  120. 输出为:所占内存:8字节  
  121.  
  122. 利用序列化(Serializable)计算对象的大小  
  123. 下面代码可以计算session的大小:  
  124. 将session中的所有对象输出到文件中,文件的大小就是对象的大小.  
  125.  
  126. Java代码   
  127.  
  128. try {      
  129.     FileOutputStream f = new FileOutputStream("c:/sessionFiles");      
  130.     ObjectOutputStream s = new ObjectOutputStream(f);      
  131.     s.writeObject("session:");      
  132.     HttpSession session = request.getSession(false);      
  133.     Enumeration names = session.getAttributeNames();      
  134.     while(names.hasMoreElements()){      
  135.         s.writeObject(session.getAttribute((String) names.nextElement()));      
  136.     }      
  137.     s.flush();      
  138.     s.close();  
  139.     f.close();      
  140. catch (Exception e) {      
  141.     e.printStackTrace();      
  142. }