Get Original Object

[Cecil Phillip]

If I have a class
public class Node {
private Object val;
public Object getObj() {
return this.val;
}

//Below will be the other accesor methods
.........
}
now if I have a list of Node , all with diferent objects in them, lets say a new Float() object, new Integer() Object, and a new String() Object. How can I call toString on these Objects to return the original values instead of the hasg code values, cause that is what happens when i do a
x.getObj().toString()

[Randall Twede]

you need to cast it to String or Float or whatever. not sure if you can do it in one statement. this should work though.
private String y;
y = (String)x.getObj();
y.toString();

if you don't know the object type, there is a way to find out what it is but i forget how. someone else will know though.
[ January 19, 2004: Message edited by: Randall Twede ]
[ January 19, 2004: Message edited by: Randall Twede ]

[John Smith]

How can I call toString on these Objects to return the original values instead of the hasg code values
There is no magic in the toString() method, -- it will do exacltly what you will tell it to do. If you don't tell anything, the toString() method of the parent class will be invoked. If the parent class happens to be Object, you will get back the name of the class, plus @, plus the hexadecimal representation of the object hash code. To get something more meningful, simply override the toString() method of your object to return the textual representation of your object as you see fit.

[Randall Twede]

Eugene,
he doesnt want to do toString() on the Node object, rather on its member variable named val.

[John Smith]

RT: he doesnt want to do toString() on the Node object, rather on its member variable named val.
Ok, but that variable is an object, not a primitive. Therefore the toString() method can be overrriden and called to return a custom-defined textual representation. For example:

package topcoder;
public class Node {
    private Object val;
    public Object getObj() {
        return this.val;
    }
    Node(NodeValue val) {
        this.val = val;
    }
}
class NodeValue {
    private int x;
    private int y;
    NodeValue(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public String toString() {
        String s = "Node value: x = " + x + " y = " + y;
        return s;
    }
}

[Randall Twede]

i think what you are looking for is called Run-time Type Identification and is covered in chapter 12 of bruce eckel's free online book "Thinking in java" at least it was in the 2nd edition
if(x instanceof Float)
((Float)x).toString();
[ January 19, 2004: Message edited by: Randall Twede ]

[Randall Twede]

iwont post the entire chapter, but maybe this will be helpful:

A dynamic instanceof
The Class isInstance method provides a way to dynamically call the instanceof operator. Thus, all those tedious instanceof statements can be removed in the PetCount example:

//: c12 :-P	 etCount3.java
// Using isInstance().
import java.util.*;
public class PetCount3 {
  public static void main(String[] args) 
  throws Exception {
    ArrayList pets = new ArrayList();
    Class[] petTypes = {
      Pet.class,
      Dog.class,
      Pug.class,
      Cat.class,
      Rodent.class,
      Gerbil.class,
      Hamster.class,
    };
    try {
      for(int i = 0; i < 15; i++) {
        // Offset by one to eliminate Pet.class:
        int rnd = 1 + (int)(
          Math.random() * (petTypes.length - 1));
        pets.add(
          petTypes[rnd].newInstance());
      }
    } catch(InstantiationException e) {
      System.err.println("Cannot instantiate");
      throw e;
    } catch(IllegalAccessException e) {
      System.err.println("Cannot access");
      throw e;
    }
    HashMap h = new HashMap();
    for(int i = 0; i < petTypes.length; i++)
      h.put(petTypes[i].toString(),
        new Counter());
    for(int i = 0; i < pets.size(); i++) {
      Object o = pets.get(i);
      // Using isInstance to eliminate individual
      // instanceof expressions:
      for (int j = 0; j < petTypes.length; ++j)
        if (petTypes[j].isInstance(o)) {
          String key = petTypes[j].toString();
          ((Counter)h.get(key)).i++;
        }
    }
    for(int i = 0; i < pets.size(); i++)
      System.out.println(pets.get(i).getClass());
    Iterator keys = h.keySet().iterator();
    while(keys.hasNext()) {
      String nm = (String)keys.next();
      Counter cnt = (Counter)h.get(nm);
      System.out.println(
        nm.substring(nm.lastIndexOf('.') + 1) + 
        " quantity: " + cnt.i);
    }
  }
} ///:~
You can see that the isInstance( ) method has eliminated the need for the instanceof expressions. In addition, this means that you can add new types of pets simply by changing the petTypes array; the rest of the program does not need modification (as it did when using the instanceof expressions).