（转）java中final 与效率

转自 http://songhongchen.iteye.com/blog/361685

关于final关键字，总是那么些疑惑，今天就总结一下。
一.final的概念：在Java中, 可以使用final关键字修饰类、方法以及成员变量。
1.final标记的类不能被继承;
在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。
2.final标记的方法不能被子类复写; 如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。
使用final方法的原因有二：第一、把方法锁定，防止任何继承类修改它的意义和实现。
第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。
3.final标记的变量即成为常量,只能被赋值一次.
二、final的用法 1、final 对于常量来说，意味着值不能改变，例如 final int i=100。这个i的值永远都是100。
但是对于变量来说又不一样，只是标识这个引用不可被改变，例如 final File f=new File("c:\test.txt");那么这个f一定是不能被改变的，如果f本身有方法修改其中的成员变量，例如是否可读，是允许修改的。有个[/size][size=medium][size=large][/size]形象的比喻：一个女子定义了一个final的老公，这个老公的职业和收入都是允许改变的，只是这个女人不会换老公而已。
2、关于空白final final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。
　另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。
public class FinalTest { final int p; final int q=3;
FinalTest(){ p=1; } FinalTest(int i){ p=i;//可以赋值，相当于直接定义p
q=i;//不能为一个final变量赋值 } }
3、final内存分配刚提到了内嵌机制，现在详细展开。
要知道调用一个函数除了函数本身的执行时间之外，还需要额外的时间去寻找这个函数（类内部有一个函数签名和函数地址的映射表）。所以减少函数调用次数就等于降低了性能消耗。
final修饰的函数会被编译器优化，优化的结果是减少了函数调用的次数。如何实现的，举个例子给你看：
public class Test{ final void func(){System.out.println("g");};
public void main(String[] args){ for(int j=0;j<1000;j++)
func(); }} 经过编译器优化之后，这个类变成了相当于这样写： public class Test{ final void func(){System.out.println("g");}; public void main(String[] args){
for(int j=0;j<1000;j++) {System.out.println("g");} }}
看出来区别了吧？编译器直接将func的函数体内嵌到了调用函数的地方，这样的结果是节省了1000次函数调用，当然编译器处理成字节码，只是我们可以想象成这样，看个明白。
不过，当函数体太长的话，用final可能适得其反，因为经过编译器内嵌之后代码长度大大增加，于是就增加了jvm解释字节码的时间。

在使用final修饰方法的时候，编译器会将被final修饰过的方法插入到调用者代码处，提高运行速度和效率，但被final修饰的方法体不能过大，编译器可能会放弃内联，但究竟多大的方法会放弃，我还没有做测试来计算过。
本文是通过两个疑问来继续阐述的：

1、使用final修饰方法会提高速度和效率吗；
见下面的测试代码，我会执行五次：

public class Test    
{    
    public static void getJava()    
    {    
        String str1 = "Java ";    
        String str2 = "final ";    
        for (int i = 0; i < 10000; i++)    
        {    
            str1 += str2;    
        }    
    }    
    public static final void getJava_Final()    
    {    
        String str1 = "Java ";    
        String str2 = "final ";    
        for (int i = 0; i < 10000; i++)    
        {    
            str1 += str2;    
        }    
    }    
    public static void main(String[] args)    
    {    
        long start = System.currentTimeMillis();    
        getJava();    
        System.out.println("调用不带final修饰的方法执行时间为:" + (System.currentTimeMillis() - start) + "毫秒时间");    
        start = System.currentTimeMillis();    
        String str1 = "Java ";    
        String str2 = "final ";    
        for (int i = 0; i < 10000; i++)    
        {    
            str1 += str2;    
        }    
        System.out.println("正常的执行时间为:" + (System.currentTimeMillis() - start) + "毫秒时间");    
        start = System.currentTimeMillis();    
        getJava_Final();    
        System.out.println("调用final修饰的方法执行时间为:" + (System.currentTimeMillis() - start) + "毫秒时间");    
    }    
}

public class Test
{
    public static void getJava()
    {
        String str1 = "Java ";
        String str2 = "final ";
        for (int i = 0; i < 10000; i++)
        {
            str1 += str2;
        }
    }
    public static final void getJava_Final()
    {
        String str1 = "Java ";
        String str2 = "final ";
        for (int i = 0; i < 10000; i++)
        {
            str1 += str2;
        }
    }
    public static void main(String[] args)
    {
        long start = System.currentTimeMillis();
        getJava();
        System.out.println("调用不带final修饰的方法执行时间为:" + (System.currentTimeMillis() - start) + "毫秒时间");
        start = System.currentTimeMillis();
        String str1 = "Java ";
        String str2 = "final ";
        for (int i = 0; i < 10000; i++)
        {
            str1 += str2;
        }
        System.out.println("正常的执行时间为:" + (System.currentTimeMillis() - start) + "毫秒时间");
        start = System.currentTimeMillis();
        getJava_Final();
        System.out.println("调用final修饰的方法执行时间为:" + (System.currentTimeMillis() - start) + "毫秒时间");
    }
}

结果为：
第一次：
调用不带final修饰的方法执行时间为:1732毫秒时间

正常的执行时间为:1498毫秒时间
调用final修饰的方法执行时间为:1593毫秒时间
第二次：

调用不带final修饰的方法执行时间为:1217毫秒时间
正常的执行时间为:1031毫秒时间

调用final修饰的方法执行时间为:1124毫秒时间
第三次：

调用不带final修饰的方法执行时间为:1154毫秒时间
正常的执行时间为:1140毫秒时间

调用final修饰的方法执行时间为:1202毫秒时间
第四次：

调用不带final修饰的方法执行时间为:1139毫秒时间
正常的执行时间为:999毫秒时间

调用final修饰的方法执行时间为:1092毫秒时间
第五次：

调用不带final修饰的方法执行时间为:1186毫秒时间
正常的执行时间为:1030毫秒时间

调用final修饰的方法执行时间为:1109毫秒时间

由以上运行结果不难看出，执行最快的是“正常的执行”即代码直接编写，而使用final修饰的方法，不像有些书上或者文章上所说的那样，速度与效率与“正常的执行”无异，而是位于第二位，最差的是调用不加final修饰的方法。
观点：加了比不加好一点。

1、使用final修饰变量会让变量的值不能被改变吗；

见代码：

public class Final    
{    
    public static void main(String[] args)    
    {    
        Color.color[3] = "white";    
        for (String color : Color.color)    
            System.out.print(color+" ");    
    }    
}    
   
class Color    
{    
    public static final String[] color = { "red", "blue", "yellow", "black" };    
}

public class Final  
{  
    public static void main(String[] args)  
    {  
        Color.color[3] = "white";  
        for (String color : Color.color)  
            System.out.print(color+" ");  
    }  
}  
  
class Color  
{  
    public static final String[] color = { "red", "blue", "yellow", "black" };  
}

执行结果：

red blue yellow white

看！，黑色变成了白色。

在使用findbugs插件时，就会提示public static String[] color = { "red", "blue", "yellow", "black" };这行代码不安全，但加上final修饰，这行代码仍然是不安全的，因为final没有做到保证变量的值不会被修改！原因是：final关键字只能保证变量本身不能被赋与新值，而不能保证变量的内部结构不被修改。例如在main方法有如下代码Color.color = new String[]{""};就会报错了。那可能有的同学就会问了，加上final关键字不能保证数组不会被外部修改，那有什么方法能够保证呢？答案就是降低访问级别，把数组设为private。这样的话，就解决了数组在外部被修改的不安全性，但也产生了另一个问题，那就是这个数组要被外部使用的。
解决这个问题见代码：

import java.util.AbstractList;    
import java.util.List;    
   
public class Final    
{    
    public static void main(String[] args)    
    {    
        for (String color : Color.color)    
            System.out.print(color + " ");    
        Color.color.set(3, "white");    
    }    
}    
   
class Color    
{    
    private static String[] _color = { "red", "blue", "yellow", "black" };    
    public static List<String> color = new AbstractList<String>()    
    {    
        @Override   
        public String get(int index)    
        {    
            return _color[index];    
        }    
        @Override   
        public String set(int index, String value)    
        {    
            throw new RuntimeException("为了代码安全,不能修改数组");    
        }    
        @Override   
        public int size()    
        {    
            return _color.length;    
        }    
    };

import java.util.AbstractList;  
import java.util.List;  
  
public class Final  
{  
    public static void main(String[] args)  
    {  
        for (String color : Color.color)  
            System.out.print(color + " ");  
        Color.color.set(3, "white");  
    }  
}  
  
class Color  
{  
    private static String[] _color = { "red", "blue", "yellow", "black" };  
    public static List<String> color = new AbstractList<String>()  
    {  
        @Override  
        public String get(int index)  
        {  
            return _color[index];  
        }  
        @Override  
        public String set(int index, String value)  
        {  
            throw new RuntimeException("为了代码安全,不能修改数组");  
        }  
        @Override  
        public int size()  
        {  
            return _color.length;  
        }  
    };  
}

这样就OK了，既保证了代码安全，又能让数组中的元素被访问了。