Analyse détaillée de la classe ArrayList [Partie 1]

Cet article examinera en détail la classe ArrayList du Collections Framework, qui est peut-être la plus simple à comprendre, car elle est basée sur un tableau standard. Lors de l'entretien, on vous posera presque certainement une question sur cette classe et son implémentation en Java. Dans la deuxième partie, nous analyserons les méthodes restantes et écrirons notre propre implémentation d'un tableau dynamique pour les nombres. La classe ArrayList hérite de la classe AbstractList et implémente les interfaces suivantes : List, RandomAccess, Cloneable, Seriallessly. Une analyse détaillée de la classe ArrayList [Partie 2] La classe ArrayList prend en charge les tableaux dynamiques qui peuvent être étendus selon les besoins. Sa nécessité et son efficacité s'expliquent par le fait qu'un tableau régulier a une longueur fixe : une fois créé, il ne peut ni grandir ni rétrécir, ce qui impose des restrictions si l'on ne sait pas quelle taille le tableau sera nécessaire. Essentiellement, la classe ArrayList est un tableau de listes de longueur variable de références d’objets. Il est important de comprendre que la taille (nombre de cellules) du tableau interne ne diminue pas automatiquement lorsque des éléments en sont supprimés. En effet, la valeur de la variable size, qui indique le nombre d'éléments réellement présents dans le tableau, est diminuée. Disons que nous créons un nouvel objet de la classe ArrayList et y ajoutons 5 éléments. Par défaut, un tableau de 10 éléments est créé. Dans ce cas, la capacité (taille/volume) de notre objet sera égale à 10, mais la valeur de la variable sizesera égale à cinq. Et lorsque nous supprimons des éléments, nous constatons des changements dans la valeur de la variable size, car nous .lengthne pouvons pas accéder au tableau interne de la classe ArrayList et connaître sa longueur. La taille peut être réduite à l'aide d'une méthode supplémentaire trimToSize(), qui sera discutée plus tard. Regardons les champs de classe.

• Champ responsable du volume par défaut du tableau dynamique :

  private static final int DEFAULT_CAPACITY = 10

  Lors de la création d'un nouvel objet new ArrayList<>() (un constructeur sans paramètre), un tableau de 10 éléments est créé à l'intérieur.

• Un champ dans lequel sont stockés tous les éléments de la collection :

  transient Object[] elementData

  Marqué par un mot-clé transient- le champ n'est pas écrit dans le flux d'octets lors de l'utilisation de l'algorithme de sérialisation standard. Il convient de noter que le champ n'est pas marqué du mot-clé private, mais cela a été fait afin de faciliter l'accès à ce champ à partir de classes imbriquées (par exemple, SubList).

• Un champ compteur qui stocke le nombre d'éléments réellement présents dans le tableau :

  private int size

  La valeur est incrémentée/décrémentée lors de l'exécution d'opérations telles que l'insertion et la suppression.

Il y a 3 champs supplémentaires dans la classe, mais ils sont essentiellement supplémentaires, il ne sert donc à rien de les considérer. La classe a trois constructeurs :

1. public ArrayList()– crée un tableau de liste vide de 10 éléments ;
2. public ArrayList(Collection < ? extends E > c)– crée un tableau de listes initialisé avec des éléments de la collection passée (si nous voulons créer un nouveau ArrayList basé sur une collection) ;
3. public ArrayList(int initialCapacity)– crée un tableau de listes avec une capacité initiale. Si le paramètre transmis initialCapacity est supérieur à 0, alors un tableau de la taille spécifiée est créé (le champ interne elementData se voit attribuer un lien vers un nouveau tableau de type Object de taille initialCapacity). Si le paramètre est 0, alors un tableau vide est créé. Si le paramètre spécifié est inférieur à 0, une IllegalArgumentException est levée.

Création d'un objet

List < String> list = new ArrayList<>();

L'objet nouvellement créé listcontient des propriétés (champs) elementDataet size. Un magasin de valeurs elementDatan'est rien de plus qu'un tableau d'un type spécifique (spécifié en générique – <>), dans notre cas String[]. Si un constructeur sans paramètres est appelé, alors par défaut un tableau de 10 éléments de type Object sera créé (avec un transtypage vers le type, bien sûr). Ajout d'éléments Classiquement, l'ajout d'éléments à un tableau de liste se fait à l'aide de variantes surchargées de add().

