Explication détaillée de Collection en Java

Les collections Java sont des boîtes à outils fournies par Java et contiennent des structures de données couramment utilisées : collections, liées liste, file d'attente, pile, tableau, mappage, etc. L'emplacement de la boîte à outils de collection Java est java.util.*

Les collections Java peuvent être principalement divisées en 4 parties : liste de listes, collection d'ensembles, mappage de cartes, classe d'outils (itérateur Iterator, classe d'énumération Enumeration, tableaux et Recueils).

Le framework de collection Java est le suivant :

Comme vous pouvez le voir sur la figure ci-dessus, le framework Java Le framework est principalement Collection et Map.

1. La collection est une interface, qui est une collection hautement abstraite. L'interface comprend des opérations de base et des attributs.

Collection contient deux branches : List et Set :

1). List est une file d'attente ordonnée, et chaque élément a son index , la valeur d'index de le premier élément est 0. Les classes d'implémentation de liste incluent LinkedList, ArrayList, Vector et Stack.

(1) LinkedList implémente l'interface List, permettant aux éléments d'être vides. LinkedList fournit des méthodes supplémentaires d'obtention, de suppression et d'insertion. Ces opérations peuvent permettre à LinkedList d'être utilisée comme pile, file d'attente ou. file d'attente bidirectionnelle.

LinkedList n'est pas thread-safe. Si plusieurs threads accèdent à LinkedList en même temps, vous devez implémenter la synchronisation des accès vous-même, ou une autre solution consiste à construire une liste synchronisée lors de la création de la liste.

(2) ArrayList implémente un tableau de taille variable, permettant à tous les éléments d'inclure null En même temps, ArrayList n'est pas thread-safe.

(3) Vector est similaire à ArrayList, mais Vector est thread-safe.

(4) Stack hérite de Vector et implémente une pile dernier entré, premier sorti.

Comparaison de Vector, ArrayLis et LinkedList :

(1) Vector est thread-safe, ArrayList et LinkedList ne sont pas thread-safe, mais les facteurs de sécurité des threads ne sont généralement pas pris en compte, et ArrayList et LinkedList est plus efficace.

(2) ArrayList et Vector implémentent des structures de données basées sur des tableaux dynamiques, tandis que LinkedList est une structure de données basée sur des listes chaînées.

(3) Performance de requête, suppression, etc. de tableaux et de listes chaînées.

2). Set est un ensemble qui n'autorise pas les éléments en double. Les classes d’implémentation de set incluent Hashset et Treeset. HashSet dépend de HashMap et est en fait implémenté via HashMap ; TreeSet dépend de TreeMap et est implémenté via TreeMap.

2. Map est une interface de cartographie, utilisant des paires clé-valeur key-value.

AbstractMap est une classe abstraite, qui implémente la plupart des API dans l'interface Map, HashMap, TreeMap et WeakHashMap héritent tous de AbstractMap, bien que HashTable hérite du dictionnaire. implémente l'interface Map.

1), HashTable

(1) HashTable hérite de l'interface Map et implémente une table de hachage de mappage clé-valeur, tout non vide Les objets peuvent être utilisés comme clé ou valeur.

(2) Le temps nécessaire à l'ajout de données et à la suppression de données est constant.

(3) Puisque l'objet en tant que clé détermine la position de la valeur correspondante en calculant sa fonction de hachage , tout objet en tant que clé doit implémenter la méthode hashCode et égal à. Les méthodes hashCode et equals sont héritées de la classe racine Object.

(4) HashTable est thread-safe.

2), HashMap

(1) HashMap est similaire à HashTable, mais HashMap n'est pas thread-safe et permet à la fois la clé et la valeur d'être vide.

(2) Lorsque vous traitez HashMap comme une collection, son coût en temps d'opération d'itération est proportionnel à la capacité de HashMap. Si l'opération de performance d'itération est très importante, ne définissez pas la capacité d'initialisation de HashMap trop élevée.

3), TreeMap

(1) HashMap utilise Hashcode pour rechercher rapidement son contenu, non ordonné, tandis que tous les éléments de TreeMap restent dans un certain ordre fixe , ordonné.

(2) TreeMap n'a aucune option de réglage car l'arbre est toujours dans un état équilibré.

4), WeakHashMap

(1) WeakHashMap est un HashMap amélioré, qui implémente une "référence faible" à la clé si une clé n'est plus. Si elle est référencée en externe, la clé peut être recyclée par GC.

Résumé

(1) Si des opérations impliquant des piles, des files d'attente, etc. sont impliquées, vous devriez envisager d'utiliser List pour celles qui en ont besoin ; pour insérer et supprimer rapidement des éléments, vous devez utiliser LinkedList ; si vous avez besoin d'un accès aléatoire rapide aux éléments, vous devez utiliser ArrayList.

(2) Si le programme est dans un environnement monothread, ou si l'accès n'est effectué que dans un seul thread, envisagez une classe non synchronisée, qui est plus efficace si plusieurs threads peuvent exploiter une classe en même temps ; en même temps, la synchronisation doit être utilisée en classe.

(3) Portez une attention particulière au fonctionnement de la table de hachage. Les méthodes equals et hashCode de l'objet clé doivent être correctement copiées.

(4) Lorsque vous utilisez Map, il est préférable d'utiliser HashMap ou HashTable pour rechercher, mettre à jour, supprimer et ajouter ; lorsque vous parcourez Map dans l'ordre naturel ou dans l'ordre des clés personnalisé, il est préférable d'utiliser TreeMap

Code source de l'interface de collection

public interface Collection<E> extends Iterable<E> {
    int size(); //大小
    boolean isEmpty();//是否为空
    boolean contains(Object o); //是否包含某个对象
    Iterator<E> iterator(); //迭代
    Object[] toArray(); //转化为数组
    <T> T[] toArray(T[] a);
    boolean add(E e); //增加对象
    boolean remove(Object o); //删除对象
    boolean containsAll(Collection<?> c); //判断是否包含相同的Collection
    boolean addAll(Collection<? extends E> c); //将Collection追加到
    boolean removeAll(Collection<?> c); //删除所有相同对象
    default boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        final Iterator<E> each = iterator();
        while (each.hasNext()) {
            if (filter.test(each.next())) {
                each.remove();
                removed = true;
            }
        }
        return removed;
    }
    boolean retainAll(Collection<?> c);
    void clear();
    boolean equals(Object o);
    int hashCode();
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!