Étant donné que la bibliothèque de Core Java n'a pas une telle collection, une matrice serait la meilleure option, surtout si on ne veut pas compter sur des bibliothèques tiers?
8 Réponses :
Vous pouvez utiliser un tableau ou un tableau Si vous voulez que vous voulez activement empêcher l'expansion de la liste, l'utilisation d'un tableau est probablement le plus facile.
Mais si j'ajoute un objet à l'instance ArrayList qui le ferait de dépasser sa taille, n'est-ce pas automatiquement étendue?
@mre: Si vous le faites, ce sera. Vous dites que vous voulez vous empêcher activement de le faire?
@aix, oui, je veux m'empêcher activement de le faire.
@mre: assez juste. Dans ce cas, je colle personnellement avec un tableau.
Overkill, c'est à peu près ce que les tableaux.Aslist se met en œuvre
.Aslist (T ...) renvoie une liste de taille fixe soutenue par le tableau spécifié
Donc, si j'essaie d'ajouter un autre objet à fixeList qui contient déjà 10 objets, va-t-il lancer une exception ou simplement en silence?
Ajouter vous donnera une erreur non supportée. Vous ne pouvez utiliser que définir et obtenir, se comporter essentiellement comme un tableau.
Eh bien, vous pouvez hériter de la classe ArrayList code> par exemple et réimplément la méthode Ajouter code> pour ne pas pouvoir ajouter une quantité donnée d'éléments. Ou encore mieux en tant que pointeur de la LAF, utilisez la composition: 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;
}
}
}
C'est un peu où je pensais que je devais aller si je ne voulais pas utiliser un tableau.
Je ne recommanderais pas l'héritage dans ce cas, mais une classe d'emballage. La méthode de la méthode Ajouter peut créer plus de problèmes, car vous deviendrez dépend de la mise en œuvre de l'arraylist . C'est quelque chose que Josh Bloch mentionne dans son livre livre Java .
@mre: J'ai posté un exemple.
Il suffit de mettre en œuvre le vôtre. Vous pouvez utiliser une approche à base de proxy. Définissez votre propre liste qui est soutenue par un Votre liste implémentera Vous devrez travailler sur les génériques et que vous n'oubliez pas de prendre en charge les cas où plusieurs choses sont ajoutées à la fois ArrayList . Faire la liste interne privée. Implémentez également un champ simple limite qui a une valeur par défaut et peut également être défini via un constructeur. Liste , et pour chaque méthode qui modifie la liste interne, l'incrément et les décréments de manière appropriée. Si la taille dépasse la limite, lancez une sorte d'exception. Quelque chose comme addall .
Nous prenons donc un ArrayList qui a été mis en place pour nous permettre d'étendre la taille des tableaux de manière dynamique, puis de changer son comportement afin que nous ne puissions plus le faire? Bien oui pas x est identique à celui x , mais c'est plutôt inutile n'est-ce pas?
Je ne suis pas sûr de ce que votre point est. Êtes-vous en train de dire que sa liste personnalisée doit être soutenue par un tableau à la place?
Eh bien, vous avez supprimé toutes les fonctionnalités supplémentaires que ARRAYLIST a ajouté sur un tableau simple, nous pourrions donc simplement utiliser le tableau lui-même - ou si nous avons besoin de fonctions ADD et CO Oui, juste la sauvegarde par un tableau serait Plus simple aussi.
Ouais c'est une approche valide, bien que je ne suis pas d'accord ce que j'ai "supprimé toutes les fonctionnalités supplémentaires ...". Personnellement, j'utiliserais une liste sur un tableau car je ne veux pas avoir à maintenir le pointeur à l'indice actuel et à tout cela, ainsi que pour les génériques, mais OP pourrait utiliser un tableau s'il convient à ses objectifs.
J'écrirais une classe wrapper autour d'un code> arraylist code>, et dans le Voici un court exemple: P> Ajouter code> et addall code>, je vérifierais la liste taille avant d'ajouter de nouveaux éléments. Si vous avez atteint la taille maximale, vous pouvez ensuite lancer une exception (ou ne rien faire, en fonction de ce que vous voulez vraiment faire dans votre code). 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
}
Utiliser collections.unmodifiablelist (liste list non-pritéePrèsException Si vous essayez d'ajouter (ou de supprimer) éléments.
Je vais probablement être brûlé, mais vous pouvez également utiliser un ArrayBlockingQueue pour cela. Qui offre au profit d'être capable d'utiliser des méthodes régulières
Il n'offre pas d'accès à toutes les méthodes de liste , cependant (c.-à-d. Il ne met pas en œuvre aucune liste de liste) - en particulier les méthodes d'accès à l'index, qui (pour moi de toute façon) serait la principale raison utiliser une liste en premier lieu.
Vrai, j'ai mis à jour ma réponse pour refléter qu'il met vraiment en œuvre les opérations de collecte, pas la liste.
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");
}
Quel comportement voulez-vous lorsque vous essayez d'ajouter un article à une liste complète? Vous devriez probablement aussi avoir une méthode qui vérifie s'il y a un peu d'espace.
Arrays.Aslist fait exactement ceci.
La question est ambiguë: la liste est corrigée? ou sa taille est fixe?