Objectifs de l'expérimentation :

• Maîtriser les opérations de fusion et de découpage des chaînes de caractères.
• Comprendre la conversion entre différents formats de date.
• Maîtriser les opérations CRUD sur les éléments d'une collection.
• Utiliser des classes utilitaires comme Math et Random.

Exercices pratiques :

1. Analyse des chaînes de caractères

public class AnalyseChaine {
    public static void main(String[] args) {
        String texte = "Bonjour le monde!";
        int pos = texte.indexOf('e');
        int posSeq = texte.indexOf("mon");
        System.out.println("Position 'e' : " + pos + ", Position 'mon' : " + posSeq);
        
        char caractere = texte.charAt(7);
        String extrait1 = texte.substring(0, 7);
        String extrait2 = texte.substring(8);
        System.out.println("Caractère : " + caractere);
        System.out.println("Extrait 1 : " + extrait1);
        System.out.println("Extrait 2 : " + extrait2);
    }
}

2. Concaténation de chaînes

public class ConcatenationExemple {
    public static void main(String[] args) {
        String premier = "Java ";
        String deuxieme = "Programmation";
        String resultat = premier.concat(deuxieme);
        System.out.println("Résultat : " + resultat);
    }
}

3. Formatage des dates

import java.text.SimpleDateFormat;
import java.util.Date;

public class FormatageDate {
    public static void main(String[] args) {
        Date maintenant = new Date();
        
        SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat format2 = new SimpleDateFormat("dd/MM/yyyy HH:mm");
        
        System.out.println("Format ISO : " + format1.format(maintenant));
        System.out.println("Format complet : " + format2.format(maintenant));
    }
}

4. Collections avec génériques

import java.util.*;

public class ListeGenerique {
    public static void main(String[] args) {
        List<integer> nombres = new ArrayList<>();
        nombres.add(5);
        nombres.add(12);
        nombres.add(8);
        nombres.add(3);
        
        // Tri de la liste
        Collections.sort(nombres);
        
        // Parcours avec iterator
        Iterator<integer> it = nombres.iterator();
        while (it.hasNext()) {
            System.out.println("Élément : " + it.next());
        }
    }
}
</integer></integer>

5. Tri inversé avec TreeSet

import java.util.*;

public class TriInverse {
    public static void main(String[] args) {
        Set<integer> ensemble = new TreeSet<>(Comparator.reverseOrder());
        ensemble.addAll(Arrays.asList(7, 2, 9, 4, 1));
        
        ensemble.forEach(System.out::println);
    }
}
</integer>

6. Manipulation de HashMap

import java.util.*;

public class MapExemple {
    public static void main(String[] args) {
        Map<integer string=""> carte = new HashMap<>();
        carte.put(10, "Alpha");
        carte.put(20, "Beta");
        carte.put(30, "Gamma");
        
        System.out.println("Contenu initial : " + carte);
        
        // Suppression d'une entrée
        carte.remove(20);
        
        // Modification d'une valeur
        carte.replace(30, "Delta");
        
        // Accès à une valeur spécifique
        String valeur = carte.get(30);
        System.out.println("Valeur pour clé 30 : " + valeur);
        System.out.println("Contenu final : " + carte);
    }
}
</integer>

7. Méthodes génériques

public class MethodeGenerique {
    
    public static <T> void afficherTableau(T[] tableau) {
        for (T element : tableau) {
            System.out.print(element + ", ");
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        Integer[] entiers = {10, 20, 30, 40};
        String[] mots = {"rouge", "vert", "bleu"};
        
        System.out.println("Entiers :");
        afficherTableau(entiers);
        
        System.out.println("Couleurs :");
        afficherTableau(mots);
    }
}

8. Statistiques sur un tableau aléatoire

import java.util.Random;
import java.util.Arrays;

public class StatistiquesTableau {
    public static void main(String[] args) {
        Random generateur = new Random();
        int[] donnees = new int[10];
        
        for (int i = 0; i < donnees.length; i++) {
            donnees[i] = generateur.nextInt(100);
        }
        
        int maximum = Arrays.stream(donnees).max().orElse(0);
        int minimum = Arrays.stream(donnees).min().orElse(0);
        double moyenne = Arrays.stream(donnees).average().orElse(0.0);
        
        System.out.println("Données : " + Arrays.toString(donnees));
        System.out.println("Maximum : " + maximum);
        System.out.println("Minimum : " + minimum);
        System.out.println("Moyenne : " + String.format("%.2f", moyenne));
    }
}

Notes importantes :

• Les collections ne peuvent contenir que des objets, pas de types primitifs directement.
• Utiliser les méthodes appropriées pour éviter les ClassCastException.
• La classe Random se trrouve dans le package java.util.

Questions de réflexion :

1. Comparer la mutabilité entre String et StringBuffer.
2. Identifier les interfaces garantissant l'ordre des éléments.
3. Quelles interfaces autoirsent les éléments dupliqués ?

Exemple de question :
Quel est le résultat du code suivant ?

String chaine = "abcdefgh";
for(int i = 0; i < chaine.length(); i += 3) {
    System.out.print(chaine.charAt(i));
}

Réponse : adg

Exemple avec StringBuffer :

StringBuffer buffer = new StringBuffer("informatique");
buffer.insert(5, " ");
System.out.println(buffer.toString());
// Sortie : infor matique