Question

一位采访者问我这个问题，在不使用集合API方法的情况下在java中创建一个只读列表。关于我们如何实现这一点的任何想法？

Answer 1

只需展开AbstractList即可。正如文档所述：

要实现不可修改的列表，程序员只需要扩展这个类并提供get（int）和size（）的实现方法

Answer 2

使用@EnableBatchProcessing方法，这将返回一个不可变的@EnableBatchProcessing对象。尝试调用添加或删除会抛出Arrays.asList。

使用：

ArrayList

来自javadoc的

：

public static List asList（T ... a） 返回由指定数组支持的固定大小列表。（对返回列表的更改＆＃34;通过＆＃34;写入数组。）此方法与Collection.toArray（）结合，充当基于数组的API和基于集合的API之间的桥梁。返回的列表是可序列化的，并实现RandomAccess。

当您调用RuntimeException时，它将返回List<Integer> ints = Arrays.asList(1,2,3,4); ints.forEach(System.out::println); ints.add(5); // will thrw exception（内部类）而不是Array.asList，使其成为ArrayList的不可变版本

Answer 3

我已覆盖get(int)和size()，但addPerson仍然可以向String添加新的ArrayList。

import java.util.AbstractList;
import java.util.ArrayList;

public class UnmodifyableList extends AbstractList
{
    public UnmodifyableList()
    {
        arrayList = new ArrayList<>();
        arrayList .add("Artyom");
        arrayList .add("Natasha");
        arrayList .add("Anton");
        arrayList .add("Dasha");
    }

    @Override
    public String get(int i)
    {
        return arrayList.get(i);
    }

    @Override
    public int size()
    {
        return arrayList.size();
    }

    public void addPerson()
    {
        arrayList.add("testname");
    }
}

但是当我删除addPerson()并使用从AbstractList继承的方法时，是的，结果是ArrayList无法修改。

Answer 4

我尝试下面的一些事情，希望它会有所帮助：

import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class ImutableList {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        List<Integer> lsd = new ArrayList<Integer>();
        lsd.add(1);
        lsd.add(2);
        lsd.add(3);
        lsd.add(4);

        ImList imList = new ImList(lsd);
        imList.getLis().add(5);
        imList.getLis().add(6);
        imList.getLis().add(7);
        imList.getLis().add(8);

        for (int k : imList.getLis()) {
            System.out.println(k);
        }
// output will: 1 2 3 4 only    

        }

    static class ImList extends AbstractList<Integer> {

        private final List<Integer> list;

        public ImList(List list) {
            this.list = list;
        }

        @Override
        public Integer get(int index) {
            // TODO Auto-generated method stub
            return this.list.get(index);
        }

        @Override
        public int size() {
            // TODO Auto-generated method stub
            return this.list.size();
        }

        public List<Integer> getLis() {
            return new ArrayList<>(list);
        }

    }

}

Answer 5

我在接受采访时被问到了同样的问题，我提出了一些在我的案例中运作良好的代码，并且采访者得到了相信。

员工类

public final class Employee {
 private int age;
 private String name;
 private double salary;
 public Employee(int age, String name, double salary){
    this.name=name;
    this.age=age;
    this.salary=salary;
 }

 public int getAge() {
    return age;
 }
 public String getName() {
    return name;
 }
 public double getSalary() {
    return salary;
 }
}

EmployeeList类

public class EmployeeList extends AbstractList<Employee>{

private ArrayList<Employee> list;

 public EmployeeList(ArrayList<Employee> list){
    this.list=list;
 }

 @Override
 public Employee get(int i) {
    return this.list.get(i);
 }

 @Override
 public int size() {
    return this.list.size();
 }

}

EmployeeListUtility Class

public class EmployeeListUtility {
 private EmployeeList employeeList;
 public EmployeeList getImmutableEmployeeList(ArrayList<Employee> employeeList) {
    this.employeeList = new EmployeeList(employeeList);
    return this.employeeList;
 }

}

亚军类

public class RunnerClass {
public static void main(String[] args) {
    ArrayList<Employee> listOfEmployees=new ArrayList<>();
    listOfEmployees.add(new Employee(1, "Faizan", 1000));
    listOfEmployees.add(new Employee(2, "Arun", 1000));
    listOfEmployees.add(new Employee(3, "Amit", 1000));
    listOfEmployees.add(new Employee(4, "Noman", 1000));
    listOfEmployees.add(new Employee(5, "John", 1000));

    //till now listOfEmployee is mutable

    EmployeeListUtility employeeListUtility=new EmployeeListUtility();
    EmployeeList employeeList=employeeListUtility.getImmutableEmployeeList(listOfEmployees);
    //now employeeList object is immutable. 
    System.out.println(employeeList.size()); //print 5
    employeeList.clear();  //will throw java.lang.UnsupportedOperationException 
}

}

现在使用运行者类中的 employeeList 对象，如果您尝试访问抽象列表中尚未在 EmployeeList 类中实现的任何其他方法，然后它将抛出java.lang.UnsupportedOperationException。

这意味着您的employeeList现在是不可变的。

如何在不使用集合API的unmodifiablelist方法的情况下在java中创建只读列表？

5 个答案: