toString Method in Java

Last Updated on December 27, 2023 by Ankit Kochar

In Java programming, the toString() method plays a fundamental role in converting an object into a string representation. This method is a part of the Object class and is overridden in most Java classes to provide meaningful information about the object’s state. The toString() method helps in debugging, logging, and displaying object details in a human-readable format. Understanding how to properly implement and utilize this method is crucial for Java developers to enhance code readability and debugging efficiency.

What is the toString Method in Java?

The toString method in Java is an in-built method that returns a string representation of an object. This method is defined in the Object class which is the root class for all Java classes, and most classes in Java override this method to provide a meaningful string representation of the object.

The toString method in Java is used for a variety of purposes, including debugging, logging, and displaying an object’s status. It is frequently used to collect information about an object and its current state.

By default, the toString method in Java returns a string that contains the class name, the "@" symbol, and the object’s hash code in hexadecimal format. This string representation is not always meaningful or useful for the programmer, and therefore the toString() method is often overridden to provide a more meaningful string representation of the object.

For example, consider a Person class with properties such as name, age, and address. By overriding the toString() method, we can obtain a string representation of the Person object that contains these properties, making it easier to obtain information about the object’s state.

Syntax for toString Method in Java

In Java, the toString() method is declared in the Object class, and it’s often overridden in custom classes to provide a meaningful string representation of the object’s state. Here’s the syntax for the toString() method:

public String toString() {
    // Define the string representation of the object
    // This could include various properties and values
    // Return a string representing the object
}

Explanation of the syntax:

• public: toString() method is usually declared as public to allow accessibility from outside the class.
• String: It specifies that the method returns a string.
• toString(): This is the method name.
• { }: Curly braces denote the body of the method where you define the custom logic to create the string representation of the object.
• // Define the string representation of the object: This is a comment to indicate where you will write the code to construct the string representation.
• Return: The return statement is used to return the string representation of the object.

Default Implementation of toString Method in Java

The default implementation of toString method in java returns a String consisting of the class name followed by an "@" sign and the hexadecimal representation of the object’s hash code.

Here’s an example of the default implementation of the toString method in Java:

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Main {
    public static void main(String [] args){
        Person person = new Person("PrepBuddy", 30);
        System.out.println(person.toString());
    }
}

Output:

Person@5caf905d

Explanation: In the above example, the default implementation of toString() returns the class name (Person) followed by an "@" sign and the hexadecimal representation of the object’s hash code (5caf905d).

How to Override the toString Method in Java?

In Java, you can provide a customized string representation of an object by overriding the toString() method. This is helpful when printing the contents of an object in a human-readable format or logging information about the item.

To override the toString() method, you need to add the method to your class and provide your own implementation. The toString method must return a String that represents the object.

Here’s an example of how to override the toString method in Java:

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Main {
    public static void main(String [] args){
        Person person = new Person("PrepBuddy", 25);
        System.out.println(person.toString());
    }
}

Output:

Person{name='PrepBuddy', age=25}

Explanation: In the above example, the toString() method now returns a string that includes the name and age of the person, which is much more useful than the default implementation which we discussed earlier.

Java Classes with Overridden toString() Method

In Java, not all classes have the toString() method overridden by default. However, some of the commonly used classes that have the toString() method overridden by default are:

Let’s look at some Java classes that have implemented the toString() method to provide a meaningful string representation of the objects.

In Java, the toString() method is overridden by all wrapper classes such as Byte, Integer, Long, Float, Double, Boolean, and Character. String, StringBuilder, and StringBuffer have also overridden the toString() method.

Let’s take an example to understand it more clearly

import java.util.*;

public class Main {

  public static void main(String[] args) {
    Integer integer = 25;
    String name = "PrepBuddy";

    List<String> students = new ArrayList<>();
    students.add("Himanshu");
    students.add("Ankit");
    students.add("Deepak");

    System.out.println(integer);
    System.out.println(name);
    System.out.println(students);
  }
}

Output:

25
PrepBuddy
[Himanshu, Ankit, Deepak]

Explanation: In the above example, there are two things that stand out. First, we did not use the toString() method to print the string value of objects because by default System.out.println() uses the toString() method internally. Second, we did not implement the toString() method, instead, java itself override it for us.

Advantages of Using toString Method in Java

The toString method in Java has several advantages:

• The toString method in Java provides a human-readable representation of an object. This is useful when we need to log or print the contents of an object.
• The toString() method is often used to help in debugging. By providing a customized string representation of an object, you can quickly identify the state of the object and any potential issues.
• The toString method in Java is simple to implement and requires only a few lines of code.
• Many Java APIs, such as logging frameworks and serialization, rely on the toString() method to provide a string representation of an object. By implementing toString() method, your code can interact more easily with these APIs.
• By providing a customized string representation of an object, the code becomes more readable and easier to understand for other developers.

Conclusion
In conclusion, the toString() method in Java is a powerful tool that allows developers to obtain a string representation of an object’s state. Its flexibility enables customization, providing concise and meaningful information for debugging purposes. Overriding this method in custom classes aids in improving code readability and simplifies the debugging process by offering a clear snapshot of an object’s properties. Mastery of the toString() method is essential for Java developers to enhance code maintainability and facilitate efficient debugging.

FAQs (Frequently Asked Questions) Related to toString Method in Java

Here are some frequently asked questions related to the toString method in java.

1. What is the purpose of the toString() method in Java?
The toString() method in Java is used to obtain a string representation of an object. It is overridden in classes to provide meaningful information about the object’s state, aiding in debugging and logging.

2. How is the toString() method implemented?
To implement the toString() method, you override it within your custom class. Within the method, you define the format in which you want to represent the object’s state as a string.

3. Why should I override the toString() method?
By overriding toString(), you can provide a customized string representation of your objects, making it easier to understand their state and aiding in debugging. It improves code readability and helps in identifying object properties quickly.

4. Can the toString() method be called explicitly?
Yes, you can call the toString() method explicitly on an object to get its string representation. For example: String representation = myObject.toString();

5. What happens if I don’t override the toString() method in my class?
If you don’t override toString() in your class, it will inherit the default implementation from the Object class, which returns a string containing the class name along with the object’s hash code.

6. Is it necessary to use toString() for every class I create?
While it’s not mandatory, implementing toString() for custom classes is considered good practice as it greatly aids in debugging and provides a standardized way to represent object state as a string.