¿Cómo implementar una "lista" de tamaño fijo en Java?

Question

Dado que la biblioteca central de Java no tiene dicha colección, ¿una matriz sería la mejor opción, especialmente si uno no desea confiar en bibliotecas de terceros?

Answer 1

Escribía una clase contenedora alrededor de un ArrayList, y en los métodos add y addAll, buscaba el tamaño de la lista antes de agregar nuevos elementos. Si ha alcanzado el tamaño máximo, puede lanzar una excepción (o no hacer nada, dependiendo de lo que realmente quiera hacer en su código).

Aquí hay un pequeño ejemplo:

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 2

Puede usar una matriz o ArrayList<E> preinicializada con el tamaño deseado.

Si desea activamente evitar la expansión de la lista, y luego usar una matriz es probablemente la más fácil.

Answer 3

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 4

Bien se podría heredar de la clase ArrayList por ejemplo y reimplementar el método add a no ser capaz de añadir más allá de una determinada cantidad de elementos. O, incluso mejor como puntero por Laf, use la composición:

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 5

Simplemente implemente la suya. Podría usar un enfoque basado en proxy. Defina su propia lista respaldada por ArrayList. Haga que la lista interna sea privada. También implemente un campo simple limit que tiene un valor predeterminado y también se puede establecer a través de un constructor.

Su lista implementará List, y para cada método que modifique la lista interna, incremente y disminuya el conteo de manera apropiada. Si el tamaño excede el límite, lanza algún tipo de excepción. Algo así como

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); 
    } 
    ... 
} 

Tendrá que trabajar en los genéricos, y recordar a apoyar a los casos en los que se añaden múltiples cosas a la vez addAll.

Answer 6

Uso Collections.unmodifiableList(List<T> list). Esto devolverá un objeto genérico List<T> que arroja UnsupportedOperationException si intenta agregar (o eliminar) elementos.

Answer 7

Probablemente me queme, pero también puede usar un ArrayBlockingQueue para esto. Lo que proporciona la ventaja de poder utilizar los métodos Colección regulares.

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

     }