Question

由于Java核心库没有这样的集合，数组是否是最佳选择，特别是如果不想依赖第三方库？

Answer 1

Arrays.asList(T ...) Returns a fixed-size list backed by the specified array

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

Answer 2

您可以使用数组，或预先初始化为所需大小的ArrayList<E>。

如果您想主动阻止扩展列表，那么使用数组可能是最简单的。

Answer 3

我会在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
    }

Answer 4

实施自己的。您可以使用基于代理的方法。定义由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);
    }
    ...
}

您必须处理泛型，并记住支持同时添加多个内容的情况addAll。

Answer 5

例如，您可以从类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;
         }
     }
}

Answer 6

使用Collections.unmodifiableList(List<T> list)。这将返回一个通用的List<T>对象，如果您尝试添加（或删除）元素，则会抛出UnsupportedOperationException。

Answer 7

我可能会被烧毁，但您也可以使用ArrayBlockingQueue。这提供了能够使用常规集合方法的好处。

Answer 8

 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");                 

        }

如何在Java中实现固定大小的“列表”？

8 个答案: