for循环的表达式中调用方法的效率问题

先看代码：

2. public class Test {
4.     public static void main(String[] args) {
5.         for (int i = 0; i < get(); i++) {
6.             System.out.println("Hello world");
7.         }
8.         System.out.println("-----------");
9.         int k = get();
10.         for (int i = 0; i < k; i++) {
11.             System.out.println("test2");
12.         }
13.     }
15.     public static int get() {
16.         return 5;
17.     }
18. }

问题：两个循环表达式哪个的效率更高一些？

      一般写程序的时候用第一种方式的情况较少，这是基本的编程风格要求之一。但是效率有何差别？ 根据编译原理上的知识，编译器有可能对这种运算进行优化。测试了一下：

1. Compiled from "Test.java"
2. public class Test extends java.lang.Object{
3. public Test();
4.   Code:
5.    0:   aload_0
6.    1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
7.    4:   return
9. public static void main(java.lang.String[]);
10.   Code:
11.    0:   iconst_0
12.    1:   istore_1
13.    2:   iload_1
14.    3:   invokestatic    #2; //Method get:()I
15.    6:   if_icmpge   23
16.    9:   getstatic   #3; //Field java/lang/System.out:Ljava/io/PrintStream;
17.    12:  ldc #4; //String Hello world
18.    14:  invokevirtual   #5; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
19.    17:  iinc    1, 1
20.    20:  goto    2
21.    23:  getstatic   #3; //Field java/lang/System.out:Ljava/io/PrintStream;
22.    26:  ldc #6; //String -----------
23.    28:  invokevirtual   #5; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
24.    31:  invokestatic    #2; //Method get:()I
25.    34:  istore_1
26.    35:  iconst_0
27.    36:  istore_2
28.    37:  iload_2
29.    38:  iload_1
30.    39:  if_icmpge   56
31.    42:  getstatic   #3; //Field java/lang/System.out:Ljava/io/PrintStream;
32.    45:  ldc #7; //String test2
33.    47:  invokevirtual   #5; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
34.    50:  iinc    2, 1
35.    53:  goto    37
36.    56:  return
38. public static int get();
39.   Code:
40.    0:   iconst_5
41.    1:   ireturn
43. }

        显然编译器没有预期的对代码进行优化。其实思考一下，这种情况下编译器并不能确定这是一个循环不变运算，因为它不能对方法调用的结果进行假设。