Talk is cheap, show me your code!

看一段代码：

/**
 * 在lambda表达式内部，修改lambda表达式外部的局部变量的值
 */
private synchronized void updateLocalVariable() {

    List<String> list = new ArrayList<>();
    list.add("444");
    list.add("4444");

    int count = 0;
    // 这样写会报错。Local variable result defined in an enclosing scope must be final or effectively final
    list.stream().forEach(str -> System.out.println("当前是第" + (count++) + "次循环" + str));
}

 

如果你试图在lambda表达式内部修改外部局部变量的值，请注意，这里的2个限定条件：
1，count在lambda外部。
2，count是局部变量。

那么jvm会无情的告诉你：
Local variable result defined in an enclosing scope must be final or effectively final

原因其实也很简单，本质上就是因为lambda表达式在方法内部，那么lambda表达式的内存分配就是在栈上。栈内存不存在线程安全问题，因为栈内存存的都是变量的副本。
对于局部变量count而言，它的生命周期就是所在方法的生命周期。这就决定了count无法被位于同一个栈帧上的lambda修改，因为这种修改毫无意义，
你无法将你的修改传递出当前栈帧。栈内存不会被共享，也就意味着你没有权利和其他栈帧通信。

如果非要在lambda内部修改lambda表达式外部的局部变量的值呢？
有两种方式：使用数组或者把局部变量定义为全局变量。

这2种方式，其实本质是一样的：内存都分配在堆上。这就决定了，使用这2种方式来修改变量的值，是可行的。

 

使用数组代码如下：

/**
     * 使用数组
     */
    private synchronized void updateLocalVariableArray() {

        List<String> list = new ArrayList<>();
        list.add("444");
        list.add("4444");

        int[] count = {0};
        list.stream().forEach(str -> System.out.println(count[0]++));
    }

 

使用全局变量也可以，很简单，这里不再列出代码。但是有个问题，全局变量需要考虑线程安全问题。

 

接下来我们讨论另外一个问题：如何用lambda替换for循环，实现计数功能。
我要知道当前处理的是第几行，比如每100条记录提交一次什么的，类似这种功能，平时需求还是很常见的。
代码实例如下：

 

private void updateLocalVariableForLoop() {

    List<String> list = new ArrayList<>();
    list.add("444");
    list.add("4444");
    list.add("090");
    // 传统for循环方式
    int count = 0;
    for (String str : list) {
        System.out.println("当前是第" + (count++) + "次循环" + str);
    }
}

 

这里提供3种方式：
1，内部类方式 参考方法 updateLocalVariableInnerClass
2，lambda方式 参考方法 updateLocalVariableLambda
3，外部类方式 参考方法 updateLocalVariableOuterClass

 

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

/**
 * 如何用lambda替换for循环，实现计数功能。
 */
public class LambdaLocalVariableUpdate {

    /**
     * 全局变量
     */
    private static int GLOBAL_COUNT = 0;

    public static void main(String[] args) {

        LambdaLocalVariableUpdate lambdaLocalVariableUpdate = new LambdaLocalVariableUpdate();
//        lambdaLocalVariableUpdate.updateLocalVariableInnerClass(); // 通过对象来实现计数，绕开本地变量，但是存在 线程安全问题
//        lambdaLocalVariableUpdate.updateLocalVariableLambda(); // 通过对象来实现计数，绕开本地变量，但是存在 线程安全问题
//        System.out.println(Thread.currentThread().getName() + "-lambda外部变量GLOBAL_INT = " + GLOBAL_INT);
        // 启动多线程，测试是否存在线程安全问题。
        for (int i = 0; i < 30; i++) {
            Thread thread = new Thread(() -> lambdaLocalVariableUpdate.updateLocalVariableInnerClass());
            thread.setName("线程-" + (i + 1));
            thread.start();
        }
    }


    /**
     * 使用lambda方式
     * 不存在线程安全问题
     */
    private void updateLocalVariableLambda() {

        List<String> list = new ArrayList<>();
        list.add("444");
        list.add("4444");
        list.add("090");

        Stream.iterate(0, i -> i + 1).limit(list.size()).forEach(index -> {
            String str = list.get(index);
            System.out.println("当前是第" + index + "次循环" + str);
        });
    }

    /**
     * 内部类方式，不存在线程安全问题，但是不易扩展。
     *
     */
    private void updateLocalVariableInnerClass() {

        CountInner count = new CountInner();
        List<String> list = new ArrayList<>();
        list.add("444");
        list.add("4444");
        list.add("090");

        list.stream().forEach(str -> System.out.println("当前是第" + count.count() + "次循环" + str));
    }

    /**
     * 外部类方式，不存在线程安全问题，但是变量要定义为非静态，如果定义为静态，则存在线程安全问题。
     *
     */
    private void updateLocalVariableOuterClass() {

        CountOuter count = new CountOuter();
        List<String> list = new ArrayList<>();
        list.add("444");
        list.add("444");
        list.add("555");

        list.stream().forEach(str -> System.out.println("当前是第" + count.count() + "次循环" + str));
    }

    /**
     * 内部类
     */
    class CountInner {

        private int i = 0;
        public Integer count() {

            return i++;
        }
    }

}

class CountOuter {

    private int i = 0;
    public Integer count() {

        return i++;
    }
}

 

 

最后，要特别说明一下，如果你要修改的是某个对象的值，比如List集合，那是完全没问题的。

 

/**
 * 在lambda内部修改List集合
 */
private void updateLocalVariableCollection() {

    List<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(100);

    List<Integer> list2 = new ArrayList<>(list.size());

    list.stream().forEach(intVal -> {
        if (intVal > 0) {
            // 在lambda内部，修改list2
            list2.add(intVal);
        }
    });
}