Redéfinir Java toString() | W3Docs Learn Java

toString est la méthode que System.out.println, la concaténation de chaînes et votre débogueur appellent lorsqu'ils ont besoin de représenter un objet sous forme de texte. La version par défaut — héritée d'Object — renvoie le nom de la classe suivi d'un hash hexadécimal illisible. Redéfinir toString est l'une des choses les moins coûteuses et les plus rentables que vous puissiez faire pour ceux qui liront vos logs et vos traces de pile (souvent une version future de vous-même).

Où est-il appelé

Vous n'appelez presque jamais toString directement. Il est invoqué implicitement chaque fois qu'un objet est converti en texte :

Point p = new Point(3, 4);
System.out.println(p);          // calls p.toString()
String msg = "got " + p;        // calls p.toString()
log.info("point: {}", p);       // calls p.toString()

Partout où un Object apparaît dans un contexte qui attend un String, toString s'exécute. C'est pourquoi la valeur par défaut est si décevante — elle apparaît partout et ne vous dit rien d'utile.

La valeur par défaut

Object.toString() renvoie getClass().getName() + "@" + Integer.toHexString(hashCode()). Ainsi, une classe ordinaire affiche quelque chose comme com.example.Point@1540e19d. Le nom de classe est correct ; le hexadécimal est le hash d'identité, qui est inutile quand vous essayez de comprendre ce que contiennent les champs de l'objet.

Une bonne redéfinition

Une bonne méthode toString est concise, non ambiguë et contient les données qu'un lecteur voudrait voir :

@Override
public String toString() {
  return "Point[x=" + x + ", y=" + y + "]";
}

Quelques conventions qui valent la peine d'être suivies :

Incluez le nom de la classe. Quand une ligne de log mélange des objets, savoir de quel type il s'agit est important.
Utilisez une forme stable et analysable. Class[field=value, field=value] est ce que les records et la plupart des bibliothèques Java modernes utilisent. C'est lisible et facile à chercher avec grep.
Affichez les champs qui importent — généralement ceux présents dans equals. Omettez les champs volumineux (un blob de 10 Mo, une Connection).
N'incluez pas de données sensibles. Mots de passe, jetons, données personnelles — laissez-les de côté, ou masquez-les. toString finit dans les fichiers de logs.

Avec String.format ou les blocs de texte

Pour plus de trois ou quatre champs, String.format (ou un bloc de texte) se lit mieux que la concaténation :

@Override
public String toString() {
  return String.format("User[id=%d, name=%s, role=%s]", id, name, role);
}

Ne le rendez pas coûteux

toString est appelé plus souvent que vous ne le pensez — les frameworks de journalisation rendent les arguments paresseusement, mais suffisamment tôt pour qu'un toString en O(n²) sur une liste de 100 000 éléments ralentisse réellement votre service. Gardez la sortie bornée. Le toString d'une collection devrait se limiter à un début sensible, avec ... (N more) pour le reste.

Ne lancez pas d'exception depuis toString

Lancer une exception dans toString transforme une ligne de log ordinaire en NullPointerException quelque part d'inattendu — et le problème sous-jacent que vous essayiez de journaliser est perdu. Protégez-vous contre les valeurs nulles :

@Override
public String toString() {
  return "Order[id=" + id + ", customer=" + (customer == null ? "<none>" : customer.name()) + "]";
}

Les records l'obtiennent gratuitement

Si votre classe est un simple porteur de données, les records génèrent déjà un bon toString :

record Point(int x, int y) {}
System.out.println(new Point(3, 4));   // Point[x=3, y=4]

Redéfinir toString est donc surtout utile pour les classes qui ne sont pas des records.

Un exemple complet

java— editable, runs on the server

import java.util.List;
import java.util.stream.Collectors;

public class ToStringDemo {
  static class User {
    final int    id;
    final String name;
    final String token;   // sensitive — must not appear in toString
    User(int id, String name, String token) {
      this.id = id; this.name = name; this.token = token;
    }
    @Override
    public String toString() {
      return "User[id=" + id + ", name=" + name + "]";   // no token
    }
  }

static class Cart {
    final User user;
    final List<String> items;
    Cart(User user, List<String> items) {
      this.user = user;
      this.items = items;
    }
    @Override
    public String toString() {
      String preview = items.stream().limit(3).collect(Collectors.joining(", "));
      String tail    = items.size() > 3 ? ", ... (" + (items.size() - 3) + " more)" : "";
      return String.format("Cart[user=%s, items=[%s%s]]", user, preview, tail);
    }
  }

public static void main(String[] args) {
    User alice = new User(42, "alice", "super-secret-token");
    Cart cart  = new Cart(alice, List.of("book", "pen", "lamp", "mug", "hat"));

System.out.println(alice);  // User[id=42, name=alice]
    System.out.println(cart);   // Cart[user=User[id=42, name=alice], items=[book, pen, lamp, ... (2 more)]]

// Default Object.toString for comparison
    Object plain = new Object();
    System.out.println("default: " + plain);
  }
}

La suite

toString produit une description d'un objet. Le prochain chapitre porte sur la production d'une copie d'un objet — clone, Cloneable, et les choix de conception délicats autour des copies superficielles et profondes. Continuez avec le clonage d'objets Java.

Pratique

Laquelle de ces implémentations est le meilleur `toString` pour une classe `Point(int x, int y)` ?

`return "Point[x=" + x + ", y=" + y + "]";` — le nom de la classe suivi des valeurs des champs dans une forme lisible et facile à rechercher`return x + "" + y;` — chiffres concaténés`return super.toString();` — retour à la valeur par défaut`return null;` — silencieux et court