public boolean add(E элемент)

Eh bien, ajoutons : list.add("0"); à l'intérieur de cette méthode, une version surchargée de la méthode est add()appelée, marquée comme private, qui à son tour prend trois paramètres en entrée : l'élément à ajouter, le tableau interne et sa taille. Dans la méthode privée, une vérification a lieu : si le paramètre size transmis est égal à la longueur du tableau interne (c'est-à-dire que le tableau est plein), alors le tableau se voit attribuer le résultat de la méthode grow(int minCapacity)(la valeur actuelle du champ size + 1 est passé à la méthode, puisqu'il faut prendre en compte l'élément à ajouter), dans laquelle l'interne du tableau se voit attribuer un lien vers le nouveau tableau créé obtenu en copiant les éléments du tableau d'origine :

Arrays.copyOf(elementData, newCapacity(minCapacity))

Comme deuxième paramètre de la méthode, copyOfnous indiquons le résultat de la méthode newCapacity(int minCapacity), dans lequel la nouvelle taille du tableau est calculée. Il est calculé à l'aide de la formule suivante : int newCapacity = oldCapacity + (oldCapacity >> 1) Pour un tableau avec la taille par défaut, ce qui suit sera vrai : >> 1– décalage au niveau du bit vers la droite de un (opérateur qui réduit un nombre à la moitié). Essentiellement, cela signifie diviser par 2 à la puissance 1. Il s'avère que nous divisons 10 par 2 et ajoutons 10. Au total, la nouvelle capacité du tableau est de 15, mais puisque nous ajoutons le 11ème élément, alors 15 + 1 = 16. Revenons à notre liste et supposons que nous y ayons déjà ajouté 10 éléments et essayons d'en ajouter 11. La vérification montrera qu'il n'y a pas d'espace dans le tableau. En conséquence, un nouveau tableau est créé et appelé Arrays.copyOf, qui utilise en interne la méthode système System.arraycopy(). Ou voici un exemple clair tiré d'un article sur JavaRush : après toutes ces vérifications et en augmentant la taille du tableau si nécessaire, dans une méthode privée, add()un nouvel élément est ajouté à la fin du tableau et le paramètre actuel sizeest augmenté d'un. . L'ancien tableau sera ensuite traité par le garbage collector. Voici comment fonctionne un tableau dynamique : lorsque l'on ajoute des éléments, on vérifie s'il y a encore de la place dedans. S'il y a de l'espace, nous ajoutons simplement l'élément à la fin du tableau. La fin ne désigne pas la dernière cellule du tableau, mais la cellule qui correspond à la valeur size. Nous avons ajouté le premier élément au tableau ; il est placé dans la cellule d'index [0]. La valeur du champ sizea augmenté de un et = 1. On ajoute l'élément suivant : on voit que size = 1, en conséquence on place l'élément dans la cellule d'index [1] et ainsi de suite. Il existe une version surchargée de la méthode avec deux paramètres :

public void add(int index, E element)

Nous pouvons spécifier la position (index) de la cellule où nous voulons ajouter l'élément. Tout d'abord, l'exactitude de la valeur d'index spécifiée est vérifiée, car il est possible qu'un index incorrect soit spécifié, ce qui pointera vers une cellule où il n'y a rien, ou qui n'existe tout simplement pas. Vérification des index : index > size || index < 0– si l'index spécifié est supérieur à la taille actuelle du tableau ou s'il est inférieur à 0, alors une exception est levée IndexOutOfBoundsException. Ensuite, si nécessaire, la taille du tableau est augmentée, comme dans l’exemple ci-dessus. Vous avez probablement entendu dire que lors des opérations d'ajout/suppression dans un tableau, quelque chose est déplacé quelque part (soit vers la droite, soit vers la gauche). Ainsi, le décalage s'effectue en copiant le tableau : System.arraycopy(elementData, index, elementData, index + 1, s - index); Tous les éléments situés à droite de l'index spécifié seront décalés d'une position vers la droite (index+1). Et seulement après cela, un nouvel élément est ajouté au tableau interne à l'index spécifié. Puisque nous avons décalé une partie du tableau vers la droite d'un point (un nouveau tableau n'est pas créé), la cellule dont nous avons besoin sera libre d'écriture. Le lien vers l'ancien tableau est effacé et à l'avenir il sera repris par le garbage collector. Collez "maserati" dans la cellule [3], qui est déjà occupée : Ainsi, lorsqu'un élément est inséré à l'index et qu'il n'y a pas d'espace libre dans le tableau, l'appel System.arraycopy()se produira deux fois : le premier dans grow(), le second dans la méthode elle-même add(index, value), ce qui affectera clairement la vitesse de toute l'opération d'ajout. En conséquence, lorsqu'il est nécessaire d'écrire un autre élément dans le tableau interne, mais qu'il n'y a pas d'espace là-bas, voici ce qui se passe dans ArrayList :

