Qu'est-ce qu'une collection?

** Ensemble d'objets **
package java.utul: fournit des classes / interfaces génériques (** framework de collection **) pour travailler avec des structures de collection
Je veux l'utiliser en premier lorsque je traite un ensemble d'objets

Interface de collecte

Bases du framework de collection
Classe d'implémentation pour chaque sous-interface
** Liste **: Commandé, les éléments peuvent être dupliqués
ArrayList: tableau de longueur variable
LinkedList: Liste des structures liées
** Set **: les éléments ne peuvent pas être dupliqués
HashSet: ensemble d'éléments stockés dans un ordre arbitraire
LinkedHashSet: ensemble d'éléments stockés dans l'ordre d'ajout
TreeSet: ensemble d'éléments triés par clé
** File d'attente **: Ajouter / supprimer les premiers / derniers éléments. Utiliser pour la file d'attente / pile
ArrayDeque: les deux extrémités de la file d'attente
LinkedList: identique à LinkedList
** Carte **: Gérer par clé / valeur, pas de clés en double
HashMap: Carte de base
TreeMap: carte triée par clé

Instanciation de collection

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

Type d'interface

Vous pouvez minimiser la dépendance à la classe en utilisant le type d'interface au lieu du type de variable (type d'implémentation).
NG Exemple: il n'est pas bon de passer le type de nombre réel comme argument car il est
ʻArrayList data = new ArrayList <> (); <br> public void run (ArrayList data) {…} ''
→ ** Si vous définissez List <String> comme type d'interface depuis le début, vous pouvez facilement passer à LinkedList! ** **
List<String> data = new LinkedList<>();

Syntaxe générique

** Mécanisme pour lier des classes / méthodes génériques à des types spécifiques **
Dans le cas de List <String>, une String est affectée au type polyvalent (List), et elle devient une ** List ** dédiée au stockage des chaînes de caractères!
Inversement, dans une collection non générique, tous les éléments sont considérés comme des types d'objets (tous les types peuvent être affectés), un cast de type explicite est requis et les valeurs de type non voulues ne peuvent pas être détectées. ..
Strng str = (String) data.get (0)
→ ** Utilisez une syntaxe générique de type sécurisé! ** **
Facultatif lorsque le type d'élément sur le côté gauche est évident (** Opérateur diamant **)
List <String> data = new ArrayList <> ();

idiome

Initialiser la collection au moment de l'instanciation

import java.util.ArrayList;
public class Main {
  public static void main(String[] args) {
    //Classe anonyme
    var data = new ArrayList<String>() {
      //Bloc d'initialisation
      {
        add("neko");
        add("inu");
        add("tori");
      }
    };
    System.out.println(data);//[neko, inu, tori]
  }
}

Traiter en cours de collecte dans l'ordre avec extension pour

En interne, le sucre de syntaxe de l'instruction while utilisant ** Iterator ** (syntaxe simplifiée)
Méthodes d'interface d'itérateur
** hasNext **: Confirmation de l'existence des éléments suivants
** suivant **: déplacer et passer à l'élément suivant
** remove **: Supprimer l'élément actuel

import java.util.ArrayList;

public class Main {
  public static void main(String[] args) {
    var data = new ArrayList<String>() {
      {
        add("neko");
        add("inu");
        add("kuma");
      }
    };
    //Processus en cours de collecte dans l'ordre
    for (var s : data) {
      System.out.println(s); //neko inu kuma
    }
    //Lors de l'utilisation d'un itérateur
    //     var itr = data.iterator();
    //     while (itr.hasNext()) {
    //      System.out.println(itr.next());
    //     }
  }
}

Supprimer des éléments dans une boucle

Notez que l'extension pour entraînera ConcurrentModificationException

import java.util.ArrayList;

public class Main {
  public static void main(String[] args) {
    var data = new ArrayList<String>() {
      {
        add("neko");
        add("inu");
        add("niwatori");
      }
    };

    var ite = data.iterator();
    while (ite.hasNext()) {
      System.out.println(ite.next()); //neko inu niwatori
      ite.remove();
    }
    System.out.println(data); //[]
  }
}

//Exemple NG:Extension pour
    for (var s : data) {
      System.out.println(s);
      data.remove(s);
    }

Lisez la liste dans l'ordre inverse

Obtenir l'objet ListIterator avec la méthode listIterator
** méthode précédente **: passer à l'élément précédent
** Méthode hasPrevious **: Confirmer l'existence de l'élément précédent
Spécifiez la position de début de lecture dans l'argument listIterator

import java.util.ArrayList;

public class Main {
  public static void main(String[] args) {
    var data = new ArrayList<String>() {
      {
        add("neko");
        add("inu");
        add("shimaenaga");
      }
    };
    //Réglez la fin sur la position de départ
    var ite = data.listIterator(data.size());
    while (ite.hasPrevious()) {
      System.out.println(ite.previous()); //shimaenaga inu neko
    }
  }
}

Conversion de tableaux et de collections

Fondamentalement, l'ensemble d'objets est ** une collection plutôt qu'un tableau ** (affinité avec la syntaxe orientée objet)

Du tableau à la liste

