Support de cours :

IntroJava01_2022

COURS PDF

<?php
echo "Bonjour le monde !";
?>

public class Bonjour {
    public static void main(String[] args) {
        System.out.println("Bonjour le monde !");
    }
}

$nom = "Alice";
$age = 20;
$pi = 3.14;
$ok = true;

String nom = "Alice";
int age = 20;
double pi = 3.14;
boolean ok = true;

if (age >= 18) {
    System.out.println("Majeur");
} else {
    System.out.println("Mineur");
}

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

String[] noms = {"Ana", "Ben", "Chloé"};
for (String n : noms) {
    System.out.println(n);
}

function addition($a, $b) {
  return $a + $b;
}

public class Maths {
    public static int addition(int a, int b) {
        return a + b;
    }
}

class Personne {
  private $nom;
  public function __construct($nom) { $this->nom = $nom; }
  public function sePresenter() { echo "Je m'appelle " . $this->nom; }
}

public class Personne {
    private String nom;

    public Personne(String nom) {
        this.nom = nom;
    }

    public void sePresenter() {
        System.out.println("Je m'appelle " + nom);
    }
}

public class Main {
    public static void main(String[] args) {
        Personne p = new Personne("Alice");
        p.sePresenter();
    }
}

import java.util.Scanner;

public class Calculatrice {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Entrez un nombre : ");
        double a = sc.nextDouble();
        System.out.print("Entrez un autre nombre : ");
        double b = sc.nextDouble();
        double somme = a + b;
        System.out.println("Résultat : " + somme);
        sc.close();
    }
}

$a = readline("Entrez un nombre : ");
$b = readline("Entrez un autre nombre : ");
echo "Résultat : " . ($a + $b) . PHP_EOL;

Qu’est-ce que la méthode equals en Java ?

La méthode equals est une méthode définie dans la classe Object et héritée par toutes les classes Java. Elle permet de comparer si deux objets sont égaux en termes de contenu ou d’état.

Caractéristiques principales :

• La méthode equals compare par défaut les références mémoire des objets, c’est-à-dire si deux variables pointent vers la même instance.
• Pour comparer le contenu logique de deux objets (par exemple, leurs champs), la méthode equals doit être redéfinie dans la classe.
• La redéfinition de equals est souvent accompagnée de la redéfinition de hashCode pour garantir la cohérence dans les structures basées sur le hachage. (voir plus loin dans le cours HashSet et HashMap)

Signature de la méthode :

public boolean equals(Object obj)

• Paramètre : obj est l’objet à comparer avec l’objet courant.
• Retour : Un booléen (true ou false) indiquant si les deux objets sont égaux.

Comment redéfinir equals ?

Pour redéfinir la méthode equals, suivez les étapes suivantes :

1. Commencez par vérifier si l’objet passé en paramètre est identique à l’objet courant (this).
2. Vérifiez si l’objet passé est null ou s’il appartient à une classe différente.
3. Comparez les champs pertinents des deux objets en utilisant des comparaisons appropriées (par exemple, == pour les types primitifs et equals pour les objets).

Exemple de redéfinition :

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true; // Même instance
        if (obj == null || getClass() != obj.getClass()) return false; // Null ou classes différentes
        Person person = (Person) obj; // Cast de l'objet
        return age == person.age && name.equals(person.name); // Comparaison des champs
    }

    @Override
    public int hashCode() {
        return 31 * name.hashCode() + age; // Assurez-vous que hashCode est cohérent avec equals
    }
}

Exemple d’utilisation de equals

Voici un exemple montrant comment utiliser la méthode equals :

public class EqualsExample {
    public static void main(String[] args) {
        Person p1 = new Person("Alice", 25);
        Person p2 = new Person("Alice", 25);
        Person p3 = new Person("Bob", 30);

        System.out.println(p1.equals(p2)); // true : même contenu
        System.out.println(p1.equals(p3)); // false : contenu différent
        System.out.println(p1.equals(null)); // false : comparaison avec null
    }
}

Résultat attendu :

true
false
false

Points importants à retenir sur equals :

• Si vous redéfinissez equals, vous devez également redéfinir hashCode pour garantir la cohérence.
• Assurez-vous que les champs utilisés pour la comparaison sont pertinents pour l’égalité logique des objets.
• Pour éviter une NullPointerException, vérifiez toujours si un champ utilisé avec equals est null.
• Vous pouvez utiliser Objects.equals pour simplifier la comparaison de champs (introduit dans Java 7) :

@Override
public boolean equals(Object obj) {
    if (this == obj) return true;
    if (obj == null || getClass() != obj.getClass()) return false;
    Person person = (Person) obj;
    return age == person.age && Objects.equals(name, person.name); // Utilisation de Objects.equals
}

Différences entre equals et == :

Qu’est-ce qu’un HashSet ?

Un HashSet est une collection en Java qui permet de stocker un ensemble d’éléments uniques, sans ordre particulier.

Caractéristiques principales :

• Pas de doublons : Chaque élément est unique. Si un élément est ajouté et qu’un élément égal existe déjà, le nouvel élément est ignoré.
• Pas d’ordre garanti : Les éléments ne sont pas conservés dans l’ordre d’insertion.
• Basé sur le hachage : Utilise la méthode hashCode pour organiser les éléments dans des compartiments (buckets) et la méthode equals pour vérifier les doublons.
• Performances :
  • Ajout, suppression et recherche d’un élément se font en O(1) en moyenne, grâce au hachage.

Quand utiliser un HashSet ?

• Lorsque vous avez besoin d’un ensemble d’éléments uniques.
• Si l’ordre des éléments n’est pas important.
• Pour des opérations rapides d’ajout, de suppression ou de recherche.

Exemple de code :

import java.util.HashSet;

public class HashSetExample {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();

        set.add("Alice");
        set.add("Bob");
        set.add("Charlie");
        set.add("Alice"); // Ignoré, car "Alice" existe déjà

        System.out.println("Contenu du HashSet :");
        for (String s : set) {
            System.out.println(s);
        }
    }
}

Résultat attendu :

Contenu du HashSet :
Alice
Bob
Charlie

Qu’est-ce qu’un HashMap ?

Un HashMap est une structure clé-valeur en Java. Il associe chaque clé unique à une valeur correspondante.

Caractéristiques principales :

• Clés uniques : Chaque clé dans un HashMap est unique. Si une nouvelle clé identique est ajoutée, sa valeur écrase l’ancienne.
• Valeurs multiples : Plusieurs clés peuvent avoir des valeurs identiques.
• Pas d’ordre garanti : Les clés et valeurs ne suivent pas d’ordre particulier.
• Basé sur le hachage : Utilise les méthodes hashCode et equals pour organiser et comparer les clés.
• Performances :
  • Recherche, insertion et suppression d’une clé ou d’une valeur se font en O(1) en moyenne.

Quand utiliser un HashMap ?

• Lorsque vous devez associer des clés uniques à des valeurs.
• Si l’ordre des éléments n’est pas important.
• Pour des opérations rapides de recherche ou de mise à jour des valeurs.

Exemple de code :

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();

        map.put("Alice", 25);
        map.put("Bob", 30);
        map.put("Charlie", 35);
        map.put("Alice", 28); // Remplace la valeur précédente pour "Alice"

        System.out.println("Contenu du HashMap :");
        for (String key : map.keySet()) {
            System.out.println(key + " : " + map.get(key));
        }
    }
}

Résultat attendu :

Contenu du HashMap :
Alice : 28
Bob : 30
Charlie : 35

Différences entre HashSet et HashMap :