• Un nouveau tableau est créé avec une taille 1,5 fois plus grande que celle d'origine, plus un élément.
• Tous les éléments de l'ancien tableau sont copiés dans le nouveau tableau
• Le nouveau tableau est stocké dans la variable interne de l'objet ArrayList et l'ancien tableau est déclaré poubelle.

La capacité des objets de type ArrayList peut être augmentée manuellement à l'aide de la méthode :

public void ensureCapacity(int minCapacity)

En augmentant la capacité de la baie à l'avance, vous pouvez éviter une redistribution supplémentaire de la RAM ultérieurement. La méthode augmente la taille du tableau interne pour s'adapter au nombre d'éléments transmis à minCapacity. La méthode ensureCapacity()n'affecte pas le champ size, elle affecte la capacity(taille du) tableau interne. Encore une fois, je souligne que sizeles deux sont capacitydes choses différentes et qu’il est très important de ne pas les confondre ! Si vous souhaitez réduire la taille du tableau sous-jacent à partir duquel ArrayList est construit au nombre actuel d'éléments réellement stockés, vous devez appeler le trimToSize(). Après avoir supprimé des éléments de la collection, size()le nombre d'éléments réellement existants s'affichera et capacityne diminuera pas ! Supposons que nous saisissions 100 éléments, supprimions les 50 premiers, sizeil deviendra égal à 50 et capacityrestera donc 100. Pour réduire et capacity, nous devons utiliser la méthode trimToSize(), qui ajuste toute notre capacité à la taille actuelle. Comment ça se met? Copie notre tableau afin qu'il ne reste plus de cellules vides (la longueur du nouveau tableau est simplement égale au champ taille). Vous pouvez également ajouter des éléments à notre collection en utilisant le addAll.

public boolean addAll(Collection< ? extends E> c)
public boolean addAll(int index, Collection< ? extends E> collection);

La première option vous permet d'ajouter tous les éléments de la collection spécifiée dans le paramètre de méthode (par exemple, une autre feuille) à la collection d'origine (insérer à la fin) pour laquelle l'appel de méthode a été effectué. La collection transmise (il peut également s'agir d'un ensemble) est convertie en tableau à l'aide du toArray(). Bien entendu, l'opération d'ajout s'effectue également par copie. La seconde consiste à ajouter tous les éléments collectionà la liste, en commençant par index index. Dans ce cas, tous les éléments seront décalés vers la droite du nombre d'éléments dans la liste collection. Supprimer des éléments Tout d'abord, regardons les options classiques pour supprimer des éléments d'une ArrayList.

public E remove(int index)

Effectue la suppression par index et décale tous les éléments suivants (après l'élément à l'index spécifié) vers la gauche, fermant ainsi les « trous ». Il renvoie également l'élément supprimé (E), qui est préalablement écrit dans une variable supplémentaire avant suppression, dont nous obtenons la valeur à la suite de l'appel de méthode. Pour comprendre ce qu'est E, vous devrez vous familiariser avec les types dits génériques. La notation E indique que la méthode renvoie le type de données qui a été spécifié lors de la création de l'objet ArrayList (rappelez-vous : List <String> list, respectivement, dans ce cas, E sera « substitué » String). Pour une compréhension générale, je vous recommande fortement de vous familiariser avec les types génériques. L'exactitude de l'index saisi est vérifiée, puis à l'intérieur de la méthode, l'élément n'est pas complètement supprimé, mais une méthode privée est appelée fastRemove(Object[] es, int i)dans laquelle la suppression a déjà lieu. Nous transmettons notre tableau et l'index spécifié à la méthode en entrée. Les éléments sont copiés à l'aide de System.arraycopy(), la taille du tableau est réduite, puis nous attribuons null au dernier élément. Il est à noter qu'un nouveau tableau n'est pas créé : System.arraycopy(es, i + 1, es, i, size - 1 - i); la partie qui se trouve à droite de la position sous l'index spécifié (i+1) est copiée dans notre (nos) tableau(s) d'origine, et elle est localisée à partir de la position même. (i) l'endroit où se trouvait l'élément à supprimer. Ainsi, nous avons effectué un décalage vers la gauche et effacé notre élément. Essayons de supprimer l'élément à l'index 3 du tableau ci-dessous : Considérons la deuxième version de la méthode :

