At the moment I have an array of
public Module[]moduleArray = new Module[4];
and to output it i'm using
public void displayModules()
{
for (int i = 0; i < moduleArray.length; i++)
{
System.out.println(moduleArray[i]);
}
}
However it's outputting
Module#1f5e4ae5
Module#67871079
null
null
Implement / override toString() in the Module class. When you see the Module#xyz String representation it is because the only implementation of toString() for the Module class is the Object class's implementation. Since Object doesn't know anything about Module it just outputs the class name and an instance id.
The class Module needs a meaningful toString() method. What you're seeing is the output of the default Object.toString() method. For example, if Module had String properties name and type you could have a toString method like:
#Override
public String toString()
{
return "Module named: " + name + " of type: " + type;
}
You would then see the String returned above instead of the output of the default toString method.
Overriding toString() method in array's content class, in your example Module class, will help you to print every value from array while iterating array.
There is quick way to print arrays content without iterating over array elements, convert array to list using Arrays.asList() utility method.
System.out.println("Convert Array to List " + Arrays.asList(moduleArray));
Related
I am a bit confused about the StringBuilder. It seems that when I print a StringBuilder, there it no need to add .toString() because it will automatically give me a string representation. However, when I return a StringBuilder object, I have to add the .toString(). Is that true? and why?
Also, I am bit confused about the following code:
package com.tutorialspoint;
import java.lang.*;
public class StringBuilderDemo {
public static void main(String[] args) {
StringBuilder str = new StringBuilder("India ");
System.out.println("string = " + str);
// append character to the StringBuilder
str.append('!');
// convert to string object and print it
System.out.println("After append = " + str.toString());
str = new StringBuilder("Hi ");
System.out.println("string = " + str);
// append integer to the StringBuilder
str.append(123);
// convert to string object and print it
System.out.println("After append = " + str.toString());
}
}
For the different println, sometimes this code use toString and some other times it didn't. Why? I tried deleting the toString and the results are the same. Is it still necessary to use toString in println?
Thanks so much for helping a newbie out!
When you print an object to a print stream, the String representation of that object will be printed, hence toString is invoked.
Some classes override Object#toString, amongst which StringBuilder does.
Hence explicitly invoking toString for StringBuilder is unnecessary.
On the other hand, other objects don't override toString. For instance, arrays.
When you print an array, unless using a utility such as Arrays.toString, you're getting the array's class type # its hash code, as opposed to a human-readable representation of its contents.
From the documentation:
Note that println() prints a string builder, as in:
System.out.println(sb);
because sb.toString() is called implicitly, as it is with any other object in a println() invocation.
If you try to append an object to a string like this : "string = " + str, the toString() method is implicitly called.
So no, it does not matter, if you specify it.
Also the toString() method itself (even when you are not append it to string) calls the toString() method.
Therefore System.out.println(str) and System.out.println(str.toString()) gives same result.
The first thing you should know about Java is that we work with objects and that all objects inherit methods from the class Object: http://docs.oracle.com/javase/7/docs/api/java/lang/Object.html
This class has a toString() method and since every object inherits this method it can always be called on every object. When you do not override it, it usually returns the physical address of the object.
Like stated in other answers, whenever a string is expected in println for instance and you pass an object it automatically calls the method which requires an Object (note the capital, we are talking about the class Object here), it will then use the toString method on the object passed along as parameter. The reason you get the string you want is because StringBuilder overrides the toString() method for you.
When you in your own code want to pass the string in your StringBuilder you have two options. You can either pass StringBuilder.toString() or change the return type to Object or StringBuilder and call toString() when you actually need it.
Hope this clarifies why you can just pass the object instead of the string.
When we do:
String string = new String("Ralph");
//This creates a reference called string that points to a sequence of
//characters in memory
This is the same as:
String string = "Ralph";
When we print both, we get the actual value of the string.
If we print any other object in Java, we get an address for that object.
My question is, is there any dereferencing that is taking place behind the scenes?
When you pass an object reference to the System.out.println() method, for
example, the object's toString() method is called, and the returned value of toString() is shown in the following example:
public class HardToRead {
public static void main (String [] args) {
HardToRead h = new HardToRead();
System.out.println(h);
}
}
Running the HardToRead class gives us the lovely and meaningful,
% java HardToRead
HardToRead#a47e0
Now,
Trying to read this output might motivate you to override the toString()
method in your classes, for example,
public class BobTest {
public static void main (String[] args) {
Bob f = new Bob("GoBobGo", 19);
System.out.println(f);
}
}
class Bob {
int shoeSize;
String nickName;
Bob(String nickName, int shoeSize) {
this.shoeSize = shoeSize;
this.nickName = nickName;
}
public String toString() {
return ("I am a Bob, but you can call me " + nickName +". My shoe size is " + shoeSize);
}
}
This ought to be a bit more readable:
% java BobTest
I am a Bob, but you can call me GoBobGo. My shoe size is 19
The class String is a special class in Java.
But it gets out printed the same way every other class does.
If we call System.out.println("Ralph") the function println takes that String and then displays it.
The class Objects toString() method is implemented, so it displays the hash code of the Object, by calling the hashCode() function. If you overwrite the toString() method, it will display something else.
If you take any object other than a String and give it to a method that takes a String (or in fact cast it to a String) java will call the toString()method of that Object, to convert it to a String.
So 'printing' always does the same thing, it's just implemented in different ways, using the toString() method.
new String("Ralph") copies the character data array of the literal string and stores it in the new String instance.
However, you only get the address of an object when you print it because printing uses the toString() method of that object. If that method is not implemented, the default implementation defined in Object is used, which returns the class name plus the hash code (that seems like an address if hashCode() is not implemented).
I believe the primary types are printed with auto dereferencingString, int, float, etc., while the objects other than primary types, only with de-referencing function object.toString() that are implemented on the object level.
{
List list= new ArrayList();
list.add("one");
list.add("second");
System.out.println(list);
}
How can the object "list" be used like it has been in the print statement? Don't we need to use the object to access a method to print the list?
prinln(someObject) will print out whatever is implemented in someObject's toString() method.
You can use toString() which is (supposed) to be implemented for all objects:
System.out.println(list.toString())
Note that you ought not to use the returned string as anything you can actually parse; it's really for a visual representation. It also doesn't need to uniquely represent the object.
When you write
System.out.println(list)
you are, in fact, using the toString() method implicitly.
Docs Says about toString() in Collections:
Returns a string representation of this collection. The string representation consists of a list of the collection's elements in the order they are returned by its iterator, enclosed in square brackets ("[]"). Adjacent elements are separated by the characters ", " (comma and space). Elements are converted to strings as by String.valueOf(Object).
When we pass any object to println() method, it will implicitly call that object's toString() method. So, what is actually executed is
System.out.println( list.toString() );
ArrayList is inherited from the class java.util.AbstractCollection and that class has toString() method. So, in your case, that toString() should be executed.
That toString() method returns a string representation of this collection. The string representation consists of a list of the collection's elements in the order they are returned by its iterator, enclosed in square brackets ("[]"). Adjacent elements are separated by the characters ", " (comma and space). Elements are converted to strings as by String.valueOf(Object).
Looking at your question and comments, I think your confusion ultimately stems from you being unsure how printing works. In general in such cases, I recommend to get the JDK sources and simply take look inside.
In this case, we would first go to the System class and check out the out member (because println is called on System.out):
public final class System {
...
public final static PrintStream out = null;
Since we know now that out is a PrintStream, let's check out that class:
public class PrintStream extends FilterOutputStream
implements Appendable, Closeable
{
...
public void println(Object x) {
String s = String.valueOf(x);
synchronized (this) {
print(s);
newLine();
}
}
(we know it's calling this method, since the other println signatures don't match the type List)
OK, so we see that println converts the given Object (your List in this case) to a String using String.valueOf(Object). Let's check out that method:
public final class String {
...
public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
}
So now we know that your List's toString() method is used to generate the output. As others have pointed out, it is overriden in ArrayList to provide the output you see.
It can be used like this because class List inherits the Object class, and the Object class has the toString() method, which means every object can be turned into a String.
printing a list directly will give the the string representation of the list.
If you want to access the objects in the list you need to use iterator or loops or advanced for loops for collections.
e.g.
for(String s : list){
System.out.println(s);
}
Well you can study and try out all the list methods to modify it. e.g. add, remove.
Also if you are printing an object, then toString() method is implicitly called.
You can loop through all the items in the list in order to print them out. you can do this using a while loop of a for loop.
while (list.hasNext) {
System.out.println((String) list.next());
}
for(String i in list){
System.out.println(i) ;
}
Not sure if this is what your looking for but its an option.
Yo need toString() method. when you print object Reference , by default toString() method is called. If you look at toString() method by default it prints
getClass().getName() + '#' + Integer.toHexString(hashCode())
Now as per your requirements you can override this to print the values in list(String Class overrides it too)
Here you are creating List interface.So it will allow to add duplicate values in list also.Also we can directly print object like System.out.println(obj);
And inside the List class the, toString method is being overridden so that it will print all its contents rather than the address of the object.
System.out.println(Arrays.toString(myList.toArray()));
I want to know what exactly the output is when I do the following.
class Data {
int a = 5;
}
class Main {
public static void main(String[] args) {
data dObj = new data();
System.out.println(dObj);
}
}
I know it gives something related to object as the output in my case is data#1ae73783. I guess the 1ae73783 is a hex number. I also did some work around and printed
System.out.println(dObj.hashCode());
I got the number 415360643. I got an integer value. I don't know what hashCode() returns, still out of curiosity, when I converted 1ae73783 to decimal, I got 415360643!
That's why I am curious about what exactly is this number. Is this some memory location of Java's sandbox or some other thing?
What happens is that the default toString() method of your class is getting used. This method is defined as follows:
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())
The value returned by the default hashCode() method is implementation-specific:
As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects. (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the JavaTM programming language.)
When you print an instance of your class, that does not override the toString method, then the toString method of Object class is used. Which prints an output in the form: -
data#1ae73783
The first part of that output shows the type of the object.
And the 2nd part is the hexadecimal representation of the hashCode
of your object.
Here's the source code of Object.toString() method, that you can find in the installation directory of your jdk, under src folder: -
public String toString() {
return getClass().getName() + "#" + Integer.toHexString(hashCode());
}
The Javadoc for hashCode() and toString() in the Object class should be able to clarify this for you.
That code calls the default toString() implementation of the Object class, that is:
public String toString() {
return getClass().getName() + "#" + Integer.toHexString(hashCode());
}
I have a varargs constructor like this :
public class Sentence {
public String[] str;
public Sentence(Object... text){
StringBuilder sb = new StringBuilder();
for (Object o : text) {
sb.append(o.toString())
.append(" ");
}
System.out.println(sb.toString());
}
}
The class can can accept various types of data via this constructor (ints, strings, and Sentence objects as well). How do I create a proper toString method for such a class?
Not sure exactly what you're trying to achieve, but as the toString() method...
Returns a string representation of the
object
...I guess I would store the result of your sb.toString() call as a member String variable (say private String asString), and return that in a toString() method overriding the method in Object:
public String toString() {
return this.asString;
}
You can't print Sentence in toString because you can get infinite loop if you initialize 2 Senence objects by each other.
So, print all strings and objects and if it's possible some data from Sentence object, or only "1 sentence object" to point that it's also passed as an init param.