如何在java中创建不可变列表？

我需要将可变列表对象转换为不可变列表。java中可能的方法是什么

public void action() {
    List<MutableClass> mutableList = Arrays.asList(new MutableClass("san", "UK", 21), new MutableClass("peter", "US", 34));
    List<MutableClass> immutableList = immutateList(mutableList);
}

public List<MutableClass> immutateList(List<MutableClass> mutableList){
    //some code here to make this beanList immutable
    //ie. objects and size of beanList should not be change.
    //ie. we cant add new object here.
    //ie. we cant remove or change existing one.
}

---

初始化

beanList

后，您可以执行以下操作

beanList = Collections.unmodifiableList(beanList);

使其不可修改。（见附件）

如果您既有可以修改列表的内部方法，也有不允许修改的公共方法，我建议您这样做

// public facing method where clients should not be able to modify list    
public List<Bean> getImmutableList(int size) {
    return Collections.unmodifiableList(getMutableList(size));
}

// private internal method (to be used from main in your case)
private List<Bean> getMutableList(int size) {
    List<Bean> beanList = new ArrayList<Bean>();
    int i = 0;

    while(i < size) {
        Bean bean = new Bean("name" + i, "address" + i, i + 18);
        beanList.add(bean);
        i++;
    }
    return beanList;
}

---

使用。您传入原始的

ArrayList

，它返回一个列表，如果您试图添加、删除或移动元素，该列表将引发异常。例如，使用

returncollections.unmodifiableList（beanList）

而不是

返回beanList

位于

getImmutableList（）的末尾
main（）
将引发异常。
Collections
类还具有用于除
List
之外的所有其他常见集合类型的方法。
下面的解决方案用于在不使用任何API的情况下使List不可变

具有ArrayList成员变量的不可变对象

public final class Demo {

    private final List<String> list = new ArrayList<String>();

    public Demo() {
        list.add("A");
        list.add("B");
    }

    public List<String> getImmutableList() {
        List<String> finalList = new ArrayList<String>();
        list.forEach(s -> finalList.add(s));
        return finalList;
    }

    public static void main(String[] args) {
        Demo obj = new Demo();
        System.out.println(obj.getImmutableList());
        obj.getImmutableList().add("C");
        System.out.println(obj.getImmutableList());
    }
}

公共最终课程演示{
私有最终列表=新的ArrayList（）；
公共演示（）{
列表。添加（“A”）；
列表。添加（“B”）；
}
公共列表getImmutableList（）{
List finalList=new ArrayList（）；
list.forEach->finalList.add；
回归终结者；
}
公共静态void main（字符串[]args）{
Demo obj=新的Demo（）；
System.out.println（obj.getImmutableList（））；
obj.getImmutableList（）.add（“C”）；
System.out.println（obj.getImmutableList（））；
}
}

因此，实际列表不会更改，始终从Java 10上输出[A，B]
，
列表。copyOf（Collection）可用于从给定集合返回不可修改的列表。来自
列表的源代码。copyOf
方法：


如果给定集合是不可修改的列表，
List.copyOf（）
将不会创建副本

如果给定集合是可变和修改的，则返回的列表将不会反映此类修改。这意味着他们是独立的

在JDK 8中：

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

如果您可以使用第三方库，s允许您从
可变列表
转换为
可变列表
，然后再转换回来

MutableList<String> mutable = Lists.mutable.with("a", "b", "c");
ImmutableList<String> immutable = mutable.toImmutable();
MutableList<String> mutableAgain = immutable.toList();

如果有一个
ArrayList
作为可变
列表
，则以下操作将起作用

List<String> mutable = new ArrayList<>(Arrays.asList("a", "b", "c"));
ImmutableList<String> immutable = Lists.immutable.withAll(mutable);
List<String> mutableAgain = immutable.toList();

List mutable=newarraylist（Arrays.asList（“a”、“b”、“c”））；
ImmutableList immutable=Lists.immutable.withAll（可变）；
List mutableReach=immutable.toList（）；

注意：我是Eclipse集合的提交者。
使其不可变，而不是直接使用列表上的不可修改列表，否则仍然可以更改原始列表

MutableCharList mutable = CharLists.mutable.with('a', 'b', 'c');
ImmutableCharList immutable = mutable.toImmutable();
MutableCharList mutableAgain = immutable.toList();

基本上，不可修改的集合是一个视图，因此间接地，它仍然可以从其他可修改的引用进行“修改”。另外，由于它只是其他集合的只读视图，所以当源集合更改时，不可修改的集合将始终显示最新的值

但是，不可变集合可以被视为另一个集合的只读副本，并且不能修改。在这种情况下，当源集合更改时，不可变集合不会反映更改

List<String> immutableList=Collections.unmodifiableList(
                            new ArrayList<String>(modifiableList));

List immutableList=Collections.unmodifiableList(
新建ArrayList（可修改列表））；

使用番石榴：

import java.util.*; 
import com.google.common.collect.ImmutableList; 
ImmutableList<String> iList = ImmutableList.copyOf(list); 

import java.util.*；
导入com.google.common.collect.ImmutableList；
ImmutableList iList=ImmutableList.copyOf（列表）；
在JavaSE9之前创建空的不可变列表

List<String> list = new ArrayList<String>();
list.add("Atto");
list.add("Rick");
list.add("Shalini");
List<String> immuList = Collections.unmodifiableList(list);

在Java9之前，我们必须使用Collections类的unmodifiableList（）方法来创建不可变列表

List<String> noElementList = new ArrayList<String>();
List<String> immuList = Collections.unmodifiableList(noElementList);

List noElementList=newarraylist（）；
List immuList=集合。不可修改列表（noElementList）；

在Java SE 9之前创建非空不可变列表

List<String> list = new ArrayList<String>();
list.add("Atto");
list.add("Rick");
list.add("Shalini");
List<String> immuList = Collections.unmodifiableList(list);

List List=new ArrayList（）；
列表。添加（“Atto”）；
列表。添加（“Rick”）；
列表。添加（“Shalini”）；
List immuList=集合。不可修改列表（List）；

Java 9–使用（）的静态工厂方法创建不可变列表

List immuList=List.of（）；

Java 9–创建非空不可变列表

List<String> immuList = List.of("Atto", "Rick", "Shalini");

List immuList=List.of（“Atto”、“Rick”、“Shalini”）；
您拥有的并不是不可变的，因为您可以非常轻松地调用.add（Object o）方法。创建ArrayList的子类，重写.add（..）方法，并使其具有空实现，或引发未检查的异常。然后，将该类设为最终类，这样您就不能将其子类化并更改实现您可以将列表包装在另一个对象中，只实现可移植接口回答您的问题：@dubey theHarcourtians，您应该查看此链接的完整答案，在下面三行给你答案我相信这个问题以前已经回答过了，但它不是So
getImmutableList（）的副本。
实际上创建了列表的防御副本，因此客户端无法修改原始列表？是的，客户端无法修改列表您的第二点是什么意思？通过使用
List.copyOf（Collection）
，您是否正在制作一个类似于建议的防御副本？确实如此。有关更多信息，请参阅。
List<String> list = new ArrayList<String>();
list.add("Atto");
list.add("Rick");
list.add("Shalini");
List<String> immuList = Collections.unmodifiableList(list);

List<String> immuList = List.of();

List<String> immuList = List.of("Atto", "Rick", "Shalini");