arrays - Gewusst wie: implementieren Sie eine Feste Größe "Liste" in Java?

Ich würde schreiben eine wrapper-Klasse um ein ArrayList, und in der add und addAll Methoden, würde ich prüfen, für die Liste die Größe, bevor Sie neue Elemente. Wenn Sie die maximale Größe erreichen, können Sie dann eine exception werfen (oder gar nichts, je nachdem, was Sie wirklich wollen in Ihrem code).

Hier ein kurzes Beispiel:

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
    }

InformationsquelleAutor Laf

12

Arrays.asList(T ...) Returns a fixed-size list backed by the specified array
```
Object[] array = new Object[10];
List<Object> fixedList = Arrays.asList(array);
```
- Also, wenn ich versuche, fügen Sie ein weiteres Objekt zu fixedList welcher bereits 10 Objekte, wird es eine exception werfen oder einfach nur still fail?
- hinzufügen geben Sie UnsupportedOperationException, können Sie nur die set-und get -, im Grunde verhält sich wie ein array.
InformationsquelleAutor Aviram Segal
5

Könnte man ein array verwenden, oder eine ArrayList<E> pre-initialized mit der gewünschten Größe.

Wenn Sie wollen aktiv verhindern die Erweiterung von der Liste, dann wird ein array verwenden, ist wahrscheinlich das einfachste.
- Aber wenn ich ein Objekt hinzufügen, das ArrayList Beispiel dazu führen würde, dass es zu überschreiten, seine Größe, wird es nicht automatisch zu erweitern?
- ja, es wird.
- Wenn Sie es tun, wird es. Sagen Sie, Sie wollen aktiv verhindern, dass Sie selbst dies zu tun?
- Ja, ich möchte aktiv zu verhindern, dass mich ab dies zu tun.
- Fair genug. In diesem Fall, ich persönlich würde stick mit einem array.
- Overkill, das ist ziemlich viel, was Arrays.asList implementiert selbst
InformationsquelleAutor NPE
3

Nur der Umsetzung Ihrer eigenen. Sie könnte verwenden Sie einen proxy-basierten Ansatz. Definieren Sie Ihre eigene Liste, die wird unterstützt durch eine ArrayList. Die interne Liste private. Auch eine einfache Implementierung limit Feld, das Standard-und auch über einen Konstruktor.

Ihre Liste implementieren List, und für jede Methode, die ändert der internen Liste, inkrementiert und dekrementiert die Anzahl entsprechend. Wenn die Größe überschreitet die Grenze, werfen irgendeine Art von Ausnahme. So etwas wie
```
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);
    }
    ...
}
```
Müssen Sie die Arbeit auf die Generika und denken Sie daran, unterstützen den Fällen, in denen mehrere Dinge auf einmal zugegeben addAll.
- Also nehmen wir ein ArrayList implementiert wurde um uns zu erlauben, zu verlängern, die Größe von arrays dynamisch und ändern Sie dann Ihr Verhalten, so können wir das nicht mehr? Na ja not not x ist das gleiche wie x, aber das ist eher sinnlos ist es nicht?
- Ich bin mir nicht sicher, was Ihr Punkt ist. Sagen Sie, dass die benutzerdefinierte Liste sollte ergänzt werden durch ein array statt?
- Gut, Sie entfernt alle zusätzlichen Funktionen, die ArrayList Hinzugefügt, über ein einfaches array, so konnten wir nur mit dem array selbst, oder wenn wir brauchen, hinzufügen und co Funktionen ja nur sichern, indem Sie ein array wäre einfacher zu.
- ja, das ist ein Gültiger Ansatz, obwohl ich überhaupt nicht, was ich habe "entfernt alle zusätzlichen Funktionen...". Ich persönlich würde eine Liste verwenden, um über ein array, weil ich nicht wollen, halten Sie den Zeiger, um den aktuellen index-und damit auch für Generika, aber die OP könnte ein array verwenden, wenn es zu seinem Zwecke.
InformationsquelleAutor hvgotcodes
2

Gut Sie konnten Erben von der Klasse ArrayList zum Beispiel, und implementieren Sie die add Methode nicht in der Lage, die Vergangenheit einer gegebenen Menge von Elementen. Oder, noch besser, da Zeiger aus, indem Laf, verwenden Zusammensetzung:
```
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;
         }
     }
}
```
- Das ist Art-von dem ich dachte, ich würde gehen wenn ich nicht wollte, um ein array zu verwenden.
- Ich würde nicht empfehlen, die Vererbung in diesem Fall aber eine wrapper-Klasse. Überschreiben der add Methode könnte mehr Probleme schaffen, weil Sie abhängig werden von der ArrayList Umsetzung. Dies ist etwas, was Josh Bloch erwähnt in seinem Effektive Java - Buch.
- Ich habe geschrieben ein Beispiel.
InformationsquelleAutor Tudor
0

Verwenden Collections.unmodifiableList(List<T> list). Das liefert eine generische List<T> Objekt, das wirft UnsupportedOperationException wenn Sie versuchen, hinzufügen oder entfernen von Elementen.

InformationsquelleAutor gregm
0

Werde ich mir wohl verbrannt, aber Sie können auch eine ArrayBlockingQueue für diese. Das bietet den Vorteil, in der Lage zu verwenden regelmäßige Sammlung Methoden.
- Sie nicht bieten Zugriff auf all - Liste von Methoden, obwohl (d.h. es nicht implementieren jede Art von Liste), insbesondere index-basierten Zugriff auf Methoden, die (für mich jedenfalls) wäre der Hauptgrund, Sie zu verwenden, die eine Liste in den ersten Platz.
- Stimmt, ich aktualisierte meine Antwort zu reflektieren, dass es wirklich implementiert Sammlung Operationen, nicht die Liste.
InformationsquelleAutor Perception

-1

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

        }

InformationsquelleAutor user6497465

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.