Can anybody explain to me the concept of the toString() method, defined in the Object class? How is it used, and what is its purpose?
From the Object.toString docs:
Returns a string representation of the
object. In general, the toString
method returns a string that
"textually represents" this object.
The result should be a concise but
informative representation that is
easy for a person to read. It is
recommended that all subclasses
override this method.
The toString method for class Object
returns a string consisting of the
name of the class of which the object
is an instance, the at-sign character
`#', and the unsigned hexadecimal
representation of the hash code of the
object. In other words, this method
returns a string equal to the value
of:
getClass().getName() + '#' + Integer.toHexString(hashCode())
Example:
String[] mystr ={"a","b","c"};
System.out.println("mystr.toString: " + mystr.toString());
output:- mystr.toString: [Ljava.lang.String;#13aaa14a
Use of the String.toString:
Whenever you require to explore the constructor called value in the String form, you can simply use String.toString...
for an example...
package pack1;
import java.util.*;
class Bank {
String n;
String add;
int an;
int bal;
int dep;
public Bank(String n, String add, int an, int bal) {
this.add = add;
this.bal = bal;
this.an = an;
this.n = n;
}
public String toString() {
return "Name of the customer.:" + this.n + ",, "
+ "Address of the customer.:" + this.add + ",, " + "A/c no..:"
+ this.an + ",, " + "Balance in A/c..:" + this.bal;
}
}
public class Demo2 {
public static void main(String[] args) {
List<Bank> l = new LinkedList<Bank>();
Bank b1 = new Bank("naseem1", "Darbhanga,bihar", 123, 1000);
Bank b2 = new Bank("naseem2", "patna,bihar", 124, 1500);
Bank b3 = new Bank("naseem3", "madhubani,bihar", 125, 1600);
Bank b4 = new Bank("naseem4", "samastipur,bihar", 126, 1700);
Bank b5 = new Bank("naseem5", "muzafferpur,bihar", 127, 1800);
l.add(b1);
l.add(b2);
l.add(b3);
l.add(b4);
l.add(b5);
Iterator<Bank> i = l.iterator();
while (i.hasNext()) {
System.out.println(i.next());
}
}
}
... copy this program into your Eclipse, and run it... you will get the ideas about String.toString...
The toString() method returns a textual representation of an object. A basic implementation is already included in java.lang.Object and so because all objects inherit from java.lang.Object it is guaranteed that every object in Java has this method.
Overriding the method is always a good idea, especially when it comes to debugging, because debuggers often show objects by the result of the toString() method. So use a meaningful implementation but use it for technical purposes. The application logic should use getters:
public class Contact {
private String firstName;
private String lastName;
public Contact (String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public String getFirstName() {return firstName;}
public String getLastName() {return lastName;}
public String getContact() {
return firstName + " " + lastName;
}
#Override
public String toString() {
return "["+getContact()+"]";
}
}
It may optionally have uses within the context of an application but far more often it is used for debugging purposes. For example, when you hit a breakpoint in an IDE, it's far easier to read a meaningful toString() of objects than it is to inspect their members.
There is no set requirement for what a toString() method should do. By convention, most often it will tell you the name of the class and the value of pertinent data members. More often than not, toString() methods are auto-generated in IDEs.
Relying on particular output from a toString() method or parsing it within a program is a bad idea. Whatever you do, don't go down that route.
toString() returns a string/textual representation of the object.
Commonly used for diagnostic purposes like debugging, logging etc., the toString() method is used to read meaningful details about the object.
It is automatically invoked when the object is passed to println, print, printf, String.format(), assert or the string concatenation operator.
The default implementation of toString() in class Object returns a string consisting of the class name of this object followed by # sign and the unsigned hexadecimal representation of the hash code of this object using the following logic,
getClass().getName() + "#" + Integer.toHexString(hashCode())
For example, the following
public final class Coordinates {
private final double x;
private final double y;
public Coordinates(double x, double y) {
this.x = x;
this.y = y;
}
public static void main(String[] args) {
Coordinates coordinates = new Coordinates(1, 2);
System.out.println("Bourne's current location - " + coordinates);
}
}
prints
Bourne's current location - Coordinates#addbf1 //concise, but not really useful to the reader
Now, overriding toString() in the Coordinates class as below,
#Override
public String toString() {
return "(" + x + ", " + y + ")";
}
results in
Bourne's current location - (1.0, 2.0) //concise and informative
The usefulness of overriding toString() becomes even more when the method is invoked on collections containing references to these objects. For example, the following
public static void main(String[] args) {
Coordinates bourneLocation = new Coordinates(90, 0);
Coordinates bondLocation = new Coordinates(45, 90);
Map<String, Coordinates> locations = new HashMap<String, Coordinates>();
locations.put("Jason Bourne", bourneLocation);
locations.put("James Bond", bondLocation);
System.out.println(locations);
}
prints
{James Bond=(45.0, 90.0), Jason Bourne=(90.0, 0.0)}
instead of this,
{James Bond=Coordinates#addbf1, Jason Bourne=Coordinates#42e816}
Few implementation pointers,
You should almost always override the toString() method. One of the cases where the override wouldn't be required is utility classes that group static utility methods, in the manner of java.util.Math. The case of override being not required is pretty intuitive; almost always you would know.
The string returned should be concise and informative, ideally self-explanatory.
At least, the fields used to establish equivalence between two different objects i.e. the fields used in the equals() method implementation should be spit out by the toString() method.
Provide accessors/getters for all of the instance fields that are contained in the string returned. For example, in the Coordinates class,
public double getX() {
return x;
}
public double getY() {
return y;
}
A comprehensive coverage of the toString() method is in Item 10 of the book, Effective Java™, Second Edition, By Josh Bloch.
Whenever you access an Object (not being a String) in a String context then the toString() is called under the covers by the compiler.
This is why
Map map = new HashMap();
System.out.println("map=" + map);
works, and by overriding the standard toString() from Object in your own classes, you can make your objects useful in String contexts too.
(and consider it a black box! Never, ever use the contents for anything else than presenting to a human)
Correctly overridden toString method can help in logging and debugging of Java.
Coding:
public class Test {
public static void main(String args[]) {
ArrayList<Student> a = new ArrayList<Student>();
a.add(new Student("Steve", 12, "Daniel"));
a.add(new Student("Sachin", 10, "Tendulkar"));
System.out.println(a);
display(a);
}
static void display(ArrayList<Student> stu) {
stu.add(new Student("Yuvi", 12, "Bhajji"));
System.out.println(stu);
}
}
Student.java:
public class Student {
public String name;
public int id;
public String email;
Student() {
}
Student(String name, int id, String email) {
this.name = name;
this.id = id;
this.email = email;
}
public String toString(){ //using these toString to avoid the output like this [com.steve.test.Student#6e1408, com.steve.test.Student#e53108]
return name+" "+id+" "+email;
}
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
public int getId(){
return id;
}
public void setId(int id){
this.id=id;
}
public String getEmail(){
return email;
}
public void setEmail(String email){
this.email=email;
}
}
Output:
[Steve 12 Daniel, Sachin 10 Tendulkar]
[Steve 12 Daniel, Sachin 10 Tendulkar, Yuvi 12 Bhajji]
If you are not used toString() in Pojo(Student.java) class,you will get an output like [com.steve.test.Student#6e1408, com.steve.test.Student#e53108].To avoid these kind of issue we are using toString() method.
Apart from what cletus answered with regards to debugging, it is used whenever you output an object, like when you use
System.out.println(myObject);
or
System.out.println("text " + myObject);
The main purpose of toString is to generate a String representation of an object, means the return value is always a String. In most cases this simply is the object's class and package name, but on some cases like StringBuilder you will got actually a String-text.
/**
* This toString-Method works for every Class, where you want to display all the fields and its values
*/
public String toString() {
StringBuffer sb = new StringBuffer();
Field[] fields = getClass().getDeclaredFields(); //Get all fields incl. private ones
for (Field field : fields){
try {
field.setAccessible(true);
String key=field.getName();
String value;
try{
value = (String) field.get(this);
} catch (ClassCastException e){
value="";
}
sb.append(key).append(": ").append(value).append("\n");
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
return sb.toString();
}
If you learn Python first and then Java. I think it plays the same role as __str__() method in Python, it is a magic method like __dict__() and __init__() but to refer to a string representing the the object.
the toString() converts the specified object to a string value.
I'm trying to do a school project in which I'm writing an application that deals with books, collections of books (we’ll call that a library), and the UI client for those classes.
One of the classes is a class called Citable that requires the implementation of typical accessor features that return a book’s ISBN, Author, Title, and Publisher (all strings) as well as the Publication Year, Month, and Day (all integers) and a Page Count (an integer).
The next class a Book class that implements the Citable interface. Library will need to sort books by their ISBN numbers, so in Book you’ll need to provide support for that as well (hint: this requires the implementation of an additional interface (one you don’t have to write, just implement) and the writing of an additional method (which should only need one line of code), and that Library make a simple call to make the sort happen). There are no statics here (except for the test method), and no UI whatsoever. I'll show you what I've did so far:
public interface Citable
{
public String getISBN();
public String getAuthor();
public String getTitle();
public String getPublisher();
public int getPublicationYear();
public int getMonth();
public int getDay();
public int getPageCount();
}
and the book interface:
import java.util.*;
public abstract class Book implements Citable, Comparable
{
/**
* Constructor for objects of class Book
*/
public Book()
{
Collections.sort(ISBN);
}
public String toString (){
String info = ISBN + "\n" + title + "\n" + author + "\n" + publisher +
"\n" + publicationYear + "\n" + month + "\n" + day;
return info;
}
}
In the Book class, I'm implementing both the interface I've made and Java's built-in Comparable. My question is this: In the Book class, I was getting the error: Book is not abstract and does not override abstract method getPageCount in Citable. The only way I could stop the error was to make the Book class abstract. However, I'm getting no indication that I should make that class abstract. Is there a way out of this?
Your class Book implements two interfaces, namely Citable and Comparable. That means you have to implement the methods from these interfaces in your class. The only other way would be to make the class Book abstract, meaning you can't instantiate it. But that is definitely not what you want.
Your class Book would look something like this:
public class Book implements Citable, Comparable
{
/**
* Constructor for objects of class Book
*/
public Book()
{
Collections.sort(ISBN);
}
public String toString (){
String info = ISBN + "\n" + title + "\n" + author + "\n" + publisher +
"\n" + publicationYear + "\n" + month + "\n" + day;
return info;
}
#Override
public int compareTo(Object o) {
//Implement this method
}
#Override
public String getISBN() {
return isbn;
}
//other methods from your interfaces here...
}
As far as I understood from your solution strategy is creating an interface for the method contract and implementing this interface in your class.
In order to that firstly let me remind that, once you implement an interface you need to implement all of its abstract methods. The error is related with it. Thus, there are two options, First, you can implement Citable methods in Book class. Second, you can write these methods as default in Citable interface and just use them on Book class.
I have shared a sample code with some comments please check them
Sample Code:
import java.util.Collections;
public class Book implements Citable, Comparable
{
/**
* Constructor for objects of class Book
*/
public Book()
{
Collections.sort(getISBN());//there is no sort method for Strings, sort method is only for lists
}
public String toString (){
String info = getISBN() + "\n" + title + "\n" + author + "\n" + publisher +
"\n" + publicationYear + "\n" + month + "\n" + day;//You need to use getter methods
return info;
}
#Override
public int compareTo(Object o) {
// TODO Auto-generated method stub
return 0;
}
#Override
public String getISBN() {
// TODO Auto-generated method stub
return null;
}
#Override
public String getAuthor() {
// TODO Auto-generated method stub
return null;
}
#Override
public String getTitle() {
// TODO Auto-generated method stub
return null;
}
#Override
public String getPublisher() {
// TODO Auto-generated method stub
return null;
}
#Override
public int getPublicationYear() {
// TODO Auto-generated method stub
return 0;
}
#Override
public int getMonth() {
// TODO Auto-generated method stub
return 0;
}
#Override
public int getDay() {
// TODO Auto-generated method stub
return 0;
}
#Override
public int getPageCount() {
// TODO Auto-generated method stub
return 0;
}
}
I don't know why this is not working, what am I writing wrong?
public class Testmain {
/**
* #param args
*/
public static void main(String[] args) {
Wat n1=new This("john","man");
System.out.println(((This)n1).toString());
// TODO Auto-generated method stub
}
}
Why am I getting this as an output :
This#68e26d2e
What I should get as an output is this :
John man
And yes I know the class names are random. So I wrote toString() method in the class "This", but it's still not working. I have a field firstname in the superclass and field gender in the subclass, but now in the output I'm not getting the gender, only firstname.
You must override method
#Override
public String toString() {
return "Name: " + name + " \n Gender:" + gender;
}
name, gender it's you private members which you set in the constructor.
This#68e26d2e is just the hexadecimal representation of the memory address of your This class. Every object will have this by default. To have your own String representation, you must override the toString() method.
#Override
public String toString() {
return < your String here >;
}
override the toString() method in This
ex:
#Override
public String toString() {
return "whatever you want";
}
I use a method
public String introduce()
{
return super.introduce();
}
which returns the value from introduce() method of super class. And assume introduce() method returns
Hey! I'm Steve and I'm 26 years old
In the same class,I also have another method
public String getAlter() {
return alter;
}
Now alter contains the value:
Jobs
Now, the question is how do I return the value
Hey! I'm Steve and I'm 26 years old. I'm also known as Jobs!
from the overridden method, ie
public String introduce()
{
return super.introduce();
}
Just concatinate the strings returned by the two methods:
#Override
public String introduce() {
return super.introduce() + ". I'm also known as " + getAlter() + "!";
}
You have to override the method introduce:
1) call the super class method introduce() -> returns "Hey! I'm Steve and I'm 26 years old"
2) use method getAlter() inside the overridden method introduce()"
public String getAlter() {
return "Jobs";
}
#Override
public String introduce() {
String msg = super.introduce();
String name = this.getAlter();
msg = msg + ". I'm also known as " + name + "!";
return msg;
}
public static void main(String[] args) {
Jobs jobs = new Jobs();
String msg = jobs.introduce();
System.out.println(msg);
}
public String introduce()
{
return super.introduce()+" I'm also known as "+getAlter();
}
You can use the result of super.introduce() to build your final result.
#Override
public String introduce() {
return super.introduce() + ". I'm also known as " + getAlter() + "!";
}
Note the #Override annotation to make it clear that I am hiding the super implementation.
Don't immediately return your call to super:
public String introduce()
{
return super.introduce() + getAlter();
// for clarity, you are essentially performing these operations:
// String response = super.introduce();
// response = response + " I'm also known as ";
// response = response + getAlter();
// return response;
}
Simple way is to append them like:
#Override
public String introduce() {
StringBuilder strBuilder = new StringBuilder();
strBuilder.append(super.introduce());
strBuilder.append(" I'm also known as");
strBuilder.append(getAlter());
return strBuilder.toString();
}
Hope this help!
I'm iterating over a ResultSet and save it to a ArrayList.
weatherData = Arrays.asList (
new WeatherInfo(rs.getDate(1), rs.getInt(2)...
When I do a System.out.println(weatherData); I see this in the Eclipse Console:
[com.example.project.view.ChartsData$WeatherInfo#66ee6cea, com.example.project.view.ChartsData$WeatherInfo#757d0531.....
What does it mean? Is it a value I can handle in Java or not?
Is this the actual date and int that I can use in Java?
thanks
You need to override toString() method in WeatherInfo class. What you see is its default implementation that presents its memory location.
This is a typical model object in Java with a toString() method. I used Intellij Idea (recommended!) which has the ability to auto-generate toString() and other methods such as equals() and hashCode(). We find that having these methods on all model objects is very useful for debugging and testing.
Running main() will output:
weatherInfo = WeatherInfo{country='CA', probablyOfPrecipitation=20}
public class WeatherInfo {
public static void main(String [] args) {
WeatherInfo weatherInfo = new WeatherInfo();
weatherInfo.setCountry("CA");
weatherInfo.setProbablyOfPrecipitation(20);
System.out.println("weatherInfo = " + weatherInfo);
}
String country;
int probablyOfPrecipitation;
public String getCountry() {
return country;
}
public void setCountry(String country) {
this.country = country;
}
public int getProbablyOfPrecipitation() {
return probablyOfPrecipitation;
}
public void setProbablyOfPrecipitation(int probablyOfPrecipitation) {
this.probablyOfPrecipitation = probablyOfPrecipitation;
}
#Override
public String toString() {
return "WeatherInfo{" +
"country='" + country + '\'' +
", probablyOfPrecipitation=" + probablyOfPrecipitation +
'}';
}
}
Top Tip!
We use a library called EqualsVerifier to guarantee that all equals() and hashCode() implementations are correct.