Java Language
Collections

Introduction

Remarques

Déclaration d'un ArrayList et ajout d'objets

Nous pouvons créer une ArrayList (en suivant l'interface List ):

List aListOfFruits = new ArrayList();

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

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

Maintenant, utilisez la méthode add pour ajouter une String :

aListOfFruits.add("Melon");
aListOfFruits.add("Strawberry");

Dans l'exemple ci-dessus, ArrayList contiendra la String "Melon" à l'index 0 et la String "Strawberry" à l'index 1.

On peut aussi ajouter plusieurs éléments avec addAll(Collection<? extends E> c)

List<String> aListOfFruitsAndVeggies = new ArrayList<String>();
aListOfFruitsAndVeggies.add("Onion");
aListOfFruitsAndVeggies.addAll(aListOfFruits);

Maintenant, "Onion" est placé à 0 index dans aListOfFruitsAndVeggies , "Melon" est à index 1 et "Strawberry" à index 2.

Construire des collections à partir de données existantes

Collections standard

Framework Java Collections

Un moyen simple de construire une List partir de valeurs de données individuelles consiste à utiliser la méthode java.utils.Arrays Arrays.asList :

List<String> data = Arrays.asList("ab", "bc", "cd", "ab", "bc", "cd");

Toutes les implémentations de collection standard fournissent des constructeurs qui prennent une autre collection comme argument en ajoutant tous les éléments à la nouvelle collection au moment de la construction:

List<String> list = new ArrayList<>(data); // will add data as is
Set<String> set1 = new HashSet<>(data); // will add data keeping only unique values
SortedSet<String> set2 = new TreeSet<>(data); // will add data keeping unique values and sorting
Set<String> set3 = new LinkedHashSet<>(data); // will add data keeping only unique values and preserving the original order

Cadre des collections Google Goyave

Un autre excellent Google Guava est Google Guava , une classe d'utilitaires étonnante (fournissant des méthodes statiques pratiques) pour la construction de différents types de collections standard: Lists et Sets :

 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 ...
 List<String> list1 = Lists.newArrayList("ab", "bc", "cd");
 List<String> list2 = Lists.newArrayList(data);
 Set<String> set4 = Sets.newHashSet(data);
 SortedSet<String> set5 = Sets.newTreeSet("bc", "cd", "ab", "bc", "cd");

Collections de cartographie

Framework Java Collections

De même pour les cartes, si une Map<String, Object> map une nouvelle carte peut être construite avec tous les éléments comme suit:

Map<String, Object> map1 = new HashMap<>(map);
SortedMap<String, Object> map2 = new TreeMap<>(map);

Cadre Apache Commons Collections

En utilisant Apache Commons vous pouvez créer Map en utilisant array dans ArrayUtils.toMap ainsi que MapUtils.toMap :

 import org.apache.commons.lang3.ArrayUtils;
 ...
 // Taken from org.apache.commons.lang.ArrayUtils#toMap JavaDoc

 // Create a Map mapping colors.
 Map colorMap = MapUtils.toMap(new String[][] {{
     {"RED", "#FF0000"},
     {"GREEN", "#00FF00"},
     {"BLUE", "#0000FF"}});

Chaque élément du tableau doit être un Map.Entry ou un Array, contenant au moins deux éléments, le premier élément étant utilisé comme clé et le second comme valeur.

Cadre des collections Google Goyave

La classe d'utilitaires du framework Google Guava est nommée Maps :

 import com.google.common.collect.Maps;
 ...
 void howToCreateMapsMethod(Function<? super K,V> valueFunction,
           Iterable<K> keys1, 
           Set<K> keys2, 
           SortedSet<K> keys3) {
     ImmutableMap<K, V> map1 = toMap(keys1, valueFunction); // Immutable copy
     Map<K, V> map2 = asMap(keys2, valueFunction); // Live Map view
     SortedMap<K, V> map3 = toMap(keys3, valueFunction); // Live Map view
 }

Stream.of("xyz", "abc").collect(Collectors.toList());

Arrays.stream("xyz", "abc").collect(Collectors.toList());

Joindre des listes

Les méthodes suivantes peuvent être utilisées pour joindre des listes sans modifier les listes de sources.

Première approche. A plus de lignes mais facile à comprendre

List<String> newList = new ArrayList<String>();
newList.addAll(listOne);
newList.addAll(listTwo);

Deuxième approche A une ligne de moins mais moins lisible.

List<String> newList = new ArrayList<String>(listOne);
newList.addAll(listTwo);

Troisième approche Nécessite une bibliothèque tierce de collections de documents Apache .

ListUtils.union(listOne,listTwo);

List<String> newList = Stream.concat(listOne.stream(), listTwo.stream()).collect(Collectors.toList());

Les références. Liste d'interfaces

Supprimer des éléments d'une liste dans une boucle

Il est difficile de supprimer des éléments d'une liste dans une boucle, ceci étant dû au fait que l'index et la longueur de la liste sont modifiés.

Compte tenu de la liste suivante, voici quelques exemples qui donneront un résultat inattendu et d'autres qui donneront le résultat correct.

List<String> fruits = new ArrayList<String>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Strawberry");

INCORRECT

Suppression en itération de for la déclaration Ignore « Banana »:

L'échantillon de code n'imprimera que Apple et Strawberry . Banana est ignorée , car il se déplace à l' index 0 une fois d' Apple est supprimé, mais en même temps i s'incrémenté à 1 .

for (int i = 0; i < fruits.size(); i++) {
    System.out.println (fruits.get(i)); 
    if ("Apple".equals(fruits.get(i))) {
         fruits.remove(i);
    }     
}

Retrait dans l'instruction améliorée for Throws Exception:

En raison de l'itération sur la collecte et la modification en même temps.

Jette: java.util.ConcurrentModificationException

for (String fruit : fruits) { 
    System.out.println(fruit);
    if ("Apple".equals(fruit)) {
        fruits.remove(fruit);
    }
}

CORRECT

Retrait en boucle en utilisant un Iterator

Iterator<String> fruitIterator = fruits.iterator();
while(fruitIterator.hasNext()) {     
    String fruit = fruitIterator.next();     
    System.out.println(fruit);
    if ("Apple".equals(fruit)) {
        fruitIterator.remove();
    } 
}

L'interface Iterator a une méthode remove() intégrée uniquement pour ce cas. Cependant, cette méthode est marquée comme "facultative" dans la documentation et peut générer une UnsupportedOperationException .

Lève: une exception UnsupportedOperationException - si l'opération de suppression n'est pas prise en charge par cet itérateur

Par conséquent, il est conseillé de vérifier la documentation pour vous assurer que cette opération est prise en charge (en pratique, à moins que la collection ne soit immuable via une bibliothèque tierce ou l’utilisation de la méthode Collections.unmodifiable...() . l'opération est presque toujours supportée).

Lors de l'utilisation d'un Iterator une Iterator ConcurrentModificationException est modCount lorsque le modCount de la List est modifié depuis la création de l' Iterator . Cela aurait pu se produire dans le même thread ou dans une application multi-thread partageant la même liste.

Un modCount est une variable int qui compte le nombre de fois où cette liste a été structurellement modifiée. Une modification structurelle signifie essentiellement une opération add() ou remove() appelée sur l'objet Collection (les modifications apportées par Iterator ne sont pas comptabilisées). Lorsque l' Iterator est créé, il stocke ce modCount et à chaque itération de la List , si le modCount actuel est identique à celui où l' Iterator été créé. S'il y a un changement dans la modCount valeur qu'il jette un ConcurrentModificationException .

Par conséquent, pour la liste ci-dessus, une opération comme ci-dessous ne lancera aucune exception:

Iterator<String> fruitIterator = fruits.iterator();
fruits.set(0, "Watermelon");
while(fruitIterator.hasNext()){
    System.out.println(fruitIterator.next());
}

Mais ajouter un nouvel élément à la List après l'initialisation d'un Iterator une Iterator ConcurrentModificationException :

Iterator<String> fruitIterator = fruits.iterator();
fruits.add("Watermelon");
while(fruitIterator.hasNext()){
    System.out.println(fruitIterator.next());    //ConcurrentModificationException here
}

Itérer en arrière

for (int i = (fruits.size() - 1); i >=0; i--) {
    System.out.println (fruits.get(i));
    if ("Apple".equals(fruits.get(i))) {
         fruits.remove(i);
    }
}

Cela ne saute rien L'inconvénient de cette approche est que la sortie est inverse. Cependant, dans la plupart des cas, vous supprimez les éléments qui ne comptent pas. Vous ne devriez jamais faire cela avec LinkedList .

Itérer en avant, ajuster l'indice de boucle

for (int i = 0; i < fruits.size(); i++) {
    System.out.println (fruits.get(i)); 
    if ("Apple".equals(fruits.get(i))) {
         fruits.remove(i);
         i--;
    }     
}

Cela ne saute rien. Lorsque le i ième élément est retiré de la List , l'élément placé à l' origine à l' indice i+1 devient le nouveau i ème élément. Par conséquent, la boucle peut décrémenter i pour que la prochaine itération traite l'élément suivant sans sauter.

Utiliser une liste "à supprimer"

ArrayList shouldBeRemoved = new ArrayList();
for (String str : currentArrayList) {
    if (condition) {
        shouldBeRemoved.add(str);
    }
}
currentArrayList.removeAll(shouldBeRemoved);

Cette solution permet au développeur de vérifier si les éléments corrects sont supprimés de manière plus propre.

List<String> filteredList = 
    fruits.stream().filter(p -> !"Apple".equals(p)).collect(Collectors.toList());

fruits.removeIf(p -> "Apple".equals(p));

Collection non modifiable

Parfois, il n’est pas une bonne pratique d’exposer une collection interne car cela peut conduire à une vulnérabilité de code malveillant en raison de sa caractéristique mutable. Afin de fournir des collections "en lecture seule", java fournit ses versions non modifiables.

Une collection non modifiable est souvent une copie d'une collection modifiable qui garantit que la collection elle-même ne peut pas être modifiée. Les tentatives de modification entraîneront une exception UnsupportedOperationException.

Il est important de noter que les objets présents dans la collection peuvent toujours être modifiés.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class MyPojoClass {
    private List<Integer> intList = new ArrayList<>();

    public void addValueToIntList(Integer value){
        intList.add(value);
    }
    
    public List<Integer> getIntList() {
        return Collections.unmodifiableList(intList);
    }
}

La tentative suivante de modifier une collection non modifiable lancera une exception:

import java.util.List;

public class App {

    public static void main(String[] args) {
        MyPojoClass pojo = new MyPojoClass();
        pojo.addValueToIntList(42);
        
        List<Integer> list = pojo.getIntList();
        list.add(69);
    }
}

sortie:

Exception in thread "main" java.lang.UnsupportedOperationException
    at java.util.Collections$UnmodifiableCollection.add(Collections.java:1055)
    at App.main(App.java:12)

Itération sur les collections

Itérer sur la liste

List<String> names  = new ArrayList<>(Arrays.asList("Clementine", "Duran", "Mike"));

names.forEach(System.out::println);

names.parallelStream().forEach(System.out::println);

for (String name : names) {
    System.out.println(name);
}

for (int i = 0; i < names.size(); i++) {
    System.out.println(names.get(i));
}

//Creates ListIterator which supports both forward as well as backward traversel
ListIterator<String> listIterator = names.listIterator();

//Iterates list in forward direction
while(listIterator.hasNext()){
    System.out.println(listIterator.next());
}

//Iterates list in backward direction once reaches the last element from above iterator in forward direction
while(listIterator.hasPrevious()){
    System.out.println(listIterator.previous());
}

Itération sur Set

Set<String> names = new HashSet<>(Arrays.asList("Clementine", "Duran", "Mike"));

names.forEach(System.out::println);

for (Iterator<String> iterator = names.iterator(); iterator.hasNext(); ) {
    System.out.println(iterator.next());
}

for (String name : names) {
    System.out.println(name);
}

Iterator iterator = names.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

Itérer sur la carte

Map<Integer, String> names = new HashMap<>();
names.put(1, "Clementine");
names.put(2, "Duran");
names.put(3, "Mike");

names.forEach((key, value) -> System.out.println("Key: " + key + " Value: " + value));

for (Map.Entry<Integer, String> entry : names.entrySet()) {
    System.out.println(entry.getKey());
    System.out.println(entry.getValue());
}
    
// Iterating over only keys
for (Integer key : names.keySet()) {
    System.out.println(key);
}
// Iterating over only values
for (String value : names.values()) {
    System.out.println(value);
}

Iterator entries = names.entrySet().iterator();
while (entries.hasNext()) {
    Map.Entry entry = (Map.Entry) entries.next();
    System.out.println(entry.getKey());
    System.out.println(entry.getValue());
}

Collections vides immuables

Parfois, il est approprié d'utiliser une collection vide immuable. La classe Collections fournit des méthodes pour obtenir de telles collections de manière efficace:

List<String> anEmptyList = Collections.emptyList();
Map<Integer, Date> anEmptyMap = Collections.emptyMap();
Set<Number> anEmptySet = Collections.emptySet();

Ces méthodes sont génériques et convertissent automatiquement la collection renvoyée au type auquel elle est affectée. C'est-à-dire qu'une invocation de par exemple emptyList() peut être affectée à n'importe quel type de List , de même que emptySet() et emptyMap() .

Les collections renvoyées par ces méthodes sont immuables dans la mesure où elles lancent une UnsupportedOperationException si vous tentez d'appeler des méthodes qui modifieraient leur contenu ( add , put , etc.). Ces collections sont principalement utiles en tant que substituts de résultats de méthode vides ou d'autres valeurs par défaut, au lieu d'utiliser null ou de créer des objets avec new .

Collections et valeurs primitives

Les collections en Java ne fonctionnent que pour les objets. Ie il n'y a pas de Map<int, int> en Java. Au lieu de cela, les valeurs primitives doivent être placées dans des objets, comme dans Map<Integer, Integer> . L’auto-boxing Java permettra une utilisation transparente de ces collections:

Map<Integer, Integer> map = new HashMap<>();
map.put(1, 17); // Automatic boxing of int to Integer objects
int a = map.get(1); // Automatic unboxing.

Malheureusement, les frais généraux sont considérables . Un HashMap<Integer, Integer> nécessitera environ 72 octets par entrée (par exemple, sur une JVM 64 bits avec des pointeurs compressés et en supposant des entiers supérieurs à 256 et en supposant une charge de 50% de la map). Étant donné que les données réelles ne sont que de 8 octets, cela génère une surcharge considérable. De plus, il nécessite deux niveaux d’indirection (Map -> Entry -> Value) qui sont inutilement lents.

Il existe plusieurs bibliothèques avec des collections optimisées pour les types de données primitifs (qui nécessitent seulement ~ 16 octets par entrée à une charge de 50%, soit quatre fois moins de mémoire et un niveau d’indirection inférieur), valeurs en Java.

Suppression des éléments correspondants des listes à l'aide de l'itérateur.

Au-dessus, j'ai remarqué un exemple pour supprimer des éléments d'une liste dans une boucle et j'ai pensé à un autre exemple qui pourrait s'avérer utile cette fois-ci en utilisant l'interface Iterator .
Ceci est une démonstration d'une astuce qui peut s'avérer utile pour traiter les éléments en double dans les listes dont vous souhaitez vous débarrasser.

Remarque: Ceci ne fait qu'ajouter aux éléments Suppression d'une liste dans un exemple de boucle :

Définissons donc nos listes comme d'habitude

    String[] names = {"James","Smith","Sonny","Huckle","Berry","Finn","Allan"};
    List<String> nameList = new ArrayList<>();

    //Create a List from an Array
    nameList.addAll(Arrays.asList(names));
    
    String[] removeNames = {"Sonny","Huckle","Berry"};
    List<String> removeNameList = new ArrayList<>();

    //Create a List from an Array
    removeNameList.addAll(Arrays.asList(removeNames));

La méthode suivante utilise deux objets Collection et effectue la magie de la suppression des éléments de notre removeNameList qui correspondent aux éléments de nameList .

private static void removeNames(Collection<String> collection1, Collection<String> collection2) {
      //get Iterator.
    Iterator<String> iterator = collection1.iterator();
    
    //Loop while collection has items
    while(iterator.hasNext()){
        if (collection2.contains(iterator.next()))
            iterator.remove(); //remove the current Name or Item
    }
}

Appel de la méthode et passage de la liste de nameList et de la removeNameList comme suit removeNames(nameList,removeNameList);
Produira la sortie suivante:

Liste des tableaux avant de supprimer les noms: James Smith Sonny Huckle Berry Finn Allan
Liste de matrices après suppression des noms: James Smith Finn Allan

Une utilisation simple et ordonnée pour les collections qui peuvent être utiles pour supprimer des éléments répétés dans les listes.

Créer votre propre structure Iterable à utiliser avec Iterator ou pour chaque boucle.

Pour que notre collection puisse être itérée en utilisant un itérateur ou pour chaque boucle, nous devons prendre en charge les étapes suivantes:

1. Les éléments sur lesquels nous voulons effectuer une itération doivent être Iterable et exposer l' iterator() .
2. Concevez un java.util.Iterator en hasNext() , next() et remove() .

J'ai ajouté une implémentation de liste chaînée générique simple ci-dessous qui utilise les entités ci-dessus pour rendre la liste chaînée itérable.

package org.algorithms.linkedlist;
 
import java.util.Iterator;
import java.util.NoSuchElementException;
 
 
public class LinkedList<T> implements Iterable<T> {
 
    Node<T> head, current;
 
    private static class Node<T> {
        T data;
        Node<T> next;
 
        Node(T data) {
            this.data = data;
        }
    }
 
    public LinkedList(T data) {
        head = new Node<>(data);
    }
 
    public Iterator<T> iterator() {
        return new LinkedListIterator();
    }
 
    private class LinkedListIterator implements Iterator<T> {
 
        Node<T> node = head;
 
        @Override
        public boolean hasNext() {
            return node != null;
        }
 
        @Override
        public T next() {
            if (!hasNext())
                throw new NoSuchElementException();
            Node<T> prevNode = node;
            node = node.next;
            return prevNode.data;
        }
 
        @Override
        public void remove() {
            throw new UnsupportedOperationException("Removal logic not implemented.");
        }
    }
 
    public void add(T data) {
        Node current = head;
        while (current.next != null)
            current = current.next;
        current.next = new Node<>(data);
    }
 
}
 
class App {
    public static void main(String[] args) {
 
        LinkedList<Integer> list = new LinkedList<>(1);
        list.add(2);
        list.add(4);
        list.add(3);
 
        //Test #1
        System.out.println("using Iterator:");
        Iterator<Integer> itr = list.iterator();
        while (itr.hasNext()) {
            Integer i = itr.next();
            System.out.print(i + " ");
        }
 
        //Test #2
        System.out.println("\n\nusing for-each:");
        for (Integer data : list) {
            System.out.print(data + " ");
        }
    }
}

Sortie

using Iterator:
1 2 4 3
using for-each:
1 2 4 3 

Cela fonctionnera dans Java 7+. Vous pouvez le faire fonctionner sur Java 5 et Java 6 également en remplaçant:

LinkedList<Integer> list = new LinkedList<>(1);

avec

LinkedList<Integer> list = new LinkedList<Integer>(1);

ou juste toute autre version en incorporant les modifications compatibles.

Piège: exceptions de modification concurrentes

Cette exception se produit lorsqu'une collection est modifiée lors d'une itération utilisant des méthodes autres que celles fournies par l'objet itérateur. Par exemple, nous avons une liste de chapeaux et nous voulons supprimer tous ceux qui ont des oreillettes:

List<IHat> hats = new ArrayList<>();
hats.add(new Ushanka()); // that one has ear flaps
hats.add(new Fedora());
hats.add(new Sombrero());
for (IHat hat : hats) {
    if (hat.hasEarFlaps()) {
        hats.remove(hat);
    }
}

Si nous exécutons ce code, ConcurrentModificationException sera levée car le code modifie la collection tout en l'itérant. La même exception peut se produire si l'un des threads multiples travaillant avec la même liste tente de modifier la collection alors que d'autres la parcourent. La modification simultanée de collections dans plusieurs threads est une chose naturelle, mais devrait être traitée avec les outils habituels de la boîte à outils de programmation simultanée tels que les verrous de synchronisation, les collections spéciales adoptées pour la modification simultanée, la modification de la collection clonée, etc.

Sous collections

List subList (int fromIndex, int toIndex)

Ici, d'index est inclusif et toIndex est exclusif.

List list = new ArrayList(); 
List list1 = list.subList(fromIndex,toIndex); 

1. Si la liste n'existe pas dans la plage de valeurs, elle génère une exception IndexOutofBoundException.
2. Les modifications apportées à la liste1 auront un impact sur les mêmes modifications de la liste. Ce sont les collections sauvegardées.
3. Si le fromnIndex est supérieur à toIndex (fromIndex> toIndex), il génère une exception IllegalArgumentException.

Exemple:

List<String> list = new ArrayList<String>();
List<String> list = new ArrayList<String>();
list.add("Hello1"); 
list.add("Hello2"); 
System.out.println("Before Sublist "+list); 
List<String> list2 = list.subList(0, 1);
list2.add("Hello3"); 
System.out.println("After sublist changes "+list); 

Sortie:
Avant la sous-liste [Hello1, Hello2]
Après les changements de sous-liste [Hello1, Hello3, Hello2]

Définir le sous-ensemble (fromIndex, toIndex)

Ici, d'index est inclusif et toIndex est exclusif.

Set set = new TreeSet(); 
Set set1 = set.subSet(fromIndex,toIndex);

L'ensemble renvoyé lancera une exception IllegalArgumentException lors d'une tentative d'insertion d'un élément en dehors de sa plage.

Map subMap (fromKey, toKey)

fromKey est inclusif et toKey est exclusif

Map map = new TreeMap();
Map map1 = map.get(fromKey,toKey);

Si fromKey est supérieur à toKey ou si cette carte elle-même a une plage restreinte, et fromKey ou toKey se situe en dehors des limites de la plage, elle lève une exception IllegalArgumentException.

Toutes les collections prenant en charge les collections sauvegardées signifient que les modifications apportées à la sous-collection auront les mêmes modifications sur la collection principale.