Summary of the difference between toString methods in Java

In Java programming, string operations are an indispensable part of developers' daily programming tasks. Especially when dealing with objects and basic data types, converting them to strings is a common requirement. Java provides a variety of ways to implement this transformation, the most common of which is()andtoString()method. This article will explore in-depth the usage, differences and applicable scenarios of these two methods.

()method

Method definition

()is a static method defined inin class. It is used to convert various types of data, including basic data types and objects, into strings. The method signature is as follows:

public static String valueOf(Object obj)

In addition, there are several overloaded methods for handling different basic data types:

public static String valueOf(boolean b)
public static String valueOf(char c)
public static String valueOf(int i)
public static String valueOf(long l)
public static String valueOf(float f)
public static String valueOf(double d)

Method implementation

(Object obj)The implementation logic is very simple. If the object passed in isnull, return the string "null"; otherwise, the object'stoString()method and return result. The following is its source code implementation:

public static String valueOf(Object obj) {
    return (obj == null) ? "null" : ();
}

For overloading methods for basic data types,()The corresponding wrapper class will be called directlytoString()method. For example:

public static String valueOf(int i) {
    return (i);
}

Example of usage

The following is()Example of usage of the method:

((123));        // Output: "123"((null));      // Output: "null"Object obj = new Object();
((obj));       // Output: () result

Use scenarios

()The main applicable scenarios of the method include:

• Need to be processed asnullAvoid the appearance ofNullPointerException。
• Converts the base data type to a string.
• It is desirable to handle string representations of various data types in a unified way.

toString() method

Method definition

toString()The method is defined inAn instance method in the class. All Java objects inherit this method. The method signature is as follows:

public String toString()

Method implementation

toString()The method defaults to return the fully qualified name of the class and the hash code of the object, in the format:getClass().getName() + "@" + (hashCode()). The following isObjectIn classtoString()The default implementation of the method:

public String toString() {
    return getClass().getName() + "@" + (hashCode());
}

However, most Java classes will override this method to provide a more meaningful string representation. For example,ArrayListClass rewrittentoString()Method, return the string representation of all elements in the list.

Example of usage

The following istoString()Example of usage of the method:

Object obj = new Object();
(());            // Output: The default string representation of the class, for example @1b6d3586
String str = "Hello, World!";
(());            // Output: "Hello, World!"

It is worth noting that if the object isnull, call()Will throwNullPointerException。

Use scenarios

toString()The main applicable scenarios of the method include:

• Want to get a custom string representation of the object.
• When debugging, you understand the state of the object by looking at the string representation of the object.
• Objects need to be converted to strings for logging or output to the console.

Key Difference

Although()andtoString()Methods can both convert objects into strings, but there are some key differences between them. The following table summarizes these differences:

In-depth discussion

Flexibility of ()

()An important advantage of this is its flexibility. Regardless of whether the incoming data type or object,()All can be processed correctly and return the corresponding string representation. For example:

((3.14));      // Output: "3.14"((true));      // Output: "true"(('c'));       // Output: "c"

This flexibility makes()It is especially convenient when processing mixed types of data. In addition, since()Can handle it safelynullvalue, so using it in development can reduce the causenullExceptions caused by values, thereby improving the robustness of the code.

Customization of toString()

although()The method is very useful in many scenarios, buttoString()The ability to customize the method makes it more advantageous in certain situations. Rewrite when we need the details of the object or want to represent the object in a specific formattoString()Methods are a common practice. For example, in entity classes we usually overridetoString()Methods to make it easier to view the properties of an object:

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
         = name;
         = age;
    }
    
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
    
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        (());   // Output: Person{name='Alice', age=30}    }

}

This customized string representation is not only very useful during debugging, but also can be used for logging and user interface display.

Comprehensive use

In actual development, we often need to use it in combination()andtoString()to play to their respective advantages. For example, in a logging system, we might use()To ensure that even if you encounter itnullValues ​​will not cause the program to crash, and use ittoString()Method to get the object's detailed information:

public class Logger {
    public static void log(Object message) {
        ((message));
    }

    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        log(person);   // Output: Person{name='Alice', age=30}        
        person = null;
        log(person);   // Output: "null"    }

}

Performance considerations

In terms of performance,()andtoString()Differences in methods are usually negligible. However, in applications with high performance requirements, choosing the right method is still worthy of attention. because()The object is called inside the methodtoString()method, so it is called directlytoString()can reduce the overhead of a method call. However, this overhead is insignificant in most applications.

Summarize

In Java,()andtoString()Each method has its own unique advantages and applicable scenarios.()Methods are flexible andnullKnown for safe handling of values, it is ideal for processing multiple types of data and avoidingNullPointerExceptionUsed in scenarios. andtoString()The method has more advantages in occasions where object details are needed due to its customizability and detailed object representation. Understanding and using both methods correctly can help developers write more robust and easier to maintain code.

This is the end of this article about the difference between () and toString() methods in Java. For more related contents of Java () and toString() methods, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!