10 - ArrayList et Collections

Les tableaux ont une taille fixe, mais que faire si vous avez besoin d'ajouter ou supprimer des éléments ? C'est là que les ArrayList entrent en jeu - des collections redimensionnables qui s'agrandissent et se réduisent automatiquement.

Bases des ArrayList

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        // Crée une ArrayList de Strings
        ArrayList<String> players = new ArrayList<>();
        
        // Ajoute des éléments
        players.add("Alice");
        players.add("Bob");
        players.add("Charlie");
        
        System.out.println(players);  // [Alice, Bob, Charlie]
    }
}

ArrayList vs Tableau

Tableau	ArrayList
Taille fixe	Redimensionnable (grandit/rétrécit)
Peut contenir des types primitifs (int, double, etc.)	Ne peut contenir que des objets (Integer, Double, String, etc.)
Accès plus rapide	Plus de fonctionnalités (add, remove, etc.)
`int[] numbers = new int[10];`	`ArrayList<Integer> numbers = new ArrayList<>();`

Créer des ArrayList

import java.util.ArrayList;

// ArrayList vide
ArrayList<String> items = new ArrayList<>();

// Avec des valeurs initiales (Java 9+)
ArrayList<String> colors = new ArrayList<>(List.of("Red", "Green", "Blue"));

// Différent types
ArrayList<Integer> numbers = new ArrayList<>();
ArrayList<Double> prices = new ArrayList<>();
ArrayList<Boolean> flags = new ArrayList<>();

Types primitifs dans les ArrayList

Vous ne pouvez pas utiliser des types primitifs directement. Utilisez leurs classes wrapper :

// Incorrect
ArrayList<int> numbers = new ArrayList<>();

// Correct - Utilise la classe wrapper
ArrayList<Integer> numbers = new ArrayList<>();

Les classes wrapper :

int → Integer
double → Double
boolean → Boolean
char → Character

Méthodes courantes sur les ArrayList

Ajouter des éléments

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

items.add("Sword");           // Ajoute à la fin
items.add("Shield");
items.add(0, "Helmet");       // Ajouter à un indice spécifique

System.out.println(items);    // [Helmet, Sword, Shield]

Accéder à des éléments

ArrayList<String> items = new ArrayList<>();
items.add("Sword");
items.add("Shield");

String first = items.get(0);    // "Sword"
String second = items.get(1);   // "Shield"

int size = items.size();        // 2

Supprimer des éléments

ArrayList<String> items = new ArrayList<>();
items.add("Sword");
items.add("Shield");
items.add("Potion");

items.remove(1);               // Supprimer par indice (Shield)
items.remove("Potion");        // Supprimer par valeur

System.out.println(items);     // [Sword]

Vérifier le contenu

ArrayList<String> items = new ArrayList<>();
items.add("Sword");
items.add("Shield");

boolean hasSword = items.contains("Sword");     // true
boolean hasAxe = items.contains("Axe");         // false

boolean isEmpty = items.isEmpty();              // false
int size = items.size();                        // 2

Modifier des éléments

ArrayList<String> items = new ArrayList<>();
items.add("Wooden Sword");

items.set(0, "Iron Sword");    // Remplace à l'indice 0

System.out.println(items);     // [Iron Sword]

Effacer tous les éléments

ArrayList<String> items = new ArrayList<>();
items.add("Sword");
items.add("Shield");

items.clear();                 // Supprime tout
System.out.println(items);     // []

Boucler sur une ArrayList

En utilisant la boucle for

ArrayList<String> players = new ArrayList<>();
players.add("Alice");
players.add("Bob");
players.add("Charlie");

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

En utilisant la boucle for améliorée

for (String player : players) {
    System.out.println(player);
}

Using forEach (Java 8+)

players.forEach(player -> System.out.println(player));

Exemples pratiques

Système d'inventaire du joueur

import java.util.ArrayList;

public class Inventory {
    private ArrayList<String> items;
    private int maxSize;
    
    public Inventory(int maxSize) {
        this.items = new ArrayList<>();
        this.maxSize = maxSize;
    }
    
