Java匿名内部类与Lambda表达式

匿名内部类适合创建那种只需要一次使用的类，而且必须继承一个父类或者实现一个接口，先看一段程序，该程序功能为实现数组数据的处理。
定义一个命令模式的接口，然后在处理数组数据的ProcessArray的类中调用类
GetSum、GetMax、GetMin的process方法（覆写接口process），这样编程看起来很复杂，其实遇到大型的程序会极大的简化程序，提高程序的扩展能力。我们定义这个Command接口时，我们并不知道process会有什么具体的处理方式，只有在调用该方法时才会指定具体的处理行为，需要什么功能只需要实现接口处理方法就行了。

interface Command{
    void process(int[] target);
}
class ProcessArray{
    public void process(int[] target,Command cmd){
        cmd.process(target);
    }
}
class GetSum implements Command{
    public void process(int[] target){
        int sum=0;
        for(int tmp:target){
            sum+=tmp;
        }
        System.out.println("sum= "+sum);

    }
}
class GetMax implements Command{
    public void process(int[] target){
        int max=0;
        for(int tmp:target){
            if(tmp>max)
                max=tmp;
        }
        System.out.println("max= "+max);
    }
}
class GetMin implements Command{
    public void process(int[] target){
        int min=0;
        for(int tmp:target){
            if(tmp"min= "+min);
    }
}
public class mycallable{
    public static void main(String[] args){
        ProcessArray p=new ProcessArray();
        int []array={2,3,5,8,1};
        p.process(array,new GetSum());
        p.process(array,new GetMax());
        p.process(array,new GetMin());
    }
}

输出结果如下：

下面我们用匿名内部类来改写该程序，为了简化程序只保留求数组数据最大值和数据和的方法：

interface Command{
    void process(int[] target);
}
class ProcessArray{
    public void process(int[] target,Command cmd){
        cmd.process(target);
    }
}
public class mycallable{
    public static void main(String[] args){
        ProcessArray p=new ProcessArray();
        int []array={2,3,5,8,1};
        //实现求取数组数据最大值
        p.process(array,new GetSum(){
            public void process(int[] target){
                int sum=0;
                for(int tmp:target){
                    sum+=tmp;
                }
                System.out.println("sum= "+sum);     
            }   
        });
        //实现求取数组数据最大值
        p.process(array,new GetMax(){
            public void process(int[] target){
                int max=0;
                for(int tmp:target){
                    if(tmp>max)
                        max=tmp;
                }
                System.out.println("max= "+max);   
            }
        });
    }
}

从程序结构来看，如果有很多功能在一块调用的话匿名内部类看起来很臃肿（只用一次的话还是极好的），匿名内部类原来要简化程序的本意就失去了。
Java8为我们提供了Lambd表达式，利用这个方法我们再来改写一下程序。

interface Command{
    void process(int[] target);
}
class ProcessArray{
    public void process(int[] target,Command cmd){
        cmd.process(target);
    }
}
public class mycallable{
    public static void main(String[] args){
        ProcessArray p=new ProcessArray();
        int []array={2,3,5,8,1};
        //实现求取数组数据最大值
        p.process(array,(int[] target)->{
                int sum=0;
                for(int tmp:target){
                    sum+=tmp;
                }
                System.out.println("sum= "+sum);        
        });
        //实现求取数组数据最大值
        p.process(array,(int[] target)->{
                int max=0;
                for(int tmp:target){
                    if(tmp>max)
                        max=tmp;
                }
                System.out.println("max= "+max);   
        });
    }
}

看看程序是不是又简化了四行。
Lambda表达式不需要new (){}这种繁琐的代码，不需要指出需要重写方法的名字也不需要给出重写方法的返回值类型，只要给出重写方法括号以及括号里的形参列表即可。
从而可以看出Lambda表达式的主要作用就是代替匿名内部类的繁琐语法。