这篇说说如何计算Java对象大小的方法。之前在聊聊高并发（四）Java对象的表示模型和运行时内存表示 这篇中已经说了Java对象的内存表示模型是Oop-Klass模型。

普通对象的结构如下，按64位机器的长度计算

1. 对象头(_mark)， 8个字节

2. Oop指针，如果是32G内存以下的，默认开启对象指针压缩，4个字节

3. 数据区

4.Padding(内存对齐)，按照8的倍数对齐

数组对象结构是

1. 对象头(_mark)， 8个字节

2. Oop指针，如果是32G内存以下的，默认开启对象指针压缩，4个字节

3. 数组长度，4个字节

4. 数据区

5. Padding(内存对齐)，按照8的倍数对齐

清楚了对象在内存的基本布局后，咱们说两种计算Java对象大小的方法

1. 通过java.lang.instrument.Instrumentation的getObjectSize(obj)直接获取对象的大小

2. 通过sun.misc.Unsafe对象的objectFieldOffset(field)等方法结合反射来计算对象的大小

java.lang.instrument.Instrumentation.getObjectSize()的方式

先讲讲java.lang.instrument.Instrumentation.getObjectSize()的方式，这种方法得到的是Shallow Size，即遇到引用时，只计算引用的长度，不计算所引用的对象的实际大小。如果要计算所引用对象的实际大小，可以通过递归的方式去计算。

java.lang.instrument.Instrumentation的实例必须通过指定javaagent的方式才能获得，具体的步骤如下：

1. 定义一个类，提供一个premain方法: public static void premain(String agentArgs, Instrumentation instP)

2. 创建META-INF/MANIFEST.MF文件，内容是指定PreMain的类是哪个： Premain-Class: sizeof.ObjectShallowSize

3. 把这个类打成jar，然后用java -javaagent XXXX.jar XXX.main的方式执行

下面先定义一个类来获得java.lang.instrument.Instrumentation的实例,并提供了一个static的sizeOf方法对外提供Instrumentation的能力

  1. package sizeof;
  2. import java.lang.instrument.Instrumentation;
  3. public class ObjectShallowSize {
  4. private static Instrumentation inst;
  5. public static void premain(String agentArgs, Instrumentation instP){
  6. inst = instP;
  7. }
  8. public static long sizeOf(Object obj){
  9. return inst.getObjectSize(obj);
  10. }
  11. }

定义META-INF/MANIFEST.MF文件

  1. Premain-Class: sizeof.ObjectShallowSize

打成jar包

  1. cd 编译后的类和META-INF文件夹所在目录
  2. jar cvfm java-agent-sizeof.jar META-INF/MANIFEST.MF  .

准备好了这个jar之后，我们可以写测试类来测试Instrumentation的getObjectSize方法了。在这之前我们先来看对象在内存中是按照什么顺序排列的

有如下这个类，字段的定义按如下顺序

  1. private static class ObjectA {
  2. String str;  // 4
  3. int i1; // 4
  4. byte b1; // 1
  5. byte b2; // 1
  6. int i2;  // 4
  7. ObjectB obj; //4
  8. byte b3;  // 1
  9. }

按照我们之前说的方法来计算一下这个对象所占大小，注意按8对齐

8(_mark) + 4(oop指针) + 4(str) + 4(i1) + 1(b1) + 1(b2) + 2(padding) + 4(i2) + 4(obj) + 1(b3) + 7(padding) = 40 ?

但事实上是这样的吗？ 我们来用Instrumentation的getObjectSize来计算一下先:

  1. package test;
  2. import sizeof.ObjectShallowSize;
  3. public class SizeofWithInstrumetation {
  4. private static class ObjectA {
  5. String str;  // 4
  6. int i1; // 4
  7. byte b1; // 1
  8. byte b2; // 1
  9. int i2;  // 4
  10. ObjectB obj; //4
  11. byte b3;  // 1
  12. }
  13. private static class ObjectB {
  14. }
  15. public static void main(String[] args){
  16. System.out.println(ObjectShallowSize.sizeOf(new ObjectA()));
  17. }
  18. }

得到的结果是32！不是会按8对齐吗，b3之前的数据加起来已经是32了，多了1个b3，为33，应该对齐到40才对啊。事实上，HotSpot创建的对象的字段会先按照给定顺序排列一下,默认的顺序如下，从长到短排列，引用排最后:  long/double --> int/float -->  short/char --> byte/boolean --> Reference

这个顺序可以使用JVM参数:  -XX:FieldsAllocationSylte=0(默认是1)来改变。