    public boolean addItem(String item) {
        if (items.size() >= maxSize) {
            System.out.println("Inventaire plein !");
            return false;
        }
        
        items.add(item);
        System.out.println("Ajouté : " + item);
        return true;
    }
    
    public boolean removeItem(String item) {
        if (items.remove(item)) {
            System.out.println("Supprimé : " + item);
            return true;
        }
        
        System.out.println("Item non-trouvé !");
        return false;
    }
    
    public void displayInventory() {
        System.out.println("=== Inventaire (" + items.size() + "/" + maxSize + ") ===");
        for (int i = 0; i < items.size(); i++) {
            System.out.println((i + 1) + ". " + items.get(i));
        }
    }
    
    public int getItemCount() {
        return items.size();
    }
    
    public boolean isFull() {
        return items.size() >= maxSize;
    }
}

// Utilisation
public class Main {
    public static void main(String[] args) {
        Inventory inv = new Inventory(5);
        
        inv.addItem("Sword");
        inv.addItem("Shield");
        inv.addItem("Potion");
        inv.displayInventory();
        
        inv.removeItem("Shield");
        inv.displayInventory();
    }
}

Système de quête

import java.util.ArrayList;

public class QuestManager {
    private ArrayList<String> activeQuests;
    private ArrayList<String> completedQuests;
    
    public QuestManager() {
        this.activeQuests = new ArrayList<>();
        this.completedQuests = new ArrayList<>();
    }
    
    public void startQuest(String questName) {
        if (!activeQuests.contains(questName)) {
            activeQuests.add(questName);
            System.out.println("Quête commencée : " + questName);
        } else {
            System.out.println("Quête déjà active !");
        }
    }
    
    public void completeQuest(String questName) {
        if (activeQuests.remove(questName)) {
            completedQuests.add(questName);
            System.out.println("Quête complétée : " + questName);
        } else {
            System.out.println("Quête non-trouvée dans la liste des quêtes actives !");
        }
    }
    
    public void displayQuests() {
        System.out.println("\n=== Quêtes Active ===");
        if (activeQuests.isEmpty()) {
            System.out.println("Pas de quêtes actives");
        } else {
            for (String quest : activeQuests) {
                System.out.println("- " + quest);
            }
        }
        
        System.out.println("\n=== Quêtes Complétées ===");
        if (completedQuests.isEmpty()) {
            System.out.println("Pas de quêtes complétées");
        } else {
            for (String quest : completedQuests) {
                System.out.println("" + quest);
            }
        }
    }
    
    public int getTotalCompleted() {
        return completedQuests.size();
    }
}

Système de classement

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

public class Leaderboard {
    private ArrayList<Integer> scores;
    private ArrayList<String> players;
    
    public Leaderboard() {
        this.scores = new ArrayList<>();
        this.players = new ArrayList<>();
    }
    
    public void addScore(String player, int score) {
        players.add(player);
        scores.add(score);
        System.out.println(player + " à marqué " + score + " points !");
    }
    
    public void displayTop(int count) {
        System.out.println("\n=== Top " + count + " des Joueurs ===");
        
        // Crée une copie pour trier
        ArrayList<Integer> sortedScores = new ArrayList<>(scores);
        ArrayList<String> sortedPlayers = new ArrayList<>(players);
        
        // Tri à bulles (simple pour apprendre)
        for (int i = 0; i < sortedScores.size() - 1; i++) {
            for (int j = 0; j < sortedScores.size() - i - 1; j++) {
                if (sortedScores.get(j) < sortedScores.get(j + 1)) {
                    // Inverser les scores
                    int tempScore = sortedScores.get(j);
                    sortedScores.set(j, sortedScores.get(j + 1));
                    sortedScores.set(j + 1, tempScore);
                    
                    // Inverser les joueurs
                    String tempPlayer = sortedPlayers.get(j);
                    sortedPlayers.set(j, sortedPlayers.get(j + 1));
                    sortedPlayers.set(j + 1, tempPlayer);
                }
            }
        }
        
        // Afficher les meilleurs scores
        int limit = Math.min(count, sortedScores.size());
        for (int i = 0; i < limit; i++) {
            System.out.println((i + 1) + ". " + sortedPlayers.get(i) + 
                             " - " + sortedScores.get(i) + " points");
        }
    }
}

