09 - Travailler avec les Strings

Les Strings sont un des types les plus utilisés en Java. Ils sont essentiels pour gérer les noms des joueurs, les messages du chat, les descriptions d'objet, et à peu près tout ce que vous voyez.

Bases des Strings

Les Strings sont des objets qui stockent du texte :

String name = "Simon";
String message = "Bienvenue dans Hytale !";
String empty = "";

Les Strings sont immutables

Une fois créés, un String ne peut pas être modifié Les méthodes qui semblent modifier un String en créent en fait un nouveau ! Les méthodes qui semblent modifier un String en créent en fait un nouveau !

String text = "Bonjour";
text.toUpperCase();           // Crée "BONJOUR" mais ne le sauvegarde pas
System.out.println(text);     // Toujours "Bonjour"

String upper = text.toUpperCase();  // ✓ Sauvegarde le résultat
System.out.println(upper);          // "Bonjour"

Les méthodes des Strings

Length (longueur de chaîne)

String name = "Alice";
int length = name.length();
System.out.println(length);  // 5

Changer la casse

String text = "Hello World";
String upper = text.toUpperCase();  // "HELLO WORLD"
String lower = text.toLowerCase();  // "hello world"

Vérifier le contenu

String message = "Bienvenue dans Hytale";

boolean hasHytale = message.contains("Hytale");  // true
boolean hasMinecraft = message.contains("Minecraft");  // false

boolean starts = message.startsWith("Bienvenue");  // true
boolean ends = message.endsWith("Hytale");  // true

Extraire des parties

String text = "Hello World";

char first = text.charAt(0);      // 'H'
char last = text.charAt(10);      // 'd'

String sub1 = text.substring(0, 5);   // "Hello"
String sub2 = text.substring(6);      // "World"

Indices de substring

substring(start, end) inclus start mais exclus end:

String text = "Hytale";
//             012345 (indices)

text.substring(0, 2);  // "Hy" (indices 0 et 1)
text.substring(2, 6);  // "tale" (indices 2, 3, 4, 5)
text.substring(2);     // "tale" (de 2 jusqu'à la fin)

Remplacer du texte

String text = "J'adore Minecraft";
String replaced = text.replace("Minecraft", "Hytale");
System.out.println(replaced);  // "J'adore Hytale"

String noSpaces = "Hello World".replace(" ", "");
System.out.println(noSpaces);  // "HelloWorld"

Tailler les espaces

String messy = "  Hello World  ";
String clean = messy.trim();
System.out.println(clean);  // "Hello World" (pas d'espaces aux extrémités)

Fractionner des Strings

String command = "give player sword 5";
String[] parts = command.split(" ");

System.out.println(parts[0]);  // "give"
System.out.println(parts[1]);  // "player"
System.out.println(parts[2]);  // "sword"
System.out.println(parts[3]);  // "5"

Comparaison de Strings

N'utilisez jamais == pour les Strings

Utilisez toujours .equals() pour comparer le contenu des Strings !

String name1 = "Steve";
String name2 = "Steve";

// Erreur - Compare les références des objets
if (name1 == name2) {
    System.out.println("Pareil");
}

// Correct - Compare le texte
if (name1.equals(name2)) {
    System.out.println("Pareil");
}

// Pour ignorer la casse lors d'une comparaison
if (name1.equalsIgnoreCase("steve")) {
    System.out.println("Pareil (casse ignorée)");
}

Comparer l'ordre

String a = "Apple";
String b = "Banana";

int result = a.compareTo(b);
// résultat < 0 si a vient avant b
// résultat == 0 si a équivaut à b
// résultat > 0 si a vient après b

if (a.compareTo(b) < 0) {
    System.out.println(a + " vient avant " + b);
}

Concaténation de Strings

En utilisant l'opérateur +

String first = "Hello";
String second = "World";
String combined = first + " " + second;  // "Hello World"

int score = 100;
String message = "Score : " + score;  // "Score : 100"

En utilisant `concat()`

String result = "Hello".concat(" World");  // "Hello World"

Construire des Strings longs