我们使用sun.misc.Unsafe对象的objectFieldOffset方法来验证一下:

  1. Field[] fields = ObjectA.class.getDeclaredFields();
  2. for(Field f: fields){
  3. System.out.println(f.getName() + " offset: " +unsafe.objectFieldOffset(f));
  4. }

可以看到确实是按照从长到短，引用排最后的方式在内存中排列的。按照这种方法我们来重新计算下ObjectA创建的对象的长度:

8(_mark) + 4(oop指针) + 4(i1) + + 4(i2) + 1(b1) + 1(b2) + 1(b3) + 1(padding) +  4(str) + 4(obj) = 32

得到的结果和java.lang.instrument.Instrumentation.getObjectSize()的结果是一样的，证明我们的计算方式是正确的。

sun.misc.Unsafe的方式

下面说一下通过sun.misc.Unsafe对象的objectFieldOffset(field)等方法结合反射来计算对象的大小。基本的思路如下:

1. 通过反射获得一个类的Field

2. 通过Unsafe的objectFieldOffset()获得每个Field的offSet

3. 对Field按照offset排序，取得最大的offset，然后加上这个field的长度，再加上Padding对齐

上面三步就可以获得一个对象的Shallow size。可以进一步通过递归去计算所引用对象的大小，从而可以计算出一个对象所占用的实际大小。

如何获得Unsafe对象已经在这篇中聊聊序列化（二）使用sun.misc.Unsafe绕过new机制来创建Java对象说过了，可以通过反射的机制来获得.

Oop指针是4还是未压缩的8也可以通过unsafe.arrayIndexScale(Object[].class)来获得，这个方法返回一个引用所占用的长度

  1. static {
  2. try {
  3. Field field = Unsafe.class.getDeclaredField("theUnsafe");
  4. field.setAccessible(true);
  5. unsafe = (Unsafe) field.get(null);
  6. objectRefSize = unsafe.arrayIndexScale(Object[].class);
  7. } catch (Exception e) {
  8. throw new RuntimeException(e);
  9. }
  10. }

