Qu'est-ce que Java Collection Framework ?

Le framework Ans Java Collection est une puissante bibliothèque intégrée qui fournit un ensemble d'implémentations optimisées des structures de données et des algorithmes les plus couramment utilisés. Il est largement utilisé dans la création d'applications Java et la résolution de développement de logiciels du monde réel. défis.

Quels avantages du framework de collection Java ?

Ans Certains des avantages du framework Java Collection sont

1. Architecture unifiée : chaque structure de données est dérivée d'interfaces telles que l'interface itérable et l'interface de collection, offrant une idée des implémentations communes.
2. Facilité d'utilisation : Il simplifie le processus de développement en fournissant des structures de données et des algorithmes prédéfinis. Le développeur peut se concentrer davantage sur la logique métier plutôt que sur la mise en œuvre et l'optimisation manuelles des structures de données et des algorithmes standard couramment utilisés.
3. Flexibilité : Si nous voulons modifier les structures de données sous-jacentes, nous pouvons le faire facilement sans craindre que la modification de la structure des données modifie la récupération des données et les modèles d'accès (principalement).
4. Thread Safety : comme Java fournit un moyen d'exécuter des processus sur différents threads individuellement, Java Collection Framework fournit différentes classes à exécuter dans des environnements multithread et des applications à thread unique.

HIÉRARCHIE DU CADRE DE COLLECTION JAVA

INTERFACE ITERABLE
L'interface Iterable en Java est un composant clé du Collection Framework. Il s'agit de l'interface racine pour tous les types de collections qui peuvent être itérés. L'implémentation de l'interface Iterable permet à un objet d'être la cible d'une "boucle for-each" (également connue sous le nom de boucle for améliorée).
Il fournit également un objet itérateur qui peut être utilisé pour l'itération directe de toutes les structures de données qui implémentent cette interface itérable.

Exemple d'utilisation de FOR EACH LOOP (ENHANCED FOR LOOP)

En interne, ArrayList implémente la liste et l'interface de liste étend l'interface de collection et l'interface de collection étend l'interface itérable.

List list = new ArrayList();//Déclaration d'une structure de données
list.add("Java");//Ajouter un élément
list.add("Collections");//Ajouter un élément
list.add("Framework");//Ajouter un élément
for (élément String : liste) {//Itération à l'aide de la boucle for améliorée
System.out.println(élément);
}

Exemple d'utilisation d'un objet ITERABLE

Itérateur iterator = list.iterator();
while (iterator.hasNext()) {
Élément de chaîne = itérateur.next();
System.out.println(élément);
}

Nous pouvons donc créer une interface itérable itérable personnalisée et remplacer les méthodes next, hasNext et Remove. Voici un exemple de la même chose.

import java.util.Iterator;
class CustomIterable implements Iterable {
    private final int[] numbers = {1, 2, 3, 4, 5};

