ArrayList Classe

Définition

[Android.Runtime.Register("java/util/ArrayList", DoNotGenerateAcw=true)]
[Java.Interop.JavaTypeParameters(new System.String[] { "E" })]
public class ArrayList : Java.Util.AbstractList, IDisposable, Java.IO.ISerializable, Java.Lang.ICloneable, Java.Util.IRandomAccess

[<Android.Runtime.Register("java/util/ArrayList", DoNotGenerateAcw=true)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "E" })>]
type ArrayList = class
    inherit AbstractList
    interface ISerializable
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable
    interface ICloneable
    interface IList
    interface ICollection
    interface IIterable
    interface ISequencedCollection
    interface IRandomAccess

Héritage

Object

JavaObject

Object

AbstractCollection

AbstractList

ArrayList

Attributs

RegisterAttribute JavaTypeParametersAttribute

Implémente

IJavaObject IJavaPeerable ISerializable ICloneable IIterable ICollection IList IRandomAccess ISequencedCollection IDisposable

Remarques

Implémentation de tableau redimensionnable de l’interface List . Implémente toutes les opérations de liste facultatives et autorise tous les éléments, y compris null. Outre l’implémentation de l’interface List , cette classe fournit des méthodes pour manipuler la taille du tableau utilisé en interne pour stocker la liste. (Cette classe est à peu près équivalente à Vector, sauf qu’elle n’est pas synchronisée.)

Les sizeopérations , isEmptygetsetiteratoret listIterator s’exécutent en temps constant. L’opération add s’exécute en temps constant amorti, autrement dit, l’ajout de n éléments nécessite le temps O(n). Toutes les autres opérations s’exécutent en temps linéaire (à peu près). Le facteur constant est faible par rapport à celui de l’implémentation LinkedList .

Chaque ArrayList instance a une capacité. La capacité est la taille du tableau utilisé pour stocker les éléments dans la liste. Il est toujours au moins aussi grand que la taille de liste. À mesure que des éléments sont ajoutés à un TableauList, sa capacité augmente automatiquement. Les détails de la stratégie de croissance ne sont pas spécifiés au-delà du fait que l’ajout d’un élément a un coût de temps amorti constant.

Une application peut augmenter la capacité d’une ArrayList instance avant d’ajouter un grand nombre d’éléments à l’aide de l’opération ensureCapacity . Cela peut réduire la quantité de réaffectation incrémentielle.

< >notez que cette implémentation n’est pas synchronisée.</strong> Si plusieurs threads accèdent simultanément à une ArrayList instance et qu’au moins un des threads modifie la liste structurellement, il doit être synchronisé en externe. (Une modification structurelle est toute opération qui ajoute ou supprime un ou plusieurs éléments, ou redimensionne explicitement le tableau de stockage ; il suffit de définir la valeur d’un élément n’est pas une modification structurelle.) Cela s’effectue généralement en synchronisant sur un objet qui encapsule naturellement la liste.

Si aucun objet de ce type n’existe, la liste doit être « encapsulée » à l’aide de la Collections#synchronizedList Collections.synchronizedList méthode. Cela est le mieux fait au moment de la création pour empêcher l’accès non synchronisé accidentel à la liste :

List list = Collections.synchronizedList(new ArrayList(...));

Les itérateurs retournés par les méthodes et les méthodes de #iterator() iterator cette classe sont #listIterator(int) listIteratorem<fail-fast>/em< : si la liste est structurellement modifiée à tout moment après la création de l’itérateur, à tout moment, sauf par le biais des propres > ou ListIterator#remove() remove méthodes de l’itérateur, l’itérateur lève un ListIterator#add(Object) add.ConcurrentModificationException Par conséquent, face à la modification simultanée, l’itérateur échoue rapidement et correctement, plutôt que de risquer un comportement arbitraire et non déterministe à un moment indéterminé à l’avenir.

Notez que le comportement de défaillance rapide d’un itérateur ne peut pas être garanti, en général, impossible d’apporter des garanties difficiles en présence d’une modification simultanée non synchronisée. Les itérateurs à vitesse d’échec lèvent ConcurrentModificationException un meilleur effort. Par conséquent, il serait incorrect d’écrire un programme qui dépendait de cette exception pour son exactitude : le comportement d’itérateur à échec doit être utilisé uniquement pour détecter les bogues.

Cette classe est membre de l’infrastructure de collections Java.

Ajouté dans la version 1.2.

Java documentation pour java.util.ArrayList.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.