下面的源码摘自 http://java-performance.info/memory-introspection-using-sun-misc-unsafe-and-reflection/， 原文中的代码在计算对象大小的时候有问题，我做了微调，并加上了内存对齐的方法，这样计算出的结果和Instrumentation的getObjectSize方法是一样的。

  1. package test;
  2. import java.util.ArrayList;
  3. import java.util.Collections;
  4. import java.util.Comparator;
  5. import java.util.List;
  6. /**
  7. * This class contains object info generated by ClassIntrospector tool
  8. * 计算一个Java类对象的大小 1.默认启用了压缩普通对象指针:-XX:+UseCompressedOops 2.这里的计算是包含了值得大小 如:Integer  a =  1; (初始化给值和不给值大小是不一样的)
  9. */
  10. public class ObjectInfo {
  11. /** Field name */
  12. public final String name;
  13. /** Field type name */
  14. public final String type;
  15. /** Field data formatted as string */
  16. public final String contents;
  17. /** Field offset from the start of parent object */
  18. public final int offset;
  19. /** Memory occupied by this field */
  20. public final int length;
  21. /** Offset of the first cell in the array */
  22. public final int arrayBase;
  23. /** Size of a cell in the array */
  24. public final int arrayElementSize;
  25. /** Memory occupied by underlying array (shallow), if this is array type */
  26. public final int arraySize;
  27. /** This object fields */
  28. public final List<ObjectInfo> children;
  29. public ObjectInfo(String name, String type, String contents, int offset, int length, int arraySize,
  30. int arrayBase, int arrayElementSize)
  31. {
  32. this.name = name;
  33. this.type = type;
  34. this.contents = contents;
  35. this.offset = offset;
  36. this.length = length;
  37. this.arraySize = arraySize;
  38. this.arrayBase = arrayBase;
  39. this.arrayElementSize = arrayElementSize;
  40. children = new ArrayList<ObjectInfo>( 1 );
  41. }
  42. public void addChild( final ObjectInfo info )
  43. {
  44. if ( info != null )
  45. children.add( info );
  46. }
  47. /**
  48. * Get the full amount of memory occupied by a given object. This value may be slightly less than
  49. * an actual value because we don't worry about memory alignment - possible padding after the last object field.
  50. *
  51. * The result is equal to the last field offset + last field length + all array sizes + all child objects deep sizes
  52. * @return Deep object size
  53. */
  54. public long getDeepSize()
  55. {
  56. //return length + arraySize + getUnderlyingSize( arraySize != 0 );
  57. return addPaddingSize(arraySize + getUnderlyingSize( arraySize != 0 ));
  58. }
  59. long size = 0;
  60. private long getUnderlyingSize( final boolean isArray )
  61. {
  62. //long size = 0;
  63. for ( final ObjectInfo child : children )
  64. size += child.arraySize + child.getUnderlyingSize( child.arraySize != 0 );
  65. if ( !isArray && !children.isEmpty() ){
  66. int tempSize = children.get( children.size() - 1 ).offset + children.get( children.size() - 1 ).length;
  67. size += addPaddingSize(tempSize);
  68. }
  69. return size;
  70. }
  71. private static final class OffsetComparator implements Comparator<ObjectInfo>
  72. {
  73. @Override
  74. public int compare( final ObjectInfo o1, final ObjectInfo o2 )
  75. {
  76. return o1.offset - o2.offset; //safe because offsets are small non-negative numbers
  77. }
  78. }
  79. //sort all children by their offset
  80. public void sort()
  81. {
  82. Collections.sort( children, new OffsetComparator() );
  83. }
  84. @Override
  85. public String toString() {
  86. final StringBuilder sb = new StringBuilder();
  87. toStringHelper( sb, 0 );
  88. return sb.toString();
  89. }
  90. private void toStringHelper( final StringBuilder sb, final int depth )
  91. {
  92. depth( sb, depth ).append("name=").append( name ).append(", type=").append( type )
  93. .append( ", contents=").append( contents ).append(", offset=").append( offset )
  94. .append(", length=").append( length );
  95. if ( arraySize > 0 )
  96. {
  97. sb.append(", arrayBase=").append( arrayBase );
  98. sb.append(", arrayElemSize=").append( arrayElementSize );
  99. sb.append( ", arraySize=").append( arraySize );
  100. }
  101. for ( final ObjectInfo child : children )
  102. {
  103. sb.append( '\n' );
  104. child.toStringHelper(sb, depth + 1);
  105. }
  106. }
  107. private StringBuilder depth( final StringBuilder sb, final int depth )
  108. {
  109. for ( int i = 0; i < depth; ++i )
  110. sb.append( "\t");
  111. return sb;
  112. }
  113. private long addPaddingSize(long size){
  114. if(size % 8 != 0){
  115. return (size / 8 + 1) * 8;
  116. }
  117. return size;
  118. }
  119. }
  120. package test;
  121. import java.lang.reflect.Array;
  122. import java.lang.reflect.Field;
  123. import java.lang.reflect.Modifier;
  124. import java.util.ArrayList;
  125. import java.util.Arrays;
  126. import java.util.Collections;
  127. import java.util.HashMap;
  128. import java.util.IdentityHashMap;
  129. import java.util.List;
  130. import java.util.Map;
  131. import sun.misc.Unsafe;
  132. /**
  133. * This class could be used for any object contents/memory layout printing.
  134. */
  135. public class ClassIntrospector {
  136. private static final Unsafe unsafe;
  137. /** Size of any Object reference */
  138. private static final int objectRefSize;
  139. static {
  140. try {
  141. Field field = Unsafe.class.getDeclaredField("theUnsafe");
  142. field.setAccessible(true);
  143. unsafe = (Unsafe) field.get(null);
  144. objectRefSize = unsafe.arrayIndexScale(Object[].class);
  145. } catch (Exception e) {
  146. throw new RuntimeException(e);
  147. }
  148. }
  149. /** Sizes of all primitive values */
  150. private static final Map<Class, Integer> primitiveSizes;
  151. static {
  152. primitiveSizes = new HashMap<Class, Integer>(10);
  153. primitiveSizes.put(byte.class, 1);
  154. primitiveSizes.put(char.class, 2);
  155. primitiveSizes.put(int.class, 4);
  156. primitiveSizes.put(long.class, 8);
  157. primitiveSizes.put(float.class, 4);
  158. primitiveSizes.put(double.class, 8);
  159. primitiveSizes.put(boolean.class, 1);
  160. }
  161. /**
  162. * Get object information for any Java object. Do not pass primitives to
  163. * this method because they will boxed and the information you will get will
  164. * be related to a boxed version of your value.
  165. *
  166. * @param obj
  167. *            Object to introspect
  168. * @return Object info
  169. * @throws IllegalAccessException
  170. */
  171. public ObjectInfo introspect(final Object obj)
  172. throws IllegalAccessException {
  173. try {
  174. return introspect(obj, null);
  175. } finally { // clean visited cache before returning in order to make
  176. // this object reusable
  177. m_visited.clear();
  178. }
  179. }
  180. // we need to keep track of already visited objects in order to support
  181. // cycles in the object graphs
  182. private IdentityHashMap<Object, Boolean> m_visited = new IdentityHashMap<Object, Boolean>(
  183. 100);
  184. private ObjectInfo introspect(final Object obj, final Field fld)
  185. throws IllegalAccessException {
  186. // use Field type only if the field contains null. In this case we will
  187. // at least know what's expected to be
  188. // stored in this field. Otherwise, if a field has interface type, we
  189. // won't see what's really stored in it.
  190. // Besides, we should be careful about primitives, because they are
  191. // passed as boxed values in this method
  192. // (first arg is object) - for them we should still rely on the field
  193. // type.
  194. boolean isPrimitive = fld != null && fld.getType().isPrimitive();
  195. boolean isRecursive = false; // will be set to true if we have already
  196. // seen this object
  197. if (!isPrimitive) {
  198. if (m_visited.containsKey(obj))
  199. isRecursive = true;
  200. m_visited.put(obj, true);
  201. }
  202. final Class type = (fld == null || (obj != null && !isPrimitive)) ? obj
  203. .getClass() : fld.getType();
  204. int arraySize = 0;
  205. int baseOffset = 0;
  206. int indexScale = 0;
  207. if (type.isArray() && obj != null) {
  208. baseOffset = unsafe.arrayBaseOffset(type);
  209. indexScale = unsafe.arrayIndexScale(type);
  210. arraySize = baseOffset + indexScale * Array.getLength(obj);
  211. }
  212. final ObjectInfo root;
  213. if (fld == null) {
  214. root = new ObjectInfo("", type.getCanonicalName(), getContents(obj,
  215. type), 0, getShallowSize(type), arraySize, baseOffset,
  216. indexScale);
  217. } else {
  218. final int offset = (int) unsafe.objectFieldOffset(fld);
  219. root = new ObjectInfo(fld.getName(), type.getCanonicalName(),
  220. getContents(obj, type), offset, getShallowSize(type),
  221. arraySize, baseOffset, indexScale);
  222. }
  223. if (!isRecursive && obj != null) {
  224. if (isObjectArray(type)) {
  225. // introspect object arrays
  226. final Object[] ar = (Object[]) obj;
  227. for (final Object item : ar)
  228. if (item != null)
  229. root.addChild(introspect(item, null));
  230. } else {
  231. for (final Field field : getAllFields(type)) {
  232. if ((field.getModifiers() & Modifier.STATIC) != 0) {
  233. continue;
  234. }
  235. field.setAccessible(true);
  236. root.addChild(introspect(field.get(obj), field));
  237. }
  238. }
  239. }
  240. root.sort(); // sort by offset
  241. return root;
  242. }
  243. // get all fields for this class, including all superclasses fields
  244. private static List<Field> getAllFields(final Class type) {
  245. if (type.isPrimitive())
  246. return Collections.emptyList();
  247. Class cur = type;
  248. final List<Field> res = new ArrayList<Field>(10);
  249. while (true) {
  250. Collections.addAll(res, cur.getDeclaredFields());
  251. if (cur == Object.class)
  252. break;
  253. cur = cur.getSuperclass();
  254. }
  255. return res;
  256. }
  257. // check if it is an array of objects. I suspect there must be a more
  258. // API-friendly way to make this check.
  259. private static boolean isObjectArray(final Class type) {
  260. if (!type.isArray())
  261. return false;
  262. if (type == byte[].class || type == boolean[].class
  263. || type == char[].class || type == short[].class
  264. || type == int[].class || type == long[].class
  265. || type == float[].class || type == double[].class)
  266. return false;
  267. return true;
  268. }
  269. // advanced toString logic
  270. private static String getContents(final Object val, final Class type) {
  271. if (val == null)
  272. return "null";
  273. if (type.isArray()) {
  274. if (type == byte[].class)
  275. return Arrays.toString((byte[]) val);
  276. else if (type == boolean[].class)
  277. return Arrays.toString((boolean[]) val);
  278. else if (type == char[].class)
  279. return Arrays.toString((char[]) val);
  280. else if (type == short[].class)
  281. return Arrays.toString((short[]) val);
  282. else if (type == int[].class)
  283. return Arrays.toString((int[]) val);
  284. else if (type == long[].class)
  285. return Arrays.toString((long[]) val);
  286. else if (type == float[].class)
  287. return Arrays.toString((float[]) val);
  288. else if (type == double[].class)
  289. return Arrays.toString((double[]) val);
  290. else
  291. return Arrays.toString((Object[]) val);
  292. }
  293. return val.toString();
  294. }
  295. // obtain a shallow size of a field of given class (primitive or object
  296. // reference size)
  297. private static int getShallowSize(final Class type) {
  298. if (type.isPrimitive()) {
  299. final Integer res = primitiveSizes.get(type);
  300. return res != null ? res : 0;
  301. } else
  302. return objectRefSize;
  303. }
  304. }

