HOWTO · Java

Booléen à chaîne de caractères en Java

Ce tutoriel enseigne comment convertir une valeur booléenne en une chaîne de caractères en Java

Sur cette page

En Java, le type primitif boolean et la classe enveloppe Boolean représentent tous deux true ou false. Pour une valeur primitive, utilisez String.valueOf(boolean) ou la surcharge statique Boolean.toString(boolean). Pour un objet Boolean non nul, sa méthode d’instance toString() convient également. La concaténation et le formatage sont utiles lorsque la valeur s’intègre à un message plus long. Ces conversions produisent du texte en minuscules : true devient "true" et false devient "false".

Convertir un boolean primitif en chaîne avec String.valueOf(boolean)

String.valueOf(boolean) est une méthode statique de String qui accepte un boolean primitif et renvoie sa représentation textuelle. C’est un choix direct lorsque la valeur est déjà primitive ; le résultat peut être stocké, comparé ou transmis à une méthode qui attend un String. La valeur d’entrée reste un booléen ; la valeur renvoyée est du texte et ne convient donc pas aux conditions booléennes ultérieures sans conversion inverse.

Exécutez cet exemple :

public class BooleanStringExample {
    public static void main(String[] args) {
        boolean active = true;
        String text = String.valueOf(active);
        System.out.println(text);
    }
}
true

Cette forme fonctionne aussi avec false et renvoie la chaîne correspondante en minuscules. Utilisez la surcharge primitive lorsque la variable source est déclarée comme boolean ; Java peut également effectuer une conversion automatique d’un Boolean non nul en boolean lorsqu’un argument primitif est requis. Si une référence enveloppe peut être nulle, traitez ce cas avant de la transmettre à une méthode qui attend un type primitif, car la conversion automatique d’une référence nulle provoque une NullPointerException.

Convertir une valeur Boolean en chaîne avec Boolean.toString()

Boolean est la classe enveloppe, tandis que boolean est le type primitif. Un objet Boolean non nul peut appeler la méthode d’instance toString(). La classe fournit également la surcharge statique Boolean.toString(boolean), qui accepte directement une valeur primitive et évite de créer un objet enveloppe uniquement pour convertir cette valeur. L’exemple montre les deux formes afin que vous puissiez choisir selon le type dont vous disposez. Les libellés « Instance » et « Static », ainsi que la sortie affichée, restent en anglais, car les blocs de code et de sortie sont conservés sans modification.

public class BooleanStringExample {
    public static void main(String[] args) {
        Boolean enabled = Boolean.FALSE;
        String instanceText = enabled.toString();
        boolean active = true;
        String staticText = Boolean.toString(active);
        System.out.println("Instance: " + instanceText);
        System.out.println("Static: " + staticText);
    }
}
Instance: false
Static: true

L’appel d’instance exige une référence non nulle : si enabled vaut null, enabled.toString() provoque une NullPointerException. La surcharge statique s’appelle sur la classe et prend une valeur primitive ; elle ne déréférence donc pas d’objet enveloppe. Si vous recevez un Boolean potentiellement nul, déterminez ce que signifie null avant d’appeler la méthode d’instance ou de convertir la valeur en type primitif. Vous pouvez, par exemple, tester la référence et fournir une chaîne de remplacement si elle est nulle.

Convertir un boolean ou un Boolean en chaîne par concaténation

Lorsqu’une chaîne est déjà en cours de construction, Java convertit un boolean primitif en texte minuscule pendant la concaténation. Un objet enveloppe Boolean non nul est lui aussi converti en texte correspondant. Placez la chaîne en premier pour rendre un libellé facile à lire, par exemple "Enabled: " + enabled. Cette approche convient aux messages et aux journaux ; pour une conversion isolée, une méthode explicite exprime plus clairement l’intention. Les libellés « Active », « Enabled » et « Available », ainsi que les sorties affichées, restent en anglais, car les blocs de code et de sortie sont conservés sans modification.

public class BooleanStringExample {
    public static void main(String[] args) {
        boolean active = true;
        Boolean enabled = Boolean.FALSE;
        System.out.println("Active: " + active);
        System.out.println("Enabled: " + enabled);
    }
}
Active: true
Enabled: false

La concaténation d’un Boolean nul produit le texte "null" ; elle n’appelle pas toString() sur cette référence. C’est différent de enabled.toString(), qui provoque une NullPointerException lorsque la même référence est nulle. Gardez cette distinction à l’esprit lors de la construction d’une sortie : la concaténation conserve null sous forme du mot null, tandis que la méthode d’instance exige une valeur Boolean réelle. Si le texte est destiné à un utilisateur ou à un format externe, choisissez une valeur de remplacement explicite lorsque null risque d’être ambigu.

Formater un booléen en chaîne avec String.format()

Utilisez String.format() lorsque le booléen fait partie d’un message formaté plus long ou lorsque le message contient plusieurs valeurs. Sa conversion %b formate un argument Boolean en true ou false minuscules ; elle convient aux modèles lisibles, même si elle ajoute un mécanisme de formatage pour une seule valeur. Cet exemple garde la chaîne de format et la valeur ensemble, ce qui permet de repérer facilement la position du booléen. Les libellés et la sortie affichée restent en anglais, car les blocs de code et de sortie sont conservés sans modification.

public class BooleanStringExample {
    public static void main(String[] args) {
        boolean available = true;
        String message = String.format("Available: %b", available);
        System.out.println(message);
    }
}
Available: true

Pour une conversion simple, préférez String.valueOf(boolean) ou Boolean.toString(boolean). Utilisez la concaténation pour un libellé court et String.format() lorsqu’un modèle structure mieux un message plus long. Dans tous les cas, tenez compte du type source : un primitif a toujours une valeur booléenne, tandis qu’une référence Boolean peut être nulle.