Pour de nombreuses concaténations, utilisez StringBuilder :

StringBuilder builder = new StringBuilder();
builder.append("Joueur : ");
builder.append("Alice");
builder.append(", Niveau : ");
builder.append(10);
builder.append(", Vie : ");
builder.append(100);

String result = builder.toString();
System.out.println(result);
// "Joueur : Alice, Niveau : 10, Vie : 100"

Pourquoi StringBuilder ?

La concaténation classique crée de nombreux Strings temporaires :

// Inefficace - Crée de nombreux Strings temporaires
String result = "";
for (int i = 0; i < 1000; i++) {
    result = result + i;  // Crée 1000 Strings temporaires !
}

// Efficace - StringBuilder est mutable
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);  // Modifie un objet
}
String result = sb.toString();

Utilisez StringBuilder lorsque vous construisez des Strings dans des boucles !

Exemples pratiques

Parser une commande du joueur

public class CommandParser {
    public static void parseCommand(String command) {
        // "/give Steve diamond_sword 1"
        String[] parts = command.split(" ");
        
        String action = parts[0].replace("/", "");  // "give"
        String player = parts[1];                   // "Steve"
        String item = parts[2];                     // "diamond_sword"
        int amount = Integer.parseInt(parts[3]);    // 1
        
        System.out.println("Action : " + action);
        System.out.println("Joueur : " + player);
        System.out.println("Objet : " + item);
        System.out.println("Quantité : " + amount);
    }
    
    public static void main(String[] args) {
        parseCommand("/give Steve diamond_sword 1");
    }
}

Formater le nom d'affichage du joueur

public class PlayerFormatter {
    public static String formatName(String name, int level, String rank) {
        StringBuilder formatted = new StringBuilder();
        
        if (rank != null && !rank.isEmpty()) {
            formatted.append("[").append(rank).append("] ");
        }
        
        formatted.append(name);
        formatted.append(" (Niv. ").append(level).append(")");
        
        return formatted.toString();
    }
    
    public static void main(String[] args) {
        String display1 = formatName("Alice", 10, "VIP");
        System.out.println(display1);  // "[VIP] Alice (Niv. 10)"
        
        String display2 = formatName("Bob", 5, null);
        System.out.println(display2);  // "Bob (Niv. 5)"
    }
}

Valider le nom d'utilisateur

public class UsernameValidator {
    public static boolean isValid(String username) {
        // Règles : entre 3 et 16 caractères, lettres et chiffres seulement
        
        if (username == null || username.isEmpty()) {
            return false;
        }
        
        username = username.trim();
        
        if (username.length() < 3 || username.length() > 16) {
            return false;
        }
        
        for (int i = 0; i < username.length(); i++) {
            char c = username.charAt(i);
            if (!Character.isLetterOrDigit(c)) {
                return false;
            }
        }
        
        return true;
    }
    
    public static void main(String[] args) {
        System.out.println(isValid("Steve"));      // true
        System.out.println(isValid("Player_123")); // false (contient des underscores)
        System.out.println(isValid("ab"));         // false (trop court)
        System.out.println(isValid(""));           // false (vide)
    }
}

Builder de description d'objet

public class ItemDescription {
    public static String buildDescription(String name, String rarity, 
                                         int damage, int durability) {
        StringBuilder desc = new StringBuilder();
        
        // Titre avec code couleur de rareté
        desc.append(getRarityColor(rarity));
        desc.append(name);
        desc.append("\n");
        
        // Statistiques
        desc.append("Dégâts : ").append(damage).append("\n");
        desc.append("Durabilité : ").append(durability).append("/");
        desc.append(durability).append("\n");
        desc.append("Rareté : ").append(rarity);
        
        return desc.toString();
    }
    
    private static String getRarityColor(String rarity) {
        switch (rarity.toLowerCase()) {
            case "legendary": return "§6";  // Doré
            case "epic": return "§5";       // Violet
            case "rare": return "§9";       // Bleu
            case "common": return "§f";     // Blanc
            default: return "§7";           // Gris
        }
    }
    