先一个测试类来验证一下Unsafe的方式计算出的结果

  1. public class ClassIntrospectorTest
  2. {
  3. public static void main(String[] args) throws IllegalAccessException {
  4. final ClassIntrospector ci = new ClassIntrospector();
  5. ObjectInfo res;
  6. res = ci.introspect( new ObjectA() );
  7. System.out.println( res.getDeepSize() );
  8. }
  9. private static class ObjectA {
  10. String str;  // 4
  11. int i1; // 4
  12. byte b1; // 1
  13. byte b2; // 1
  14. int i2;  // 4
  15. ObjectB obj; //4
  16. byte b3;  // 1
  17. }
  18. private static class ObjectB {
  19. }
  20. }

计算结果如下：

32

和我们之前计算结果是一致的，证明是正确的。

最后再来测试一下数组对象的长度。有两个类如下:

  1. private static class ObjectC {
  2. ObjectD[] array = new ObjectD[2];
  3. }
  4. private static class ObjectD {
  5. int value;
  6. }

它们在内存的大体分布如下图:

我们可以手工计算一下ObjectC obj = new ObjectC()的大小：

ObjectC的Shallow size = 8(_mark) + 4(oop指针)  + 4(ObjectD[]引用) = 16

new ObjectD[2]数组的长度 =  8(_mark) + 4(oop指针) + 4(数组长度占4个字节) + 4(ObjectD[0]引用) + 4(ObjectD[1]引用) = 24

