匿名內部類適合建立那種只需要一次使用的類，而且必須繼承一個父類或者實現一個介面，先看一段程式，該程式功能為實現陣列資料的處理。
定義一個命令模式的介面，然後在處理陣列資料的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=tmp;
        }
        System.out.println("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表示式的主要作用就是代替匿名內部類的繁瑣語法。