    public static void main(String[] args) {
        String desc = buildDescription("Excalibur", "Legendary", 50, 1000);
        System.out.println(desc);
    }
}

Filtre de messages dans le tchat

public class ChatFilter {
    private static String[] bannedWords = {"badword1", "badword2"};
    
    public static String filterMessage(String message) {
        String filtered = message.toLowerCase();
        
        for (String word : bannedWords) {
            if (filtered.contains(word)) {
                String replacement = "*".repeat(word.length());
                filtered = filtered.replace(word, replacement);
            }
        }
        
        return filtered;
    }
    
    public static void main(String[] args) {
        String message = "Ceci est un test de badword1";
        String clean = filterMessage(message);
        System.out.println(clean);  // "ceci est un test de ********"
    }
}

Formatage de Strings

En utilisant String.format()

String name = "Alice";
int level = 10;
double health = 85.5;

String formatted = String.format("%s est niveau %d avec %.1f%% de vie", 
                                 name, level, health);
System.out.println(formatted);
// "Alice est niveau 10 avec 85.5% de vie"

Spécificateurs de format

Codes de format courants :

%s - String
%d - Integer (entier)
%f - Flottant (décimal)
%.2f - Flottant avec deux décimales
%n - Nouvelle ligne (indépendamment de la plateforme)

String.format("Nom : %s", "Steve");          // "Nom : Steve"
String.format("Niveau : %d", 10);              // "Niveau : 10"
String.format("Vie : %.1f", 85.5);         // "Vie : 85.5"
String.format("Position : (%d, %d, %d)", 
              10, 64, -5);                    // "Position : (10, 64, -5)"

Opérations courantes sur les Strings

Vérifier si un String est vide

String text = "";

// Vérifie si null ou vide
if (text == null || text.isEmpty()) {
    System.out.println("Vide !");
}

// Vérifie si null ou vide ou uniquement rempli d'espaces
if (text == null || text.trim().isEmpty()) {
    System.out.println("Vide ou espace blanc !");
}

Compter les occurrences

public static int countOccurrences(String text, String target) {
    int count = 0;
    int index = 0;
    
    while ((index = text.indexOf(target, index)) != -1) {
        count++;
        index += target.length();
    }
    
    return count;
}

// Utilisation
int count = countOccurrences("bonjour bonjour salut", "bonjour");
System.out.println(count);  // 2

Inverser un String

public static String reverse(String text) {
    StringBuilder sb = new StringBuilder(text);
    return sb.reverse().toString();
}

// Utilisation
String reversed = reverse("Bonjour");
System.out.println(reversed);  // "ruojnoB"

Vérifier si un String est un palindrome

public static boolean isPalindrome(String text) {
    String cleaned = text.toLowerCase().replaceAll("[^a-z0-9]", "");
    String reversed = new StringBuilder(cleaned).reverse().toString();
    return cleaned.equals(reversed);
}

// Utilisation
System.out.println(isPalindrome("kayak"));     // true
System.out.println(isPalindrome("bonjour"));       // false

Exercices pratiques

Vérificateur de nom d'utilisateur : écrivez une méthode qui vérifie si un nom d'utilisateur :
- Est composé de 3 à 16 caractères
- Contient uniquement des lettres, chiffres et underscores
- Ne commence pas par un chiffre
- Renvoie vrai si le nom est valide, faux sinon
Parseur de commande : parser ce format de commande : /teleport x y z
- Extrayez les coordonnées
- Convertissez-les en entiers
- Renvoyer un tableau composé des trois valeurs
Formateur de tchat : créez une méthode qui formate les messages du tchat :
- Entrée : nom du joueur, rang, message
- Sortie : "[RANG] NomJoueur : message"
- S'il n'y a pas de rang, affichez juste "NomJoueur : message"
Compteur de mots : comptez combien de mots sont présents dans une phrase (les mots sont supposés séparés par un espace)
Casse de titre : convertit un String en casse de titre :
- Entrée : "hello world"
- Sortie : "Hello World"

09 - Travailler avec les Strings

On this page