由于ObjectD[]数组没有指向具体的对象大小，所以我们手工计算的结果是16 + 24 = 40

使用Unsafe对象的方式来计算一下:

  1. public static void main(String[] args) throws IllegalAccessException {
  2. final ClassIntrospector ci = new ClassIntrospector();
  3. ObjectInfo res;
  4. res = ci.introspect( new ObjectC() );
  5. System.out.println( res.getDeepSize() );
  6. }

计算结果如下，和我们计算的结果是一致的，证明是正确的:

40

再给ObjectD[]数组指向具体的ObjectD对象，再测试一下结果：

  1. public static void main(String[] args) throws IllegalAccessException {
  2. final ClassIntrospector ci = new ClassIntrospector();
  3. ObjectInfo res;
  4. res = ci.introspect( new ObjectC() );
  5. System.out.println( res.getDeepSize() );
  6. }
  7. private static class ObjectC {
  8. ObjectD[] array = new ObjectD[2];
  9. public ObjectC(){
  10. array[0] = new ObjectD();
  11. array[1] = new ObjectD();
  12. }
  13. }
  14. private static class ObjectD {
  15. int value;
  16. }

我们可以手工计算一下ObjectC obj = new ObjectC()的大小：

ObjectC的Shallow size = 8(_mark) + 4(oop指针)  + 4(ObjectD[]引用) = 16

new ObjectD[2]数组的长度 =  8(_mark) + 4(oop指针) + 4(数组长度占4个字节) + 4(ObjectD[0]引用) + 4(ObjectD[1]引用) = 24

ObjectD对象长度 = 8(_mark) + 4(oop指针) + 4(value) = 16

所以ObjectC实际占用的空间 = 16 + 24 + 2 * 16 = 72

使用Unsafe的方式计算的结果也是72，和我们手工计算的方式一致。

其他参考链接:https://segmentfault.com/a/1190000004574249