public boolean remove(Object o)

La méthode supprime l'élément passé de la liste o, ou plus précisément, l'objet au niveau du lien spécifié. Si un élément est présent dans la liste, il est supprimé et tous les éléments sont décalés vers la gauche. Si l'élément existe dans la liste et est supprimé avec succès, la méthode renvoie vrai ; sinon, faux. Semblable à l'option avec suppression par index, la méthode est appelée fastRemove(), où exactement les mêmes actions se produisent. La différence est que la méthode remove(Object o)recherche en outre l'objet souhaité via une méthode equals()de la classe Object. Lors de la suppression par valeur, la boucle parcourt tous les éléments de la liste jusqu'à ce qu'une correspondance soit trouvée. Seul le premier élément trouvé sera supprimé. Résumons : lors de la suppression d'éléments d'un tableau dynamique, il ne reste plus de trous comme dans un tableau normal (la cellule supprimée ne sera pas vide). Tous les éléments suivants (qui se trouvaient à droite de l'index) sont décalés d'une position vers la gauche. Il existe plusieurs méthodes supplémentaires qui peuvent être utilisées pour supprimer des éléments de la liste à des degrés divers. Examinons-les brièvement. Nettoyage de notre collection :

public void clear()

Une simple boucle forparcourt tous les éléments d’un tableau, attribuant null à chaque élément. Vous pouvez supprimer de notre collection les éléments contenus dans une autre collection transférée comme ceci :

public boolean removeAll(Collection< ?> c)

Si vous devez supprimer plusieurs éléments, vous ne devriez probablement pas le faire dans une boucle conditionnelle : il est plus pratique et plus sûr d'utiliser la méthode removeAll(). Il accepte une collection d'éléments qui seront supprimés de la liste. La collection doit contenir des éléments du même type que celui stocké par la liste cible. Sinon il sera jeté ClassCastException. La méthode retournera true si la liste a été modifiée à la suite de l'appel de méthode. Supprime les éléments qui n'appartiennent pas à la collection passée :

public boolean retainAll(Collection< ?> c)

Disons que nous avons une collection :

List< String> listFirst = new ArrayList<>();
listFirst.add("White");
listFirst.add("Black");
listFirst.add("Red");

Et le deuxième:

List< String> listSecond = new ArrayList<>();
listSecond.add("Green");
listSecond.add("Red");
listSecond.add("White");

Puis après listSecond.retainAll(listFirst)il listSecondrestera :

"White"
"Red"

Depuis que "Green" a été supprimé, ce qui n'est pas dans listFirst. Mais après listSecond.removeAll(listFirst)cela il listSecondrestera :

"Green"
Удалorсь все элементы, которые есть в listFirst.

N'appartenant pas à la collection passée - signifie que s'il y a des éléments qui ne sont pas dans la collection passée, vous devez les supprimer de la première (à laquelle la méthode est appliquée). Appartenant à la collection transférée - par conséquent, s'il existe un élément dans les première et deuxième collections (transférées), le duplicata de la première est détruit.

protected void removeRange(int fromIndex, int toIndex)

Supprime de la liste tous les éléments situés entre l'index spécifié de début (inclus) et l'index spécifié de fin (non inclus). Il est à noter que la méthode ne peut pas être appelée directement sur un objet ArrayList. Pour l'utiliser, vous devez hériter de AbstractList/ArrayList. La méthode est également utilisée par une autre méthode (sous-Liste, qui sera discutée plus tard).

public boolean removeIf(Predicate< ? super E> filter)

