Java Academy · Leçon

Arrays.binarySearch

Rechercher dans des tableaux triés

Arrays.binarySearch est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Rechercher dans des tableaux triés

Arrays.binarySearch recherche un élément dans un tableau trié en temps O(log n). La méthode réduit la plage de recherche de moitié à chaque étape, ce qui est bien plus rapide que de parcourir chaque élément.

La condition préalable du tri

Le tableau doit déjà être trié dans l'ordre croissant. S'il ne l'est pas, le résultat n'est pas défini. Appelez toujours Arrays.sort au préalable en cas de doute.

Une recherche simple

Lorsque la valeur est trouvée, binarySearch renvoie son index.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = {2, 4, 6, 8, 10};
        int index = Arrays.binarySearch(nums, 8);
        System.out.println("Found at index " + index);
    }
}

Lorsque la valeur est absente

Si la valeur n'est pas présente, la valeur renvoyée est négative : elle est égale à -(insertionPoint) - 1. Le point d'insertion indique où placer la valeur pour conserver le tableau trié.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = {2, 4, 6, 8, 10};
        int result = Arrays.binarySearch(nums, 5);
        System.out.println("Raw result: " + result);
    }
}

Récupérer le point d'insertion

Pour convertir un résultat négatif en index d'insertion, calculez -(result) - 1. Vous saurez ainsi où insérer la valeur absente.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = {2, 4, 6, 8, 10};
        int result = Arrays.binarySearch(nums, 5);
        if (result < 0) {
            int insertionPoint = -(result) - 1;
            System.out.println("Would insert at index " + insertionPoint);
        }
    }
}

Rechercher dans des tableaux d'objets

binarySearch fonctionne également sur les tableaux d'objets en utilisant l'ordre naturel. Le tableau doit être trié selon le même ordre que celui utilisé pour la recherche.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Alice", "Bob", "Charlie", "Dave"};
        int index = Arrays.binarySearch(names, "Charlie");
        System.out.println("Charlie at index " + index);
    }
}

Rechercher avec un Comparator

Si le tableau a été trié avec un Comparator personnalisé, vous devez transmettre le même Comparator à binarySearch ; sinon, les résultats sont dépourvus de sens.

import java.util.Arrays;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Dave", "Charlie", "Bob", "Alice"};
        Comparator<String> desc = Comparator.reverseOrder();
        Arrays.sort(names, desc);
        int index = Arrays.binarySearch(names, "Charlie", desc);
        System.out.println("Index: " + index);
    }
}

Rechercher dans une plage

Vous pouvez limiter la recherche à une partie du tableau avec binarySearch(array, fromIndex, toIndex, key). Les limites de la plage suivent la même règle d'inclusion et d'exclusion que pour sort.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = {2, 4, 6, 8, 10, 12};
        int index = Arrays.binarySearch(nums, 1, 5, 8);
        System.out.println("Index: " + index);
    }
}

Les doublons ne sont pas spécifiés

Si le tableau contient des valeurs en double, rien ne garantit l'index correspondant qui sera renvoyé. La recherche binaire est surtout utile avec des tableaux dont les clés sont uniques.

Pourquoi ne pas utiliser une simple boucle ?

Un parcours linéaire est en O(n) et fonctionne sur des données non triées. La recherche binaire est en O(log n), mais elle exige des données triées. Pour des recherches répétées dans de grands ensembles de données, trier une fois puis effectuer de nombreuses recherches binaires offre un gain considérable.

Mettre tout en pratique

Triez, recherchez, puis interprétez le résultat en toute sécurité.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] ids = {40, 10, 30, 20};
        Arrays.sort(ids);
        int r = Arrays.binarySearch(ids, 30);
        if (r >= 0) {
            System.out.println("Found 30 at index " + r);
        } else {
            System.out.println("Not found; insert at " + (-(r) - 1));
        }
    }
}

Vérification rapide

Vérifiez votre compréhension de binarySearch.

Récapitulatif

Vous avez appris à effectuer des recherches rapides avec Arrays.binarySearch.

Le tableau doit d'abord être trié.
Un résultat non négatif est l'index de l'élément trouvé.
Un résultat négatif encode le point d'insertion sous la forme -(result) - 1.
Utilisez le même Comparator pour le tri et la recherche.

Questions Fréquemment Posées

La leçon « Arrays.binarySearch » est-elle gratuite ?

Oui — le texte complet de « Arrays.binarySearch » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Arrays.binarySearch » ?

Rechercher dans des tableaux triés Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Arrays.binarySearch » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Java Academy