在Lambda中操作集合时，PMD的LocalVariableCouldBeFinal规则是否有效？

Great question—let's break this down clearly to understand why PMD is flagging this, and whether the rule applies here.

First, let's clarify the core of the LocalVariableCouldBeFinal rule: it checks whether a local variable's reference is ever reassigned, not whether the object the variable points to is immutable.

Why the Rule Applies to Your adjacentNodeSet #

Looking at your code:

Set<String> adjacentNodeSet = new HashSet<>();
nodesLocal.stream().forEach(node -> adjacentNodeSet.addAll(getAdjacentNodes(node)));

You only assign a value to adjacentNodeSet once (when you initialize it with new HashSet<>()). After that, you never reassign the variable itself—you're just modifying the internal state of the HashSet using addAll().

The final modifier for a local variable doesn't prevent you from changing the object's contents—it just prevents you from pointing the variable to a different object. So declaring adjacentNodeSet as final is completely safe here, and PMD's suggestion is valid. You can update that line to:

final Set<String> adjacentNodeSet = new HashSet<>();

Does This Apply to All Collection Types/Variable Scenarios? #

Let's split this into cases:

• Local variables (like your adjacentNodeSet): The rule applies whenever the variable's reference isn't reassigned. It doesn't matter if the object is a Set, List, Map, or any other mutable type—so long as you never do something like adjacentNodeSet = new TreeSet<>() later, you can mark it as final.
• Instance/static variables: The LocalVariableCouldBeFinal rule doesn't target these at all. This rule is specifically for method-scoped local variables and catch block parameters. For instance/static variables, separate rules (like FieldCouldBeFinal) may apply if their reference isn't changed after initialization, but that's a distinct check.

Quick Example to Highlight the Difference #

This is allowed with a final local variable (modifying the object's internal state):

final List<String> names = new ArrayList<>();
names.add("Alice"); // No issue—we're not changing what `names` points to

This is not allowed with a final local variable (reassigning the variable reference):

final List<String> names = new ArrayList<>();
names = new LinkedList<>(); // Breaks the `final` contract—we're changing what `names` points to

内容的提问来源于stack exchange，提问作者Rizwan