Prog 10 : Collections (ArrayList, HashMap)

Démo interactive

Une liste qui grandit toute seule

Contrairement à un tableau figé, une ArrayList s'agrandit et se réduit toute seule. Ajoute ou retire des éléments : les cases se décalent automatiquement.

list.size() = 0

La taille s'ajuste à chaque opération.

1

Pourquoi pas juste des tableaux ?

❌ Tableau classique (Array)

• Taille fixe a la creation
• Ajouter/supprimer = galere
• Pas de methodes pratiques
• Chercher = parcourir tout

int[] notes = new int[5]; // Limite a 5!

✅ Collections

• Taille dynamique
• add(), remove(), contains()...
• Differents types pour differents besoins
• Recherche optimisee (HashMap, Set)

List<Integer> notes = new ArrayList<>(); // Illimite!

2

ArrayList / List

Liste ordonnee qui grandit automatiquement. Comme une file d'attente numerotee.

[0] "Alice"

[1] "Bob"

[2] "Charlie"

import java.util.ArrayList;

ArrayList<String> users = new ArrayList<>();

// Ajouter
users.add("Alice");    // ["Alice"]
users.add("Bob");      // ["Alice", "Bob"]

// Acceder par index
String first = users.get(0);  // "Alice"

// Supprimer
users.remove(0);       // Supprime "Alice"
users.remove("Bob");   // Supprime "Bob"

// Taille
int size = users.size();

// Parcourir
for (String user : users) {
    System.out.println(user);
}

# Python : les listes sont natives!
users = []

# Ajouter
users.append("Alice")  # ["Alice"]
users.append("Bob")    # ["Alice", "Bob"]

# Acceder par index
first = users[0]  # "Alice"

# Supprimer
users.pop()          # Supprime le dernier
users.remove("Alice")  # Supprime "Alice"

# Taille
size = len(users)

# Parcourir
for user in users:
    print(user)

# Bonus Python: list comprehension
doubles = [x * 2 for x in [1, 2, 3]]  # [2, 4, 6]

// JavaScript : Array dynamique natif
const users = [];

// Ajouter
users.push("Alice");  // ["Alice"]
users.push("Bob");    // ["Alice", "Bob"]

// Acceder par index
const first = users[0];  // "Alice"

// Supprimer
users.pop();           // Supprime le dernier
users.splice(0, 1);    // Supprime a l'index 0

// Taille
const size = users.length;

// Parcourir
users.forEach(user => console.log(user));

// Bonus: map, filter, reduce
const doubles = [1, 2, 3].map(x => x * 2);  // [2, 4, 6]

// Go : Slices (tableaux dynamiques)
users := []string{}

// Ajouter
users = append(users, "Alice")  // ["Alice"]
users = append(users, "Bob")    // ["Alice", "Bob"]

// Acceder par index
first := users[0]  // "Alice"

// Supprimer (index 1)
users = append(users[:1], users[2:]...)

// Taille
size := len(users)

// Parcourir
for i, user := range users {
    fmt.Printf("[%d] %s\n", i, user)
}

# R : Vecteurs + Listes
users <- c()  # Vecteur vide

# Ajouter
users <- c(users, "Alice")  # ["Alice"]
users <- c(users, "Bob")    # ["Alice", "Bob"]

# Acceder (attention: indices commencent a 1 !)
first <- users[1]  # "Alice"

# Supprimer (index 2)
users <- users[-2]  # Supprime "Bob"

# Taille
size <- length(users)

# Parcourir (vectorise, pas de boucle !)
print(users)  # Affiche tout
sapply(users, toupper)  # Applique a chaque element

3

HashMap / Dictionnaire

Cle → Valeur. Comme un dictionnaire : tu cherches un mot (cle), tu trouves sa definition (valeur). Acces ultra-rapide O(1) !

"id" → 42

"name" → "Alice"

"email" → "a@b.com"

import java.util.HashMap;

HashMap<String, Integer> ages = new HashMap<>();

// Ajouter
ages.put("Alice", 25);
ages.put("Bob", 30);

// Obtenir
int aliceAge = ages.get("Alice");  // 25

// Verifier existence
if (ages.containsKey("Charlie")) { ... }

// Supprimer
ages.remove("Bob");

// Parcourir
for (String name : ages.keySet()) {
    System.out.println(name + ": " + ages.get(name));
}

# Python : dictionnaire natif
ages = {}

# Ajouter
ages["Alice"] = 25
ages["Bob"] = 30

# Ou directement
ages = {"Alice": 25, "Bob": 30}

# Obtenir
alice_age = ages["Alice"]  # 25
bob_age = ages.get("Bob", 0)  # 30, ou 0 si absent

# Verifier existence
if "Charlie" in ages: ...

# Supprimer
del ages["Bob"]

# Parcourir
for name, age in ages.items():
    print(f"{name}: {age}")

// JavaScript : Object ou Map

// Methode 1: Object (plus courant)
const ages = {};
ages["Alice"] = 25;
ages.Bob = 30;  // Syntaxe point

// Ou directement
const ages2 = { Alice: 25, Bob: 30 };

// Methode 2: Map (plus puissant)
const map = new Map();
map.set("Alice", 25);
map.get("Alice");  // 25
map.has("Bob");    // false
map.delete("Alice");

// Parcourir Object
Object.entries(ages).forEach(([name, age]) => {
    console.log(`${name}: ${age}`);
});

// Go : map
ages := make(map[string]int)

// Ajouter
ages["Alice"] = 25
ages["Bob"] = 30

// Ou directement
ages := map[string]int{"Alice": 25, "Bob": 30}

// Obtenir
aliceAge := ages["Alice"]

// Verifier existence (idiome Go)
age, exists := ages["Charlie"]
if exists { ... }

// Supprimer
delete(ages, "Bob")

// Parcourir
for name, age := range ages {
    fmt.Printf("%s: %d\n", name, age)
}

4

Set (Ensemble)

Collection sans doublons. Parfait pour : "est-ce que cet element existe deja ?"

"apple"

"banana"

"orange"

💡 Cas d'usage typiques : Emails deja inscrits, tags uniques, IDs vus, detection de doublons, operations mathematiques (union, intersection).

5

Quelle collection choisir ?

Operation	ArrayList	HashMap	Set
Acces par index	O(1) ✓	N/A	N/A
Acces par cle	O(n)	O(1) ✓	O(1) ✓
Ajouter a la fin	O(1)	O(1)	O(1)
Chercher element	O(n)	O(1) ✓	O(1) ✓
Ordre garanti	Oui ✓	Non*	Non*
Doublons	Autorises	Cles uniques	Interdits ✓

📋

ArrayList

Liste ordonnee, acces par position, parcours sequentiel

🔑

HashMap

Acces rapide par cle, associations, cache

🎯

Set

Unicite, appartenance, deduplication

Quiz

Mode Survie : Collections

Une erreur = Game Over ! 10 questions aléatoires.

Les Collections