Derrière indexof java, il y a surtout une question très concrète : comment retrouver proprement la position d’un caractère ou d’une sous-chaîne dans un `String` Java. Avec `indexOf`, on récupère l’indice du premier élément trouvé, ou `-1` si rien ne correspond, ce qui en fait un outil de base pour découper un e-mail, lire un log ou vérifier un format avant traitement. Le point important, en pratique, c’est de savoir quoi faire de cet indice sans se tromper sur le zéro, la casse ou les caractères Unicode.
Les points essentiels à retenir avant de chercher un index
- `indexOf` renvoie un indice à partir de 0, pas à partir de 1.
- La méthode retourne -1 quand la chaîne ou le caractère n’est pas trouvé.
- Il existe des variantes pour chercher un caractère, une sous-chaîne ou partir d’un point de départ.
- Pour une répétition ou un séparateur final, `lastIndexOf` est souvent plus adapté.
- Si tu veux juste savoir si quelque chose existe, `contains` suffit souvent.
- Avec des emojis ou certains symboles, l’index reste basé sur les unités UTF-16, pas sur la perception visuelle.
Ce que renvoie vraiment `indexOf` en Java
La règle de base est simple, mais je la rappelle souvent parce qu’elle évite beaucoup d’erreurs de lecture : `indexOf` cherche la première occurrence et renvoie sa position dans la chaîne. En Java, cette position commence à `0`, donc le premier caractère d’un `String` est toujours à l’indice 0, le second à 1, et ainsi de suite.
La méthode est définie sur `String` et existe en plusieurs surcharges. C’est pratique, parce qu’on ne cherche pas toujours la même chose : parfois un simple caractère, parfois une séquence complète, parfois à partir d’un décalage précis.
| Méthode | Ce qu’elle cherche | Retour si trouvé | Usage typique |
|---|---|---|---|
indexOf(int ch) |
Un caractère | Indice du premier match | Repérer un séparateur, comme `@` ou `.` |
indexOf(int ch, int fromIndex) |
Un caractère à partir d’un point de départ | Indice du premier match après ce point | Chercher le second ou troisième séparateur |
indexOf(String str) |
Une sous-chaîne | Indice du premier match | Trouver un mot-clé, un préfixe ou une extension |
indexOf(String str, int fromIndex) |
Une sous-chaîne à partir d’un point de départ | Indice du premier match après ce point | Parcourir une chaîne par segments |
Le retour -1 n’est pas un cas d’exception rare, c’est une sortie normale. Je le traite toujours comme une branche de logique à part entière, pas comme une erreur à ignorer. C’est ce qui permet d’écrire du code lisible et sûr.
Utiliser `indexOf` avec un caractère ou une sous-chaîne
Dans la pratique, deux usages reviennent tout le temps : trouver un caractère unique et repérer un texte plus long. C’est là qu’on voit vraiment pourquoi `indexOf` est si utile dans le parsing léger, les validations simples et les transformations de chaînes.
Repérer un caractère précis
String texte = "Bonjour Java";
int index = texte.indexOf('J'); // 8Ici, `indexOf('J')` renvoie la position du premier `J`. Si le caractère n’existe pas, la méthode renvoie `-1`. Cette forme est idéale pour les séparateurs classiques comme `@`, `.` ou `:`.
Trouver une sous-chaîne
String fichier = "rapport.final.pdf";
int position = fichier.indexOf("final"); // 8La logique est la même, mais on cherche une séquence de plusieurs caractères. C’est utile dès qu’on travaille avec des identifiants, des chemins, des URL, des logs ou des textes métier un peu structurés.
Lire aussi : Nombres aléatoires Java - Le guide complet pour bien choisir
Commencer la recherche après un premier résultat
String log = "INFO|2026-06-09|module|message";
int premierSeparateur = log.indexOf('|');
int secondSeparateur = log.indexOf('|', premierSeparateur + 1);Cette variante est celle que j’utilise le plus quand il faut découper une chaîne sans la scinder entièrement. On évite de créer des objets intermédiaires inutiles, et on garde un contrôle fin sur la position exacte.
Le vrai intérêt de cette approche, c’est qu’elle reste très lisible tant que la structure du texte est simple. Dès que le format devient irrégulier, il faut comparer cette méthode avec d’autres options, surtout si la même séquence peut apparaître plusieurs fois.
Choisir entre `indexOf`, `lastIndexOf` et `contains`
Beaucoup de problèmes viennent moins de la méthode elle-même que du mauvais choix de méthode. Si tu veux la première occurrence, `indexOf` est parfait. Si tu veux la dernière, il faut basculer sur `lastIndexOf`. Si tu veux juste une réponse oui/non, `contains` fait le travail plus proprement.
| Méthode | Retour | Quand je la choisis | Limite principale |
|---|---|---|---|
indexOf |
int |
Quand j’ai besoin de la première position | Ne trouve pas la dernière occurrence |
lastIndexOf |
int |
Quand le séparateur peut se répéter | Moins intuitif si on pense en lecture de gauche à droite |
contains |
boolean |
Quand je veux seulement savoir si le texte existe | Ne donne aucune position |
startsWith |
boolean |
Quand je teste un préfixe | Ne cherche pas au milieu de la chaîne |
matches |
boolean |
Quand la recherche dépend d’un motif plus complexe | Regex plus lourde à lire et souvent inutile pour un simple index |
Dans un code métier, je préfère presque toujours la solution la plus simple qui exprime clairement l’intention. Pour un point précis dans un texte, `indexOf` reste le bon réflexe. Pour un séparateur final comme l’extension d’un fichier, `lastIndexOf` est souvent plus juste.
Les pièges qui font perdre du temps
Les erreurs autour de `indexOf` sont rarement compliquées. Elles viennent surtout d’un détail de lecture ou d’une hypothèse trop rapide sur la chaîne de caractères.
- Confondre `0` et `-1` : `0` signifie que la valeur est au début de la chaîne, pas qu’elle est absente.
- Oublier la sensibilité à la casse : `"Java".indexOf("java")` renvoie `-1` parce que la comparaison est stricte.
- Ne pas tester le retour avant `substring` : si l’indice vaut `-1`, l’appel suivant peut casser ta logique.
- Interpréter un index comme un “vrai caractère” : en Java, les indices de `String` sont basés sur des unités UTF-16, donc certains emojis ou symboles occupent deux positions.
- Utiliser `indexOf` pour un besoin trop complexe : si la structure est irrégulière, un parseur dédié ou une expression régulière sera plus fiable.
Pour une recherche insensible à la casse, je normalise généralement les deux chaînes avec `toLowerCase(Locale.ROOT)` avant la recherche. C’est une solution pragmatique, mais elle ne règle pas tous les cas linguistiques, notamment les variantes liées aux accents ou à certaines locales.
Les réflexes que j’applique avant d’exploiter l’index
Quand j’utilise `indexOf` dans du code de production, je garde une petite discipline. Elle évite les bugs silencieux et rend la suite du traitement beaucoup plus robuste.
- Je vérifie d’abord si la valeur retournée est bien supérieure ou égale à `0`.
- Je choisis entre première et dernière occurrence avant d’écrire la logique, pour ne pas imposer un mauvais comportement par défaut.
- J’extrais ensuite la partie utile avec `substring` seulement si l’indice est valide.
- Je fais attention aux textes contenant des caractères Unicode complexes si la position doit être affichée à un utilisateur.
- Je préfère une recherche simple quand le format est stable, et une vraie stratégie de parsing quand le texte devient ambigu.
Dans un projet réel, cette méthode simple me sert souvent de point d’entrée pour découper des identifiants, des logs ou des champs techniques. Elle reste rapide à lire, facile à tester et suffisante dans une grande partie des cas courants.
Les bons réflexes que je garde pour un code fiable
Si je devais résumer l’usage de `indexOf` en une seule idée, ce serait celle-ci : la méthode est simple, mais elle demande un minimum de rigueur autour du retour et du contexte. Une fois que tu as intégré le rôle de `-1`, la différence entre première et dernière occurrence, et la question des unités UTF-16, le reste devient très mécanique.
- Je n’enchaîne jamais un `substring` sans vérifier l’index.
- Je choisis `lastIndexOf` dès qu’un séparateur peut se répéter.
- Je considère les chaînes multilingues ou riches en emojis comme un cas à part, pas comme un détail.
- Je n’utilise pas `indexOf` quand le besoin est seulement booléen.
En pratique, c’est ce petit niveau de discipline qui transforme une méthode très basique en outil fiable pour le traitement de texte. Bien utilisée, elle couvre une grande partie des besoins courants sans complexifier le code inutilement.
