Comparaison du vecteur Java et de la liste Array
Aujourd'hui, j'ai étudié les codes source de Vector et ArrayList et approfondi ma compréhension de ces deux classes.
Il y a trois classes implémentées dans l'interface de liste: ArrayList, Vector et LinkedList. Je ne dirai pas grand-chose sur LinkedList, il est généralement utilisé pour maintenir l'ordre d'insertion des données.
ArrayList et Vector sont tous deux implémentés à l'aide de tableaux, et il existe trois différences principales:
1. Le vecteur est multi-thread et sûr, tandis que ArrayList ne l'est pas. Cela peut être vu à partir du code source. De nombreuses méthodes de la classe vectorielle sont modifiées par synchronisées, ce qui conduit à l'efficacité du vecteur qui ne peut pas être comparé à ArrayList;
2. Les deux utilisent des éléments de stockage d'espace continu linéaires, mais lorsque l'espace est insuffisant, les deux classes sont ajoutées différemment. De nombreux internautes disent que le vecteur double l'espace d'origine et ArrayList augmente l'espace d'origine de 50%. En fait, c'est à peu près la même. Cependant, il y a encore des problèmes qui peuvent être vus à partir du code source, et il sera analysé à partir du code source ultérieur.
3. Vector peut définir le facteur de croissance, mais ArrayList ne peut pas. Quand j'ai regardé cela pour la première fois, je ne comprenais pas quel était le facteur incrémentiel. Cependant, je l'ai compris en comparant les deux codes source. Examinons d'abord les méthodes de construction des deux classes:
ArrayList a trois méthodes de construction:
public ArrayList (int initialCapacity) // Construisez une liste vide avec la capacité initiale spécifiée. public ArrayList () // Construisez une liste vide avec une capacité initiale de 10. Public ArrayList (Collection <? Étend E> C) // Construisez une liste d'éléments contenant la collection spécifiée
Vector a quatre constructeurs:
Vector public () // Construisez un vecteur vide en utilisant la capacité initiale et l'incrément de capacité spécifié égal à zéro. Vector public (int initialCapacity) // Construisez un vecteur vide pour faire la taille de son réseau de données interne, et son incrément de capacité standard est nul. Vector public (Collection <? étend E> C) // Construire un vecteur contenant des éléments dans la collection spécifiée Vector Public (int INI initialCapacity, int CapacityIncrement) // Construire un vecteur vide en utilisant la capacité initiale et les incréments de capacité spécifiés
Le vecteur a une méthode de construction de plus que ArrayList. C'est vrai, la méthode de construction du vecteur public (int initialeCapacité, int la capacité encrément). La capacité de la capacité est la croissance de la capacité, qui est le facteur de croissance mentionné ci-dessus, qui n'est pas disponible dans ArrayList.
Puis publiez deux classes pour ajouter l'analyse du code source (version JDK1.7):
// classe ArrayList Add Code source: public boolean add (e e) {AssurecapacityInternal (taille + 1); // incréments modCount !! elementData [size ++] = e; Retour Vrai; } private void assurecapacityInternal (int mincapacity) {modCount ++; // Code soucieux du trop-plein // Si après avoir ajouté un élément, la taille du nouveau conteneur est supérieure à la capacité du conteneur, la valeur ne peut pas être enregistrée. L'espace doit être élargi si (mincapacité - elementData.length> 0) se développer (mincapacité); } private void Grow (int Mincapacity) {// Code de trop-flux int Int OldCapacity = elementData.Length; int newcapacity = oldcapacity + (oldcapacity >> 1); // L'espace d'extension augmente de 50% (c'est-à-dire 1,5 fois l'original) if (newcapacity - mincapacity <0) // Si le conteneur n'est toujours pas suffisant après l'expansion, alors définissez simplement Mincapacity à la taille du conteneur newcapacity = mincapacité; if (newCapacity - max_array_size> 0) // Si le conteneur élargi est trop grand, exécutez HugeCapacity NewCapacity = HugeCapacity (Mincapacity); // La mincapacité est généralement proche de la taille, il s'agit donc d'une victoire: elementData = arrays.copyof (elementData, newcapacity); } Ajoutez du code source à la classe vectorielle:
Public synchronisé boolean add (e e) {modCount ++; AssurecapacityHelper (élémentCount + 1); elementData [elementCount ++] = e; Retour Vrai; } private void assurecapacityHelper (int mincapacity) {// code de trop-flux if (mincapacity - elementData.length> 0) grandir (mincapacity); } private void Grow (int Mincapacity) {// Code de trop-flux int Int OldCapacity = elementData.Length; int newcapacity = oldcapacity + ((capacineIncrement> 0)? CapacitéIncrement: oldCapacity); / ** Cette expansion de la capacité nécessite un jugement: si l'incrément de capacité n'est pas initialisé de 0, c'est-à-dire l'initialisation du constructeur de vecteur public (Int initiale, int la capacité d'intrigue), alors la capacité d'expansion de la capacité est (OldCapacity + CapacityIncrement), qui est la valeur de la capacité d'origine plus la capacité de capacité; Si l'incrément de capacité n'est pas réglé, la capacité après l'expansion est (OldCapacity + OldCapacity), ce qui est le double de la capacité d'origine. ** / if (newcapacity - mincapacity <0) newcapacity = mincapacity; if (newCapacity - max_array_size> 0) newCapacity = HugeCapacity (mincapacity); elementData = arrays.copyof (elementData, newCapacity); }Grâce à l'analyse, cela devrait être compréhensible maintenant!
Merci d'avoir lu, j'espère que cela peut vous aider. Merci pour votre soutien à ce site!