Traqueur de joueurs en ligne

import java.util.ArrayList;

public class OnlinePlayersTracker {
    private ArrayList<String> onlinePlayers;
    
    public OnlinePlayersTracker() {
        this.onlinePlayers = new ArrayList<>();
    }
    
    public void playerJoin(String playerName) {
        if (!onlinePlayers.contains(playerName)) {
            onlinePlayers.add(playerName);
            broadcast(playerName + " à rejoint le jeu");
            updatePlayerCount();
        }
    }
    
    public void playerLeave(String playerName) {
        if (onlinePlayers.remove(playerName)) {
            broadcast(playerName + " à quitté le jeu");
            updatePlayerCount();
        }
    }
    
    public boolean isOnline(String playerName) {
        return onlinePlayers.contains(playerName);
    }
    
    public int getPlayerCount() {
        return onlinePlayers.size();
    }
    
    public void listPlayers() {
        System.out.println("\n=== Online Players (" + getPlayerCount() + ") ===");
        for (String player : onlinePlayers) {
            System.out.println("• " + player);
        }
    }
    
    private void broadcast(String message) {
        System.out.println("[Serveur] " + message);
    }
    
    private void updatePlayerCount() {
        System.out.println("Joueurs en ligne : " + getPlayerCount());
    }
}

ArrayList d'objets personnalisés

Vous pouvez stocker vos propres classes dans des ArrayLists :

public class Player {
    private String name;
    private int level;
    
    public Player(String name, int level) {
        this.name = name;
        this.level = level;
    }
    
    public String getName() {
        return name;
    }
    
    public int getLevel() {
        return level;
    }
    
    @Override
    public String toString() {
        return name + " (Niv. " + level + ")";
    }
}

public class Main {
    public static void main(String[] args) {
        ArrayList<Player> players = new ArrayList<>();
        
        players.add(new Player("Alice", 10));
        players.add(new Player("Bob", 15));
        players.add(new Player("Charlie", 8));
        
        // Affiche tous les joueurs
        for (Player player : players) {
            System.out.println(player);
        }
        
        // Trouver un joueur par son nom
        for (Player player : players) {
            if (player.getName().equals("Bob")) {
                System.out.println("Trouvé : " + player);
            }
        }
    }
}

Operations utiles sur les ArrayList

Convertir en tableau

ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");

String[] array = list.toArray(new String[0]);

Convertir un tableau en ArrayList

String[] array = { "A", "B", "C" };
ArrayList<String> list = new ArrayList<>(Arrays.asList(array));

Copier une ArrayList

ArrayList<String> original = new ArrayList<>();
original.add("A");
original.add("B");

// Copie supperficielle
ArrayList<String> copy = new ArrayList<>(original);

Trouver l'indice d'un élément

ArrayList<String> items = new ArrayList<>();
items.add("Sword");
items.add("Shield");

int index = items.indexOf("Shield");  // 1
int notFound = items.indexOf("Axe");  // -1

Exercices pratiques

Panier d'achats : créez un système de panier :
- Ajouter des objets
- Retirer des objets
- Calculer le total des objets
- Vider le panier
Liste d'amis : créez un système de gestion d'amis :
- Ajouter des amis
- Retirer des amis
- Regarder si quelqu'un est un ami
- Afficher tous les amis
Todo List : créez un système de todo list :
- Ajouter une tâche
- Marquer une tâche comme complétée (la déplacer dans la liste des tâches complétées)
- Afficher les tâches actives
- Afficher les tâches complétées
Meilleurs scores : créez un système de meilleur score :
- Ajouter des scores
- Afficher les 5 meilleurs scores dans l'ordre
- Supprimer les scores les plus bas si plus de 10 scores existent

10 - ArrayList et Collections

On this page