    @Override
    public Iterator iterator() {
        return new Iterator() {
            private int index = 0;
            private int lastReturnedIndex = -1;

            @Override
            public boolean hasNext() {
                return index 



Note :

Les itérateurs en Java sont rapides à échouer. Cela signifie que si la collection est modifiée lors de l'itération (sauf via la propre méthode remove() de l'itérateur), elle lève une ConcurrentModificationException.
La méthode remove() ne peut supprimer que des éléments et elle ne doit être appelée qu'une seule fois par appel à next(). Sinon, il lancera une IllegalStateException.

  
  
  Interface de collecte


Il s'agit de l'interface à travers laquelle les structures de données et les implémentations internes deviennent flexibles. La plupart des classes implémentent cette interface indirectement, permettant de modifier l'implémentation en modifiant simplement l'objet attribué à sa référence Collection.


//ArrayList
Collection c = new ArrayList():
c.add(1);
c.add(2);
c.contains(1);

Collection c1 = new LinkedList():
c1.addAll(c);//Array added to a linked list

/*What if i dont want arraylist but now i want a priority queue for applying efficient algorithms such as findmax and find min*/
//Just Change Object - SIMPLE!
Collection c = new **PriorityQueue**():
c.add(1);
c.add(2);
c.contains(1);




Interface des méthodes de collecte


int size : Renvoie la taille de la collection.

boolean isEmpty : renvoie true si la collection est vide.

boolean contain(Object o) : renvoie true si l'objet o existe dans la collection.

Iterator iterator() : Renvoie un itérateur pointant vers une collection.

Object[] toArray() : convertit une collection en un tableau de type Object.

 T[] toArray(T[] a) : Renvoie un tableau contenant tous les éléments de la collection ; le type d'exécution du tableau renvoyé est celui du tableau spécifié.

boolean add(E e) : Ajoute l'élément e à la collection. Renvoie vrai si l'opération réussit.

boolean remove(Object o) : Supprime un objet o de la collection. Renvoie vrai si l'opération réussit.

boolean containAll(Collection> c) ​​: renvoie true si tous les éléments des deux collections sont identiques. Renvoie vrai si l'opération réussit.
10.boolean addAll(Collection extends E> c) : Ajoute tous les éléments des deux collections. Renvoie vrai si l'opération réussit.

boolean removeAll(Collection> c) ​​: Supprime l'élément de la collection c de la collection appelante. Renvoie vrai si l'opération réussit.

boolean containAll(Collection> c) ​​: Conserve uniquement les éléments présents dans la collection c.

void clear() : Efface tous les éléments de la collection.
En implémentant la classe de collection, nous pouvons remplacer les méthodes ci-dessus pour créer une collection personnalisée. Vous trouverez ci-dessous un exemple de la même chose.


import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class CustomCollection implements Collection {
    private final ArrayList list = new ArrayList();

    @Override
    public int size() {
        return list.size();
    }

    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    @Override
    public boolean contains(Object o) {
        return list.contains(o);
    }

    @Override
    public Iterator iterator() {
        return new Iterator() {
            private int index = 0;

            @Override
            public boolean hasNext() {
                return index  T[] toArray(T[] a) {
        return list.toArray(a);
    }

    @Override
    public boolean add(E e) {
        return list.add(e);
    }

    @Override
    public boolean remove(Object o) {
        return list.remove(o);
    }

    @Override
    public boolean containsAll(Collection> c) {
        return list.containsAll(c);
    }

    @Override
    public boolean addAll(Collection extends E> c) {
        return list.addAll(c);
    }

    @Override
    public boolean removeAll(Collection> c) {
        return list.removeAll(c);
    }

    @Override
    public boolean retainAll(Collection> c) {
        return list.retainAll(c);
    }

    @Override
    public void clear() {
        list.clear();
    }
}







  
  
  Interface de liste


L'interface List en Java fait partie du Java Collections Framework et étend l'interface Collection. Il représente une collection ordonnée (également appelée séquence) qui permet un accès positionnel, des éléments en double et une itération sur ses éléments. L'interface List est implémentée par plusieurs classes, telles que ArrayList, LinkedList, Vector et Stack.

Caractéristiques clés de l'interface de liste :

Collection ordonnée : une liste préserve l'ordre d'insertion des éléments, ce qui signifie que les éléments sont accessibles via leur index.
Autorise les doublons : une liste peut contenir des éléments en double, contrairement aux ensembles qui n'autorisent pas les doublons.
Accès positionnel : les éléments d'une liste peuvent être consultés, ajoutés ou supprimés par leur index.
Itération : l'interface List permet des boucles for améliorées, ainsi que des itérations à l'aide d'Iterator ou de ListIterator.
Méthodes d'interface de liste couramment utilisées :
Toutes les méthodes d'interface de collection sont également implémentées par l'interface List car l'interface List étend l'interface Collection.

void add(int index, E element) : insère l'élément E spécifié à l'index spécifié dans cette liste.
E get(int index) : renvoie l'élément à la position spécifiée dans cette liste.
E remove(int index) : supprime l'élément à la position spécifiée dans cette liste.
E set(int index, E element) : remplace l'élément à la position spécifiée dans cette liste par l'élément spécifié.
int indexOf(Object o) : renvoie l'index de la première occurrence de l'élément spécifié, ou -1 si la liste ne contient pas l'élément.
int lastIndexOf(Object o) : renvoie l'index de la dernière occurrence de l'élément spécifié, ou -1 si la liste ne contient pas l'élément.
List subList(int fromIndex, int toIndex) : renvoie une vue de la partie de cette liste entre le fromIndex spécifié, inclus, et toIndex, exclusif.

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

public class ListExample {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("Java");
        list.add("Collections");
        list.add("Framework");

        // Accessing elements by index
        System.out.println("First Element: "   list.get(0));

        // Removing an element by index
        list.remove(1);
        System.out.println("After Removal: "   list);

        // Updating an element
        list.set(1, "Updated Element");
        System.out.println("Updated List: "   list);

        // Using a sublist
        List sublist = list.subList(0, 1);
        System.out.println("Sublist: "   sublist);
    }
}