** Méthode asList **
La liste convertie est juste un tableau qui couvre la liste!
Les modifications apportées à la liste affectent la matrice d'origine et ne peuvent pas être ajoutées ou supprimées de la liste
→ ** Dupliquer avec la méthode Collections.addAll **

//Exemple NG: convertir une chaîne de caractères existante en liste, ajouter une valeur à la liste convertie et supprimer
import java.util.Arrays;

public class Main {
  public static void main(String[] args) {
    var data = new String[] { "cat", "dog", "bird"};
    var list = Arrays.asList(data);
    list.set(0, "neko");
    System.out.println(list); //[neko, dog, bird]
    System.out.println(Arrays.toString(data)); //[neko, dog, bird]
    //list.add("inu"); //UnsupportedOperationException
    //list.remove(0);  //UnsupportedOperationException
  }
}

//OK Exemple: convertir une chaîne de caractères existante en liste, ajouter et supprimer des valeurs dans la liste convertie
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Main {
  public static void main(String[] args) {
    var data = new String[] { "cat", "dog", "bird" };
    var list = new ArrayList<String>();
    Collections.addAll(list, data);
    list.set(0, "neko");
    list.add("inu");
    System.out.println(list); //[neko, dog, bird, inu]
    list.remove(1);

    System.out.println(list); //[neko, bird, inu]
    System.out.println(Arrays.toString(data)); //[cat, dog, bird]
  }
}

De la collection au tableau

** Méthode toArray **
Définissez tous les éléments s'ils tiennent dans le tableau d'arguments
S'il ne rentre pas, générez le même tableau que l'argument puis définissez tous les éléments
Si l'élément de collection ne peut pas être converti en un type d'élément de tableau ʻArrayStoreException`
Puisque les éléments sont copiés en dernier, les opérations sur la liste des sources de conversion n'affectent pas le tableau.

import java.util.ArrayList;
import java.util.Arrays;

public class Main {
  public static void main(String[] args) {
    var data = new ArrayList<String>(Arrays.asList("cat", "dog", "bird"));
    //Copiez le contenu dans un tableau de chaînes de la même taille que la liste
    var strs = new String[data.size()];
    data.toArray(strs);
    //Ajouter des données uniquement à la liste des sources de conversion
    data.set(0, "neko");
    System.out.println(Arrays.toString(strs)); //[cat, dog, bird]
    //Seule la liste des sources de conversion a changé
    System.out.println(data); //[neko, dog, bird]
  }
}

Convertir en une collection immuable

** méthode non modifiable **
En essayant de changer ʻUnsupportedOperationException`
Si l'élément est un type de référence, il peut ne pas être possible de restreindre les modifications de contenu (comme StringBuilder).
La méthode Of peut également générer directement une collection immuable (Java 9 ou version ultérieure)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Main {
  public static void main(String[] args) {
    var data = new ArrayList<String>(Arrays.asList("cat", "dog", "bird"));
    //Générer une liste immuable
    var udata = Collections.unmodifiableList(data);
    udata.set(0, "neko"); //UnsupportedOperationException
    udata.add("inu");  //UnsupportedOperationException
  }
}

//Le contenu des éléments de collection peut être modifié dans StringBuilder
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Main {
  public static void main(String[] args) {
    var data = new ArrayList<StringBuilder>(Arrays.asList(
        new StringBuilder("Bonjour"),
        new StringBuilder("Kame-san"),
        new StringBuilder("Yo")));
    var udata = Collections.unmodifiableList(data);
    udata.get(0).append("Kameyo");
    System.out.println(udata); //[Bonjour,Kame-san,Yo]
  }
}

//Collection immuable directement générée par la méthode of
import java.util.List;
public class Main {
  public static void main(String[] args) {
    var data = List.of("cat", "dog", "bird");
    System.out.println(data);
    data.set(0, "neko"); //UnsupportedOperationException
  }
}

Génération de collection vide

Si la valeur de retour est une méthode vide, ** renvoie la collection au lieu de null **
** Méthode emptyList / emptySet / emptyMap **
return Collections.emptyList();

Génération de collection synchronisée

** Collection synchronisée **: Méthode de support multi-thread (= traitement exclusif)
** méthode synchronizedCollection / synchronizedList / synchronizedSet / synchronizedMap **
Peut être utilisé en toute sécurité dans un environnement multi-thread (= ** thread safe **)
var data = Collections.synchronizedList(new ArrayList<String>());
Meilleure génération de collecte parallèle
- CopyOnWriteArrayList / CopyOnWriteArraySet / ConcurrentHashMap
var map = new ConcurrentHashMap<String,String>();

[Java] Cadre de collection

Qu'est-ce qu'une collection?

Interface de collecte

Instanciation de collection

** Type d'interface **

** Syntaxe générique **

idiome

Initialiser la collection au moment de l'instanciation

Traiter en cours de collecte dans l'ordre avec extension pour

Supprimer des éléments dans une boucle

Lisez la liste dans l'ordre inverse

Conversion de tableaux et de collections

Du tableau à la liste

De la collection au tableau

Convertir en une collection immuable

Génération de collection vide

Génération de collection synchronisée

Type d'interface

Syntaxe générique