String Manipulation · Manipulation de Chaînes
| English | Français |
|---|---|
| immutable/ɪˈmjuːtəbl/ | immuables |
Strings and indexing
- A
Stringis a sequence of characters, numbered from0. - In
"HELLO", index0is'H', index1is'E', … index4is'O'. s.length()gives the count of characters; the last index islength() - 1.- Off-by-one errors here are the most common String bug.
Chaînes et indexation
- Une
Stringest une séquence de caractères, numérotés à partir de0. - Dans
"HELLO", l'index0est'H', l'index1est'E', … l'index4est'O'. s.length()donne le nombre de caractères ; le dernier index estlength() - 1.- Les erreurs d'indexation (off-by-one) sont le bug String le plus courant.
substring
s.substring(start, end)returns the characters from indexstartup to but not includingend."HELLO".substring(1, 3)→"EL"(indices1and2, not3).s.substring(start)(one argument) goes fromstartto the end.- The result's length is
end - start.
substring
s.substring(start, end)retourne les caractères de l'indexstartjusqu'à mais sans inclureend."HELLO".substring(1, 3)→"EL"(indices1et2, pas3).s.substring(start)(un argument) va destartjusqu'à la fin.- La longueur du résultat est
end - start.
indexOf and equals
s.indexOf("lo")returns the first index where the text appears, or-1if not found.s.equals(t)tests whether two Strings have the same characters — returns aboolean.- Use
.equals(), never==, to compare String contents. ==compares references (addresses), not the characters.
indexOf et equals
s.indexOf("lo")retourne le premier index où le texte apparaît, ou-1s'il n'est pas trouvé.s.equals(t)teste si deux Strings ont les mêmes caractères — retourne unboolean.- Utilisez
.equals(), jamais==, pour comparer le contenu des Strings. ==compare les références (adresses), pas les caractères.
Strings are immutable
- A String is immutable 不可变: its characters can never be changed once created.
- Methods like
substringandtoUpperCasereturn a new String — they don't edit the original. s.toUpperCase();alone does nothing visible; you must store the result:s = s.toUpperCase();- Immutability is why String methods always hand back a fresh value.
Les Strings sont immuables
- Un String est immuable 不可变 : ses caractères ne peuvent jamais être changés une fois créés.
- Les méthodes comme
substringettoUpperCaseretournent un nouveau String — elles ne modifient pas l'original. s.toUpperCase();seul ne fait rien de visible ; vous devez stocker le résultat :s = s.toUpperCase();- L'immutabilité est pourquoi les méthodes String retournent toujours une nouvelle valeur.
Compare String contents with .equals(), never ==. == tests whether two references point to the same object, not whether the characters match — so a == b can be false even when both are "cat". And Strings are immutable: s.toUpperCase() returns a new String and leaves s unchanged unless you reassign s = s.toUpperCase();.
Comparez le contenu des Strings avec .equals(), jamais ==. == teste si deux références pointent vers le même objet, pas si les caractères correspondent — donc a == b peut être false même si tous deux sont "cat". Et les Strings sont immuables : s.toUpperCase() retourne un nouveau String et laisse s inchangé sauf si vous réassignez s = s.toUpperCase();.
Working with "HELLO":
"HELLO".length()→5; index0is'H', index4is'O'."HELLO".substring(1, 4)→"ELL"(indices1, 2, 3)."HELLO".indexOf("L")→2(firstL);.equals("hello")→false(case differs).
Travailler avec "HELLO" :
"HELLO".length()→5; l'index0est'H', l'index4est'O'."HELLO".substring(1, 4)→"ELL"(indices1, 2, 3)."HELLO".indexOf("L")→2(premierL) ;.equals("hello")→false(la casse diffère).
A String is indexed from 0 (last index length()-1). substring(start, end) returns indices start to end-1; indexOf finds a position (or -1). Compare contents with .equals(), not ==. Strings are immutable — methods return a new String, so reassign to keep the change.
Une String est indexée à partir de 0 (dernier index length()-1). substring(start, end) retourne les indices start à end-1 ; indexOf trouve une position (ou -1). Comparez le contenu avec .equals(), pas ==. Les Strings sont immuables — les méthodes retournent un nouveau String, donc réassignez pour garder le changement.
Indexing HELLO from 0 · Indexation de HELLO depuis 0
substring(1, 4) takes indices 1, 2, 3 → ELL. · substring(1, 4) prend les indices 1, 2, 3 → ELL.
In the String "HELLO", which character is at index 0? · Dans la chaîne "HELLO", quel caractère est à l'index 0 ?
Strings are indexed from 0, so index 0 is 'H'. · Les chaînes sont indexées à partir de 0, donc l'index 0 est 'H'.
What does "HELLO".substring(1, 3) return? · Que retourne "HELLO".substring(1, 3) ?
Indices 1 and 2 (up to but not including 3) → EL. · Indices 1 et 2 (jusqu'à mais sans inclure 3) → EL.
To compare whether two Strings have the same characters, you should use... · Pour comparer si deux chaînes ont les mêmes caractères, vous devez utiliser...
.equals() compares contents; == compares references. · .equals() compare le contenu ; == compare les références.
s.toUpperCase(); on its own changes the String s in place. · s.toUpperCase(); tout seul modifie la chaîne s sur place.
Strings are immutable — you must reassign s = s.toUpperCase();. · Les chaînes sont immuables — vous devez réassigner s = s.toUpperCase();
What does "HELLO".indexOf("L") return (the first L)? · Que retourne "HELLO".indexOf("L") (le premier L) ?
The first 'L' is at index 2. · Le premier 'L' est à l'index 2.