Supprime des éléments d'une collection en fonction d'un prédicat donné. Le prédicat lui-même est une certaine fonction/algorithme/condition sur la base duquel un ou plusieurs éléments correspondant à une condition donnée seront supprimés. Predicate— une interface fonctionnelle (ne contient qu'une seule méthode, elle peut donc être utilisée comme lambda), fonctionne sur le principe « reçu un paramètre - renvoyé un booléen ». Essentiellement, la méthode remplace l'implémentation de l'interface Collectionet implémente la « stratégie » suivante : elle parcourt les éléments et marque ceux qui correspondent à notre Predicate; il est ensuite exécuté une seconde fois pour supprimer (et décaler) les éléments qui ont été marqués lors de la première itération. Implémentons une interface Predicatequi retournera true si deux objets sont égaux :

class SamplePredicate< T> implements Predicate< T>{
  T varc1;
  public boolean test(T varc){
     if(varc1.equals(varc)){
       return true;
  }
  return false;
  }
}

Dans une autre classe, créons une ArrayList à partir Stringd'un objet de notre classe qui implémente Predicate:

ArrayList< String> color_list = new ArrayList<> ();
SamplePredicate< String> filter = new SamplePredicate<> ();

varc1Écrivons la valeur "White" à la variable :

filter.varc1 = "White";

Ajoutons quelques lignes à la liste :

color_list.add("White");
color_list.add("Black");
color_list.add("Red");
color_list.add("White");
color_list.add("Yellow");
color_list.add("White");

Exécutons la méthode sur la liste removeIf, à laquelle nous passerons notre objet avec la condition :

color_list.removeIf(filter);

En conséquence, toutes les lignes avec la valeur « Blanc » seront supprimées de la liste, puisque notre « prédicat » les compare pour leur égalité. Liste finale : [Noir, Rouge, Jaune]. Remplacement d'éléments

public E set(int index, E element)

Remplace l'élément à la position spécifiée indexpar celui passé element. L'index doit également être supérieur à zéro et inférieur à l'index du dernier élément, sinon une exception sera levée IndexOutOfBoundsException. Aucune copie du tableau interne ne se produit. Simplement, au lieu de l'élément à l'index spécifié, un nouvel élément est inséré, c'est-à-dire écraser la valeur.

public void replaceAll(UnaryOperator<e> operator)

Modifie tous les éléments de la collection (possible avec une condition). Principalement utilisé en combinaison avec des lambdas ou une classe anonyme (mais pour plus de clarté, dans l'exemple nous utiliserons simplement une classe qui implémente l'interface) qui implémente l'interface UnaryOperatoret définit ses méthodes. Implémentons l'interface :

class MyOperator< T> implements UnaryOperator< T>{
   T varc1;
   public T apply(T varc){
     return varc1;
  }
}

Dans une autre classe, créons une ArrayList à partir Stringd'un objet de notre classe qui implémente UnaryOperator:

ArrayList< String> color_list = new ArrayList<> ();
MyOperator< String> operator = new MyOperator<> ();

varc1Écrivons la valeur "White" à la variable :

operator.varc1 = "White";

Ajoutons quelques lignes à la liste :

color_list.add("White");
color_list.add("Black");
color_list.add("Red");
color_list.add("White");
color_list.add("Yellow");
color_list.add("White");

Exécutons une méthode sur la liste replaceAllà laquelle nous passerons notre objet operator:

color_list.replaceAll(operator);

En conséquence, toutes les valeurs de la liste ont été remplacées par « Blanc » : [Blanc, Blanc, Blanc, Blanc, Blanc, Blanc]. Et voici comment, par exemple, vous pouvez supprimer tous les espaces des chaînes qui se trouvent dans la collection :

ArrayList< String> list = new ArrayList<>(Arrays.asList("A   ", "  B  ", "C"));
list.replaceAll(String::trim);

Autres méthodes : vous pouvez convertir le tableau de liste ArrayList en un tableau normal à l'aide de la méthode :

public Object[] toArray()

ou

public < T> T[] toArray(T[] a)

- ici le type du tableau retourné est déterminé en runtime Cette méthode permettra :

1. accélérer certaines opérations ;
2. passer un tableau en paramètre à une méthode qui n'est pas surchargée pour accepter directement la collection ;
3. Intégration d'un nouveau code basé sur les collections avec du code existant qui ne reconnaît pas les collections.

Renvoie un objet copie du tableau :

public Object clone()

Veuillez noter que la méthode clone()renvoie le type d'objet, donc après l'avoir appelée, vous devrez effectuer un cast vers la classe requise. Le clonage crée un nouvel objet indépendant. Vérifiez la collection pour la présence d'un objet :

public boolean contains(Object o)

Vérifie la présence d'un objet dans la liste (en interne en utilisant la méthode égale de la classe Object, c'est-à-dire compare les références), renvoie vrai/faux en fonction du résultat. En plus des boucles habituelles, vous pouvez parcourir (accéder à chaque élément et effectuer certaines actions) une collection en utilisant :

