java - 将 Java Final 关键字添加到在循环内构建实例的工作方法

Question

采用以下 POJO:

public class Widget {
    private String fizz;
    private Long buzz;
    private List<Fidget> collaborators;

   // Constructor, getters & setters
}

public class Fidget {
    private String fizz;
    private String foo;

    // Constructor, getters & setters
}

以及以下(工作)方法:

public void compriseWidgets(List<Fidget> fidgetList) {
    List<Widget> widgets = new ArrayList<Widget>();
    Widget currentWidget = null;

    for (Fidget fidget : fidgetList) {
        if (currentWidget == null || 
                !currentWidget.getFizz().equals(fidget.getFizz())) {

            currentWidget = new Widget();
            widgets.add(currentWidget);
            currentWidget.setFizz(fidget.getFizz());
            currentWidget.setBuzz(fidget.getFoo().length());
        }

        currentWidget.getCollaborators().add(fidget);
    }

    return widgets;
}

这里我们要返回 List<Widget>并仅填充该列表:

1. 从第一个Fidget在输入列表中(因此 currentWidget == null )；和
2. 如果 Fidget和currentWidget有相同的fizz值

此外，我们希望继续附加 collaborators到currentWidget无论嘶嘶声是否匹配。

我的问题

新的代码风格指南要求我们用final声明ALL变量...这意味着我需要将上面的代码重构为如下所示:

public void compriseWidgets(final List<Fidget> fidgetList) {
    final List<Widget> widgets = new ArrayList<Widget>();
    final Widget currentWidget = null;

    for (final Fidget fidget : fidgetList) {
        ...
    }

    return widgets;
}

因为它需要创建一个新的 Widget 在循环内部，但是外部(循环外部)引用 Widget我们可以添加collaborators到，我完全不知道如何用 final 重写它。有任何想法吗？另外，请注意，这不是我可以“推回”的事情，我只需要弄清楚它并使其与新的编码标准一起工作。

Answer 1

为了扩展我的评论，您可以或多或少地机械地转换示例代码，如下所示:

public List<Widget> compriseWidgets(final List<Fidget> fidgetList) {
    final List<Widget> widgets = new ArrayList<Widget>();
    final Widget[] currentWidget = new Widget[] {null};

    for (final Fidget fidget : fidgetList) {
        if (currentWidget[0] == null || 
                !currentWidget[0].getFizz().equals(fidget.getFizz())) {

            currentWidget[0] = new Widget();
            widgets.add(currentWidget);
            currentWidget.setFizz(fidget.getFizz());
            currentWidget.setBuzz(fidget.getFoo().length());
        }

        currentWidget.getCollaborators().add(fidget);
    }

    return widgets;
}

许多变量可以设为final，而不会产生任何特殊影响，包括Fidgets 和Widgets 列表，以及增强的for 循环中的循环变量。原始方法中唯一的其他变量是 currentWidget，实现会对其进行修改。这可以替换为长度为 1 的 (final) 数组，其第 0 个元素可以用作原始变量的直接替换。

同样，一个更麻烦的要求是您不能使用赋值语句(变量声明中的初始化程序不被视为“赋值”)。这正在插入一种更实用的编程风格，我想这可能是您的新指南的目的。那么，您可以像这样处理它:

public List<Widget> compriseWidgets(final List<Fidget> fidgetList) {
    final List<Widget> widgets = new ArrayList<Widget>();
    final ListIterator<Fidget> fidgets = fidgetList.listIterator();

    while (addWidget(widgets, fidgets)) { /* empty */ }

    return widgets;
}    

private boolean addWidget(final List<Widget> widgets, final ListIterator<Fidget> fidgets) {
    if (fidgets.hasNext()) {
        final Fidget firstFidget = fidgets.next();
        final Widget currentWidget = new Widget();

        widgets.add(currentWidget);
        currentWidget.setFizz(firstFidget.getFizz());
        currentWidget.setBuzz(firstFidget.getFoo().length());
        currentWidget.getCollaborators().add(firstFidget);

        while (fidgets.hasNext()) {
            final nextFidget = fidgets.next();

            if (currentWidget.getFizz().equals(nextFidget.getFizz())) {
                currentWidget.getCollaborators().add(nextFidget);
            } else {
                fidgets.previous();
                return true;
            }
        }
    }

    return false;
}

这几乎是相同的技巧，只是不太明显。可变状态隐藏在调用堆栈中(每次调用 addWidget() 都代表原始方法的 currentWidget() 的突变)和容器对象中，计时 ListIterator。

人们可以在函数式编程方向上走得更远。例如，一般来说，您可以考虑基于流的方法，尽管我认为在这种特殊情况下这种方法并不能完全干净地发挥作用。然而，更通用的函数式编程没有适用于 Streams 的约束。