Source de l'article : Internet Auteur : PaleSting/CSDN
Dans cet article, nous examinerons les types de données en Java, mais nous introduirons le concept de types de données abstraits (ADT). Nous découvrirons également certains des ADT définis par Java en présentant le Java Collections Framework.
ADT
Un ADT est défini uniquement par le type de données qu'il contient et les opérations qui peuvent être effectuées sur ce type de données. Les développeurs ne peuvent accéder aux propriétés d'ADT que via les méthodes de fonctionnement d'ADT, et ils ne sauront pas comment les différentes opérations au sein de ce type de données sont implémentées.
En Java, on utilise souvent une interface pour fournir un ensemble d'opérations sans révéler les détails de la mise en œuvre de ces opérations. N'oubliez pas qu'une interface définit un ensemble de méthodes et qu'une classe Java doit implémenter cet ensemble afin de satisfaire ses conditions obligatoires ou implémenter une instance de l'interface.
Tables linéaires, piles et files d'attente
Quand on parle d'ADT, on parle souvent de listes linéaires, de piles et de files d'attente. Nous ne discuterons pas des détails de ces structures de données, mais nous expliquerons pourquoi elles sont appelées ADT.
Une liste linéaire est une collection d'éléments finis disposés de manière linéaire et donnant un accès direct à ses éléments. Une pile est une liste linéaire ordonnée dernier entré, premier sorti (LIFO). Les éléments sont ajoutés et supprimés de la tête de la pile. Une file d'attente est une liste linéaire ordonnée premier entré, premier sorti, les éléments sont ajoutés à la fin de la file d'attente et extraits de la tête de la file d'attente.
Les structures internes des listes linéaires, des piles et des files d'attente peuvent être implémentées de plusieurs manières. Par exemple, nous pourrions utiliser un tableau ordonné ou une liste chaînée pour implémenter chaque structure. Le point clé est que quelle que soit la manière dont vous implémentez sa structure interne, son interface externe restera toujours la même. Cela vous permet de modifier ou de mettre à niveau l'implémentation sous-jacente sans modifier l'interface publique.
Architecture des collections Java
Le kit de développement logiciel (SDK) Java 2 fournit de nouvelles classes pour prendre en charge les ADT les plus couramment utilisés. Ces classes sont appelées classes de collection Java (similaires aux classes de collection dans MFC) et elles fonctionnent ensemble pour former l'architecture de collection Java. Cette architecture de collection fournit un ensemble d'interfaces et de classes qui représentent les données sous forme de données dites abstraites de collection.
L'interface java.util.Collection est utilisée pour représenter n'importe quel groupe d'objets, c'est-à-dire des éléments. Cette interface fournit des opérations de base telles que l'ajout, la suppression et la requête. L'interface Collection fournit également une méthode itérateur. La méthode iterator renvoie une instance de l'interface java.util.Iterator. L'interface Iterator fournit les méthodes hasNext, next et delete. À l'aide des méthodes fournies par l'interface Iterator, vous pouvez parcourir les instances d'un objet Collection du début à la fin et supprimer en toute sécurité l'élément représenté par l'itérateur (curseur).
java.util.AbstractCollection est la base de toutes les classes d'architecture de collection. La classe AbstractCollection fournit des implémentations de toutes les méthodes de l'interface java.util.Collection, à l'exception des méthodes iterator et size. Ces deux méthodes d'exception sont implémentées par toutes les sous-classes qui héritent de java.util.AbstractCollection.
Une classe qui implémente une interface doit fournir l’implémentation de toutes les méthodes d’interface. Étant donné que certaines méthodes d'interface dans l'architecture de collection sont facultatives, il doit exister un moyen d'informer l'appelant qu'une certaine méthode n'est pas implémentée. Lorsqu'une méthode facultative est implémentée et que cette méthode n'est pas implémentée, une UnsupportedOperationException est levée. La classe UnsupportedOperationException hérite de la classe RuntimeException. Cela permet à l'appelant d'appeler toutes les opérations de collecte sans placer chaque appel dans une paire try-catch.
Tableau linéaire de liste
L'interface List hérite de l'interface Collection et définit une collection ordonnée qui permet à des éléments identiques d'exister. L'interface List ajoute également des méthodes qui utilisent une valeur d'index numérique pour opérer sur les éléments de la collection en fonction de la position de l'élément dans la liste linéaire. Ces opérations incluent l'ajout, l'obtention, la définition et la suppression.
L'interface List fournit également la méthode listIterator. Cette méthode renvoie une instance de l'interface java.util.ListIterator, qui vous permet de parcourir une liste linéaire du début à la fin ou de la fin à la fin. java.util.ListIterator hérite de l'interface java.util.Iterator. Par conséquent, il prend en charge l’ajout et la modification d’éléments dans la collection qu’il représente.
L'exemple suivant montre comment parcourir les éléments d'une liste de l'arrière vers l'avant. Pour ce faire, le ListIterator doit être positionné après le dernier élément de la liste avant le début du parcours.
ListIterator iter = aList.listIterator(aList.size());
tandis que (iter.hasPrevious())
System.out.println(iter.previous().toString());
}
L'architecture de collection fournit deux implémentations de l'interface List : LinkedList (liste liée) et ArrayList (liste de tableaux, c'est-à-dire liste statique). Les deux implémentations prennent en charge l'accès aléatoire à leurs éléments. Une instance ArrayList prend en charge les opérations de style tableau et les opérations de redimensionnement de tableau. Une instance de LinkedList fournit une prise en charge explicite pour l'ajout, la suppression et la fourniture d'éléments au début et à la fin de la liste. En utilisant ces nouvelles méthodes, un programmeur peut simplement utiliser une LinedList comme pile ou file d'attente, comme suit :
LinkedList aQueue = new LinkedList(aCollection);
aQueue.addFirst(newElement);
Objet anElement = aQueue.removeLast();
LinkedList aStack = new LinkedList(aCollection);
aStack.addFirst(newElement);
Objet anElement= aStack.removeFirst();
L'extrait de code du tableau A illustre certaines opérations courantes sur les instances d'implémentation de l'interface java.util.List à l'aide de java.util.ArrayList et java.util.LinkedList. Ces opérations incluent l'ajout d'éléments, l'accès aléatoire à des éléments et la suppression explicite d'éléments à la fin de la liste.
Savoir ce qui se passe et ne pas savoir pourquoi est très bénéfique
ADT fournit un outil puissant pour séparer les opérations dans l'interface publique d'un objet de son implémentation concrète. Cela permet à une implémentation ADT de changer et d'évoluer tout en gardant son interface publique inchangée. L'architecture de collection Java fournit un grand nombre d'interfaces et d'implémentations qui représentent des collections d'éléments de base et peuvent être utilisées pour créer des ADT utiles.