Objectifs d'apprentissage

• Assimiler les concepts fondamentaux de Git pour la gestion de versions.
• Optimiser l'utilisation de la classe Scanner pour la lecture des flux d'entrée.
• Exploiter les classes essentielles du JDK : String, StringBuilder, Integer, etc.
• Manipuler les structures de données dynamiques avec ArrayList et les tableaux multidimensionnels.
• Comprendre la précision numérique avec BigDecimal.

Gestion de version avec Git

L'usage de Git est crucial pour maintenir l'historique de votre code. Voici les étapes clés à maîtriser :

• Configuration : Création d'un dépôt distant et clonage en local via la ligne de commande.
• Flux de travail : Synchronisation systématique (pull) avant toute modification pour éviter les conflits, suivie du commit et du push.
• Intégration IDE : Utilisation des outils intégrés comme Eclipse Egit pour faciliter les opérations graphiques.

Pratiques de programmation et astuces IDE

Pour une efficacité maximale lors de la résolution de problèmes techniques, suivez ces recommandations :

• Gestion des entrées : Privilégiez l'utilisation exclusive de nextLine() pour éviter le problème classique du "caractère de nouvelle ligne résiduel" lors de l'alternance avec nextInt().
• Traitement des chaînes : Utilisez String.split("\\s+") pour découper une chaîne de caractères en ignorant les espaces multiples.
• Raccourcis IDE : Familiarisez-vous avec les modèles de code (sout, fori dans IntelliJ) et les fonctions de refactorisation (Alt + Shift + M pour extraire une méthode).

Manipulation des collections : Focus sur ArrayList

Contrairement aux tableaux statiques, la ArrayList offre une flexibilité totale. Voici un exemple illustrant la manipulation de listes et l'importance de l'extraction de méthodes pour la clarté du code.

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

public class GestionCollections {

    public static void main(String[] args) {
        List<Integer> notes = new ArrayList<>();
        notes.add(15);
        notes.add(Integer.valueOf(18));
        
        System.out.println("Liste des notes :");
        afficherContenu(notes);

        List<String> noms = new ArrayList<>();
        noms.add("Alice");
        noms.add("Bob");
        noms.add(1, "Charles"); // Insertion à l'index 1
        noms.set(0, "Damien");   // Remplacement de l'élément à l'index 0
        
        System.out.println("Liste des noms modifiée :");
        afficherContenu(noms);
    }

    /**
     * Méthode extraite pour modulariser l'affichage
     */
    private static void afficherContenu(List<?> liste) {
        for (Object element : liste) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

Optimisation et Précision

Performance des chaînes de caractères

Lors de la concaténation de chaînes dans des boucles, l'utilisation de l'opérateur + crée de multiples objets temporaires. Il est fortement recommandé d'utiliser StringBuilder pour améliorer les performances mémoire et processeur.

Calculs financiers et précision

Les types primitifs float et double ne sont pas adaptés aux calculs de haute précision à cause des erreurs d'arrondi binaire. Pour ces cas, la classe BigDecimal est indispensable. Notez que BigDecimal est immuable : chaque opération produit une nouvelle instance.

import java.math.BigDecimal;

public class CalculPrecis {
    public static void main(String[] args) {
        BigDecimal valeur1 = new BigDecimal("1.0");
        BigDecimal valeur2 = new BigDecimal("0.9");
        BigDecimal resultat = valeur1.subtract(valeur2);
        System.out.println("Résultat précis : " + resultat); // Affiche 0.1
    }
}

Structures de données non régulières

Java permet de définir des tableaux multidimensionnels dont la taille de la seconde dimension varie. Cela est utile pour optimiser l'espace mémoire lorsque les lignes ne contiennent pas le même nombre d'éléments.