Java对象大小计算的更多相关文章

  1. 两种计算Java对象大小的方法

    之前想研究一下unsafe类,碰巧在网上看到了这篇文章,觉得写得很好,就转载过来.原文出处是: http://blog.csdn.net/iter_zc/article/details/4182271 ...

  2. Java虚拟机14：Java对象大小、对象内存布局及锁状态变化

    一个对象占多少字节? 关于对象的大小,对于C/C++来说,都是有sizeof函数可以直接获取的,但是Java似乎没有这样的方法.不过还好,在JDK1.5之后引入了Instrumentation类,这个 ...

  3. Java对象大小：size和retained size

    最近看到网上很多文章讲如何计算java对象的大小(size),很多观点不敢苟同. 这是其中一篇比较靠前的文章,写的也比较全面: http://blog.csdn.net/iter_zc/article ...

  4. Java虚拟机18：Java对象大小、对象内存布局及锁状态变化

    一个对象占多少字节? 关于对象的大小,对于C/C++来说,都是有sizeof函数可以直接获取的,但是Java似乎没有这样的方法.不过还好,在JDK1.5之后引入了Instrumentation类,这个 ...

  5. java调优随记-java对象大小

    在java中,基本数据类型的大小是固定.但是java对象的大小是不固定的,需要通过计算. 在java中,一个空对象(没有属性和方法的对象)在堆中占用8byte,比如 Object obj = new ...

  6. Coherence对象压缩以及对象大小计算

    1.通过util.zip带的gzip压缩程序  Coherence对象压缩程序如下 package coherencetest; import com.tangosol.net.CacheFactor ...

  7. java对象大小

    Java对象的内存布局:对象头(Header),实例数据(Instance Data)和对齐填充(Padding) 对象头在32位系统上占用8B,64位系统上占16B. 无论是32位系统还是64位系统 ...

  8. 1）C++对象大小计算

          C++对象的大小不同的编译器的实现是不一样的,以下仅讨论.net2003,其他编译的可能出现的结果以下也做了分析和猜测.在反推不同编译器实现的C++对象的大小时.对齐是一个很重要也容易被遗 ...

  9. 如何准确计算Java对象的大小

    如何准确计算Java对象的大小 原创文章,转载请注明:博客园aprogramer 原文链接:如何准确计算Java对象的大小      有时,我们需要知道Java对象到底占用多少内存,有人通过连续调用两 ...

随机推荐

  1. Linux开机自动登录（文本模式）

    • Linux系统启动登录过程 以RedHat/CentOS为例,Linux系统Level3模式下从启动到登录的整个过程大致如下: 1> 加载BIOS信息:包含了CPU/显卡/内存/硬盘/网卡等 ...

  2. 博客整理——K米测评

    K米测评 1.233郑扬涛(orzyt) 博客链接:个人作业--关于K米的产品案例分析 亮点分析: 1.将整个软件各个功能模块的逻辑图都画出来了,而不是只画一个大概. 我做了个缩略图 2.第三部分 建 ...

  3. Python 动态创建函数【转】

    知乎上也有相似的问题 偶然碰到一个问题,初想是通过动态创建Python函数的方式来解决,于是调研了动态创建Python函数的方法. 定义lambda函数 在Python中定义lambda函数的写法很简 ...

  4. Qt-导入第三方库

    Qt提供了显式和隐式导入第三方库方法,本文只介绍显示导入方法. 第三方提供的库文件包括ControlCAN.h,ControlCAN.dll和ControlCAN.lib.将ControlCAN.h和 ...

  5. 【Network】TCPDUMP 详解

    参考资料: https://www.baidu.com/s?ie=UTF-8&wd=tcpdump%20%E6%8C%87%E5%AE%9Aip tcpdump非常实用的抓包实例:  http ...

  6. R语言进阶

    一.初学入门:<R in Action><The Art of_R Programming>入门者可首选两本,前者从统计角度入手,分高中低三部分由浅入深的讲解了如何用R来实现统 ...

  7. django（3） 一对多跨表查询、ajax、多对多

    1.一对多跨表查询获取数据的三种形式:对象.字典.元组 例:有host与business两张表,host与business的id字段关联,business在host表中的对象名是b,  通过查询hos ...

  8. Android源码阅读 – Zygote

    @Dlive 本文档: 使用的Android源码版本为:Android-4.4.3_r1 kitkat (源码下载: http://source.android.com/source/index.ht ...

  9. ALS

    最近看了一些关于ALS(肌萎缩性脊髓侧索硬化症)的电视剧和一本ALS患者的生活自述的书. 一次偶然的机会在一部日剧<我所存在的时间>中看到了ALS这种疾病,感觉这就像众病之王--癌症一样, ...

  10. 更改WAS Profiles的概要文件的server1的SDK版本

    WebSphere只能使用IBM JDK 哦,不能使用sun的JDK哦.不过如果只是改jdk的版本的话可以参考如下步骤:(以集群为例,假设具有管理节点Dmgr01,应用概要AppSrv01) 1. 确 ...