[转载]java编译器对于循环进行了真正的编译优化吗？

java编译器对于循环进行了真正的编译优化吗？
此文章只是用来在java编译器进行循环化方面的验证，本文是有感而发，并希望求得大家的分析结果，这里引用了一位网友的话（没有人身攻击的色彩）:
///
对于Vector v=new Vector()若v中包含了10000个对象,我们进行一个loop如下
for(int I=0; I大家一定会用如下的写法吧
int size = v.size(); for(int I=0; I///
但有些网友说(只是为了说明问题而已，无攻击色彩）：
不能用完全解释语言过程来理解Java，v.size()在循环中并没有被调用10000次，因为，编译的循环优化会对其进行优化，
因此，实际运行时只运行一次，和用初始化v.size()的程序效率一样。这是很早的编译优化机制。
大家肯定这种说法正确吗？我不太赞同,很简单地可以用一个test作难证:
一个类Vector的类TetstObj.java

2. public class TestObj {
3. int count=0;
4. public TestObj() {
5. count+=5;
6. }
7. public int size(){
8. System.out.println("size="+count);
9. return count;
10. }
11. }

测试类:test.java

2. public class test{
3. public test(){}
4. public static void main(String[] args){
5. TestObj similarVector=new TestObj();
6. for(int i=1;i
7. //do something
8. }
9. }
10. }

结果还是5个size=1的打印结果.
size=5
size=5
size=5
size=5
size=5
大家也可以分析一下java.util.Vector这个类(下面摘录Vector的部分源码)
例如只以一个insert对象而言:

2. /**
3. * Returns the number of components in this vector.
4. *
5. * @return the number of components in this vector.
6. */
7. protected int elementCount;
8. /**
9. * Inserts the specified object as a component in this vector at the
10. * specified index. Each component in this vector with
11. * an index greater or equal to the specified index is
12. * shifted upward to have an index one greater than the value it had
13. * previously.

14. *
15. * The index must be a value greater than or equal to 0
16. * and less than or equal to the current size of the vector. (If the
17. * index is equal to the current size of the vector, the new element
18. * is appended to the Vector.)

19. *
20. * This method is identical in functionality to the add(Object, int) method
21. * (which is part of the List interface). Note that the add method reverses
22. * the order of the parameters, to more closely match array usage.
23. *
24. * @param obj the component to insert.
25. * @param index where to insert the new component.
26. * @exception ArrayIndexOutOfBoundsException if the index was invalid.
27. * @see #size()
28. * @see #add(int, Object)
29. * @see List
30. */
31. public synchronized void insertElementAt(Object obj, int index) {
32. modCount++;
33. if (index >= elementCount + 1) {
34. throw new ArrayIndexOutOfBoundsException(index
35. + " > " + elementCount);
36. }
37. ensureCapacityHelper(elementCount + 1);
38. System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
39. elementData[index] = obj;
40. elementCount++;
41. }
42. /**
43. * Returns the number of components in this vector.
44. *
45. * @return the number of components in this vector.
46. */
47. public synchronized int size() {
48. return elementCount;
49. }

这象上面的similarVector对象一样,v.size()会每次调用Vector中的size()方法,10000次的调用一次也不会少吧!!
所以就我自身来说我不会相信java的对循环的编译优化,你呢??有何见解,请给出你的想法!大家也可以评论一些其它编译器的优化问题,
也给每位来读者一个好的回报!

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/374079/viewspace-130811/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/374079/viewspace-130811/