public void forEach(Consumer< ? super E> action)

Voici comment nous pouvons afficher notre liste :

List< Integer> numbers = new ArrayList<>(Arrays.asList(10, 20, 50, 100, -5));
numbers.forEach((number)-> System.out.println(number));

Sans utiliser lambdas, vous devez utiliser une classe anonyme et remplacer la méthode acceptd'interfaceConsumer :

numbers.forEach(new Consumer< Integer>() {
  @Override
   public void accept(Integer integer) {
      System.out.println(integer);
          }
});

Récupère un élément par son index :

public E get(int index)

Utilisé pour un accès aléatoire aux éléments de collection. Renvoie l'élément situé dans la liste à l'index spécifié. Si index < 0ou correspond index >=au nombre maximum d'éléments dans la liste, une exception sera levée IndexOutOfBoundsException. Il s'agit de la méthode de base pour récupérer un élément d'une liste, et le temps de récupération d'un élément par index sera toujours le même, quelle que soit la taille de l'ArrayList, puisqu'il accède à une cellule spécifique du tableau. Recherche d'index pour les objets spécifiés :

public int indexOf(Object o);
public int lastIndexOf(Object o);

Les méthodes renvoient l'index du premier élément (lorsque l'objet donné est rencontré pour la première fois) ou de la dernière occurrence (lorsque l'objet donné est rencontré pour la dernière fois) de la liste. Si l'élément n'existe pas dans la liste, les méthodes renverront -1. Vérifiez la collection pour les éléments :

public boolean isEmpty();

La méthode renvoie true si la liste est vide (regarde si le champ est égal size 0), sinon false. Si la liste ne contient que des éléments nuls, la méthode retournera false. Autrement dit, les éléments nuls sont également pris en compte par cette méthode. Découvrez le nombre d'éléments dans une liste :

public int size();

Renvoie le nombre d'éléments dans la liste (valeurs du champ de taille). Le nombre d'éléments peut différer de la capacité de la liste (capacité). Obtenez un itérateur pour une liste :

public Iterator< E> iterator();

Renvoie un itérateur pour une liste pour une utilisation ultérieure dans une boucle ou tout autre traitement. L'itérateur implémente un comportement d'échec rapide. S'il parcourt la collection et y remarque des modifications (qui n'ont pas été obtenues à l'aide des méthodes de l'itérateur), il lève immédiatement une exception ConcurrentModificationException. L'itérateur a quelque chose appelé modification count. Lorsque l'itérateur parcourt la collection après chaque next/hasNext/remove, il vérifie ce compteur. Si cela ne correspond pas à ce que l’itérateur s’attendait à voir, il lève une exception. Je ne considérerai pas les itérateurs en détail ici.

public ListIterator< E> listIterator() и public ListIterator< E> listIterator(int index)

Renvoie un itérateur de liste pour une liste pour une utilisation ultérieure dans une boucle ou tout autre traitement. L'interface ListIteratorétend l'interface Iteratorpour un parcours bidirectionnel de la liste et la modification de ses éléments. Dans la version surchargée, vous pouvez passer l'index à partir duquel le « parcours » commencera. L'index dans ce cas désigne le premier élément à partir duquel la méthode commencera son travail next(), et lorsque la méthode est appelée, previous()le parcours commencera à partir de l'élément sous l'index « index passé - 1 ».

public Spliterator <E> spliterator()

Java 8 introduit un nouveau type d'itérateur de liaison tardive et d'échec rapide appelé itérateur de délimiteur. Les itérateurs séparateurs vous permettent de parcourir une séquence d’éléments, mais ils sont utilisés d’une manière différente. La caractéristique la plus importante de l' interface Spliterator est sa capacité à prendre en charge l'itération parallèle de parties individuelles d'une séquence d'éléments, et donc la programmation parallèle.