Java “如何实施固定规模”；列表“；在爪哇？

既然Java核心库没有这样的集合，那么数组是否是最好的选择，特别是如果不想依赖第三方库的话？

您可以使用数组，或者使用预先初始化为所需大小的

数组列表

如果要主动阻止列表的扩展，则使用数组可能是最简单的方法。
返回由指定数组支持的固定大小列表

Object[] array = new Object[10];
List<Object> fixedList = Arrays.asList(array);

Object[]数组=新对象[10]；
List fixedList=Arrays.asList（array）；
例如，您可以从class
ArrayList继承，并重新实现
add
方法，使其不能添加超过给定数量的元素。或者，更像Laf指出的那样，使用合成：

public class MyArrayList<T> {
     private ArrayList<T> innerList;
     private int maxSize;

     public boolean add(T item) {
         if(innerList.size() < maxSize) {
             return innerList.add(item);
         } else {
             return false;
         }
     }
}

公共类MyArrayList{
私有ArrayList内部列表；
私有int-maxSize；
公共布尔加法（T项）{
if（innerList.size（）
只需实现自己的功能。您可以使用基于代理的方法。定义自己的列表，该列表由
ArrayList
支持。将内部列表设置为私有。还可以实现一个简单的
limit
字段，该字段具有默认值，也可以通过构造函数进行设置

您的列表将实现
list
，对于每个修改内部列表的方法，适当地增加和减少计数。如果大小超过限制，则引发某种异常。差不多

public class FixedList implements List {
    private ArrayList<E> list = new ArrayList<E>();
    private int limit = 10; // default

    FixedList(){} // default constructor

    FixedList(int limit) {
        this.limit = limit;
    }

    public boolean add(E object) {
       if (this.list.size() == limit - 1) {
           // throw some sort of LimitExceeded Runtime Exception
       }

       this.list.add(object);
    }
    ...
}

公共类FixedList实现列表{
private ArrayList list=new ArrayList（）；
private int limit=10；//默认值
FixedList（）{}//默认构造函数
固定列表（整数限制）{
这个极限=极限；
}
公共布尔添加（E对象）{
if（this.list.size（）==limit-1）{
//抛出某种运行时异常
}
此.list.add（对象）；
}
...
}

您必须处理泛型，并记住支持同时添加多个内容的情况
addAll
 我会围绕
ArrayList
编写一个包装类，在
add
和
addAll
方法中，我会在添加新元素之前检查列表的大小。如果已达到最大大小，则可以抛出异常（或不执行任何操作，具体取决于您真正希望在代码中执行的操作）

下面是一个简短的例子：

public class SizeLimitedArray<E> implements java.util.List<E>
    {
    private static final int DEFAULT_SIZE_LIMIT = 10;
    private ArrayList<E> myList;
    private int maxSize;

    public SizeLimitedArray ()
        {
        this (DEFAULT_SIZE_LIMIT);
        }

    public SizeLimitedArray (int size)
        {
        myList = new ArrayList<E> (size);
        maxSize = size;
        }

    @Override
    public boolean add (E objectToAdd)
        {
        if (myList.size () > maxSize)
            {
            throw new IllegalStateException ("The array is full");
            }

        return myList.add (objectToAdd);
        }

    @Override
    public boolean addAll (Collection collectionToAdd)
        {
        if (myList.size () + collectionToAdd.size () > maxSize)
            {
            throw new IllegalStateException ("The array is full");
            }

        return myList.addAll (collectionToAdd);
        }

    // Rest of class omitted for brevity
    }

public类SizeLimitedArray实现java.util.List
{
私有静态最终整数默认大小限制=10；
私人ArrayList myList；
私有int-maxSize；
公共尺寸（米）
{
这（默认大小限制）；
}
公共大小MiteMiteDarray（整数大小）
{
myList=新阵列列表（大小）；
最大尺寸=尺寸；
}
@凌驾
公共布尔添加（E objectToAdd）
{
if（myList.size（）>maxSize）
{
抛出新的IllegalStateException（“数组已满”）；
}
返回myList.add（objectToAdd）；
}
@凌驾
公共布尔addAll（集合集合集合添加）
{
if（myList.size（）+collectionToAdd.size（）>maxSize）
{
抛出新的IllegalStateException（“数组已满”）；
}
返回myList.addAll（collectionToAdd）；
}
//为了简洁起见，省略了课堂的其余部分
}
使用
集合。不可修改列表（列表列表）
。这将返回一个通用的
列表
对象，如果您试图添加（或删除）元素，该对象将抛出
UnsupportedOperationException
。
我可能会被烧掉，但您也可以使用。它提供了能够使用常规收集方法的好处。
公共类libsystem扩展了javax.swing.JFrame{
 public class libsystem extends javax.swing.JFrame {

   //public static ArrayList<books> al = new ArrayList<books>();
   public static List<books> al = Arrays.asList(new books[100]);
   public libsystem() {
    initComponents();
  }
   String msg =jTextArea1.getText();

    try {
        FileWriter fs=new FileWriter("library.txt");
        try(
            BufferedWriter out= new BufferedWriter(fs)){;
            out.write(msg);
        }
       } catch (Exception e){
        System.err.println("wrong" + e.getMessage());                                
  }
    String line;
    String id,name,type;
    try{
        FileReader in=new FileReader("library.txt");
        try (BufferedReader br = new BufferedReader(in)) {      

            while((line=br.readLine())!=null){      
                StringTokenizer st1 = new StringTokenizer(line,",");    
                while(st1.hasMoreTokens()){     
                    id=st1.nextToken();     
                    name=st1.nextToken();    
                    type=st1.nextToken();   
      books book=new books(id,name,type);    
                al.add(book);     
              }     
                br.close();    
        for(int i=0;i<al.size();i++){    
      books obj = al.get(i);    

        System.out.println("Book NAme :"+obj.getName()+ "\n" +"                                       Name:"+obj.getAuthor()+ "\n"+"Type :"+obj.getSubject()+"\n");                 

        }         

//public static ArrayList al=new ArrayList（）；
public static List al=Arrays.asList（新书[100]）；
公共图书馆系统（）{
初始化组件（）；
}
字符串msg=jTextArea1.getText（）；
试一试{
FileWriter fs=新的FileWriter（“library.txt”）；
试一试(
BufferedWriter out=新的BufferedWriter（fs））{；
out.write（msg）；
}
}捕获（例外e）{
System.err.println（“错误”+e.getMessage（））；
}
弦线；
字符串id、名称、类型；
试一试{
FileReader in=newfilereader（“library.txt”）；
try（BufferedReader br=new BufferedReader（in））{
而（（line=br.readLine（））！=null）{
StringTokenizer st1=新的StringTokenizer（行“，”）；
而（st1.hasMoreTokens（））{
id=st1.nextToken（）；
name=st1.nextToken（）；
type=st1.nextToken（）；
图书=新书（id、名称、类型）；
加（书）；
}     
br.close（）；
对于（int i=0；i如果我向
ArrayList
实例添加一个会导致它超出其大小的对象，它不会自动扩展吗？@mre:如果这样，它会自动扩展。你是说你想主动阻止自己这样做吗？@aix，是的，我想主动阻止自己这样做。@mre:很公平。在这种情况下，我个人会这样做的坚持使用数组。Overkill，这几乎就是Arrays.asList实现它自己的功能。这就是我认为如果我不想使用数组，我就必须去的地方。在这种情况下，我不建议继承，而是建议使用包装类。重写
add
方法可能会产生更多问题，因为您依赖
方法rrayList
实现。这是Josh Bloch在他的《有效的Java》一书中提到的。@mre:我已经发布了一个示例。因此，如果我尝试向
fixedList
添加另一个对象，它已经包含