Declaring a List field with the final keyword

问题

If I have the following statement within a class where Synapse is an abstract type:

private final List<Synapse> synapses;

Does final allow me to still be able to change the state of the Synapse objects in the List, but prevent me from adding new Synapse objects to the list? If I am wrong, could you please explain what final is doing and when I should be using the keyword final instead.

回答1:

No, the final keyword does not make the list, or its contents immutable. If you want an immutable List, you should use:

List<Synapse> unmodifiableList = Collections.unmodifiableList(synapses);

What the final keyword does is prevent you from assigning a new value to the 'synapses' variable. I.e., you cannot write:

final List<Synapse> synapses = createList();
synapses = createNewList();

You can, however, write:

List<Synapse> synapses = createList();
synapses = createNewList();

回答2:

final prevents you from reassigning synapses after you've assigned it once - you can still add/remove elements as you would normally. You can read more about the final keyword here.

回答3:

The Java Language Specification writes:

A variable can be declared final. A final variable may only be assigned to once. Declaring a variable final can serve as useful documentation that its value will not change and can help avoid programming errors.

It is a compile-time error if a final variable is assigned to unless it is definitely unassigned (§16) immediately prior to the assignment.

A blank final is a final variable whose declaration lacks an initializer.

Once a final variable has been assigned, it always contains the same value. If a final variable holds a reference to an object, then the state of the object may be changed by operations on the object, but the variable will always refer to the same object.

Therefore, if you wish to enforce that the state reachable through the variable does not change, you have to declare the variable final, use an unmodifiable List (for instance with Collections.unmodifiableList), and make Synapse objects immutable.

回答4:

You can still change, add and remove the contents of the list, but cannot create a new list assigned to the variable.

回答5:

The final implementation implies that object reference once initiated, the reference itself can never be changed but the content can of course be. Its not violating the rules at all. You have specified only one rule about the reference change which is working accordingly. If you want the values should also never change you should go for immutable lists i.e

List<String> items = Collections.unmodifiableList(Arrays.asList("a", "b", "c"));

See the following related question.

Final variable manipulation in Java

回答6:

Above answer explained all in theory here you can find code to run and see actual diffrence ,advisable to use loacal variable

package exp_test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class testList {
    final static List<String> synapses = new ArrayList();;

    public static void main(String[] args) {

        synapses.add("A");
        System.out.println(synapses);
        //
        System.out.println(finalLisTest(synapses));
        //
        System.out.println(synapses);
        //
        synapses.add("B");

        List<String> unmodifiableList = Collections.unmodifiableList(synapses);
        System.out.println(finalLisTest(unmodifiableList));
        //
        System.out.println(unmodifiableList);

    }

    private static List finalLisTest(List<String> list) {
        list.remove(0);
        return null;

    }

}

Results :

[A]
null
[]
Exception in thread "main" java.lang.UnsupportedOperationException
    at java.util.Collections$UnmodifiableList.remove(Collections.java:1317)
    at exp_test.testList.finalLisTest(testList.java:29)
    at exp_test.testList.main(testList.java:22)

来源：https://stackoverflow.com/questions/13079365/declaring-a-list-field-with-the-final-keyword

标签

java

list

final