Kotlin Charset : encodage, conversions et pièges courants

Qu'est-ce que Kotlin Charset ?

C’est l’ensemble des règles qui transforment des octets en texte et inversement. Kotlin délègue à la JVM: java.nio.charset.Charset, CharsetEncoder/CharsetDecoder.

Voici les éléments essentiels à connaître autour des Charset en Kotlin :

1 Jeux de caractères courants

Ceux que vous croiserez le plus sur JVM/Android :

UTF-8, UTF-16LE/BE, UTF-16, ISO-8859-1, Windows-1252, US-ASCII

2 API de la JVM utilisées en Kotlin

Interfaces et utilitaires pour encoder/décoder correctement :

java.nio.charset.Charset, StandardCharsets, CharsetEncoder, CharsetDecoder

3 Spécificités Unicode et normalisation

Points clés pour éviter les surprises et comparer des chaînes :

Points de code > U+FFFF (surrogate pairs)

Diacritiques combinés vs précomposés (é = e + ́)

Formes NFC/NFD/NFKC/NFKD pour la normalisation

Caractères non imprimables et NBSP

4 BOM et considérations techniques

Détails qui perturbent souvent les lectures/écritures :

BOM UTF-8/UTF-16 (U+FEFF)

Endianness en UTF-16 (LE/BE)

Séparateurs de lignes CRLF/CR/LF

Substitution char (�) en cas d’erreur de décodage

Problèmes classiques

Fichiers lus/écrits sans charset explicite

Décodage via charset par défaut de la plateforme, différent en CI ou prod.

Tests unitaires qui échouent

Deux chaînes semblent identiques, mais proviennent d’encodages différents (�, diacritiques combinés).

toByteArray() ou String(bytes) sans charset

Utilise le charset par défaut; “ça marche chez moi” mais pas sur un autre OS.

Regex/parseurs perturbés

Caractères substitués, BOM en tête, formes Unicode différentes cassent les traitements.

Exemple de problème courant :

// Kotlin: données “identiques” mais encodage différent

val s1 = "café"

val bytesIso = s1.toByteArray(Charsets.ISO_8859_1)

val s2 = String(bytesIso, Charsets.UTF_8) // Décodage incorrect → “caf�”

check(s1 == s2) // ❌ Échec

Symptômes qui doivent vous alerter

🚨 Signaux d'alarme

!

Un diff git montre des “�” ou un changement massif sans modification apparente

!

Des CSV/JSON parsés en Kotlin perdent des accents ou contiennent des caractères bizarres

!

Un .env/JSON refuse de charger à cause d’un BOM en tête de fichier

!

Votre IDE indique “ISO-8859-1” alors que le projet attend “UTF-8”

!

Un copier-coller dans un terminal ou REPL Kotlin affiche des losanges/points d’interrogation

Comment les détecter

✨ Solution recommandée : Clean ASCII

Clean ASCII met en évidence les caractères non-ASCII, NBSP, ZWSP et BOM qui brouillent l’encodage. Idéal pour repérer rapidement les séquences problématiques avant de corriger le charset dans votre code Kotlin.

✅ Détection automatique

BOM, NBSP, ZWSP, caractères de contrôle, diacritiques isolés

📊 Analyse complète

Positions, points de code Unicode, indices pour choisir l’encodage

🧹 Nettoyage automatique

Remplacement sûr vers ASCII/UTF-8 lorsque pertinent

💾 Export propre

Télécharger un texte nettoyé prêt pour vos I/O Kotlin

🔍 Inspecter mes textes pour l’encodage

Autres méthodes de détection

Affichage dans l'éditeur

✓ Android Studio / IntelliJ: File Encoding, “Reopen with Encoding…”, “Transparent native-to-ascii”

✓ VS Code: “Reopen with Encoding” et statut d'encodage dans la barre d’état

En ligne de commande (Unix)

# Détecter le type présumé

file -bi fichier.txt

# Deviner l'encodage (si installé)

uchardet fichier.txt

# Vérifier si UTF-8 est valide

iconv -f utf-8 -t utf-8 -o /dev/null fichier.txt || echo "UTF-8 invalide"

# Voir les codes hexadécimaux

hexdump -C fichier.txt

En code

Kotlin

val bytes = "éà✓".toByteArray(Charsets.UTF_8)
val hex = bytes.joinToString(" ") { "%02x".format(it) }
val roundTrip = String(bytes, Charsets.UTF_8)

Java

byte[] b = "café".getBytes(java.nio.charset.StandardCharsets.UTF_8);
String s = new String(b, java.nio.charset.StandardCharsets.UTF_8);

Excel / Google Sheets

CODE(MID(cellule;position;1)) # Inspecter les points de code

Nettoyer et prévenir

🚀 Solution rapide avec Clean ASCII

Avant d’ajouter des couches de code, servez-vous de Clean ASCII pour révéler les caractères qui trahissent un mauvais encodage et nettoyer ce qui peut l’être en amont.

✓ Détection des caractères non-ASCII et BOM

✓ Nettoyage ciblé avant import en Kotlin

✓ Export immédiat prêt à lire en UTF-8

Nettoyer maintenant

Méthodes techniques avancées

🔧 Normaliser

✓ Toujours préciser le charset: Charsets.UTF_8 dans String(...) et toByteArray(...)

✓ Supprimer les BOM inutiles en UTF-8, contrôler l’endianness en UTF-16

✓ Uniformiser les fins de ligne via .gitattributes et outils (dos2unix)

🧹 Filtrer

✓ Écrire des extensions Kotlin pour remplacer NBSP, normaliser NFC/NFKC si comparaison stricte

✓ Refuser/échapper les caractères de contrôle indésirables lors de l’import

✓ Configurer les décodeurs pour signaler les erreurs (reporting) plutôt que remplacer silencieusement

⚙️ Automatiser

✓ Gradle: sourceEncoding=UTF-8, compileOptions.encoding = "UTF-8", kotlin.compiler.execution.strategy

✓ .editorconfig: charset = utf-8, vérifications dans la CI

✓ Hooks pre-commit: refuser fichiers non UTF-8 ou contenant BOM

Checklist rapide

Sources et ressources en UTF-8 sans BOM

Gradle/Maven configurés pour UTF-8 partout

IDE paramétré en UTF-8, “Reopen with Encoding” au besoin

Conversions explicites String(bytes, Charsets.UTF_8)

Tests round-trip: s == String(s.toByteArray(UTF_8), UTF_8)

Documentation interne sur encodage, BOM et fins de ligne

Conclusion

Maîtriser Charset en Kotlin, c’est garantir des entrées/sorties fiables et des données lisibles partout. Un charset explicite, des fichiers cohérents et une détection précoce évitent les surprises coûteuses.

Précisez systématiquement l’encodage, contrôlez vos flux et surveillez les BOM: vous éliminez l’essentiel des bugs d’encodage.