nitpicking:
  Map<String, Double> m = new HashMap<String, Double>();

Try this:
    double value = ((Double)obj).doubleValue();

Double (with a capital D) is a wrapper class and double (lower case d)
is a primitive datatype. This casts the object as a Double then gets
the primitive datatype from that.

Good.  One improvement would be for your test to actually compile (i.e.
include necessary imports, and leave the duplicate working line commented out.
More importantly, if you're getting an error, TELL US what it is!  When I read
your post, I thought you were getting a compile error, and I couldn't see
why - you're allowed to cast an Object to a Double.

It turns out you're NOT getting a compile error, you're getting a runtime
error, and it is
 Exception in thread "main" java.lang.ClassCastException: java.lang.String
       at Foo.main(Foo.java:28)
This means you're trying to cast a String into a Double.  That won't work.

Casting is different than parsing.  Casting is just a way to tell one part of
the code that you, the developer, have more information about the type of the
object, and you want to try to use the object as if it were this more specific
type.  If it's NOT actually usable as that type, it'll get a
ClassCastException.

A String isn't a Double.  It's a String.  So the cast fails.

What you want is to parse the string, meaning to read it's characters and see
what double it represents.  You can do that by using the
Double.parseDouble(String) method.  It takes a string, so if you know the
object is a String, you can cast it.  That's your
 double value = Double.parseDouble((String)obj);
line (note that it's parseDouble(), not parse()).

If you don't know that, you can call toString() on it.
 double value = Double.parseDouble(obj.toString());

If you want a Double object rather than a double primitive value, you can use
 Double value = new Double((String)obj);

Of course, many Strings, and even more non-String objects, have string values
that can't be parsed, and you'll get a NumberFormatException.
--
Mark Rafn    dagon@dagon.net    <http://www.dagon.net/>

This loads the values as type String.

I'm not sure why you are copying a HashTable backed Properties object
into a new HashMap. Surely you could just use "states" where you later
use "map"?

Because obj is a String, you can't cast a String to a Double.

Because the compiler doesn't know the type of obj, you told the compiler
that obj was an Object, it doesn't know that obj will hold a String at
run-time.

Note that 5.999 is a String even if it doesn't look like it.

I'd rethink the approach to avoid all mention of type "Object".

e.g. one step along that path ...

public class PropertyDouble {
    public static void main(String[] args) throws FileNotFoundException,
            IOException {

        Properties states = new Properties();
        states.load(new FileInputStream("property_file.txt"));

        // copy entries from states file to the map
        Map<String, Double> map = new HashMap<String, Double>(10);
        for (Map.Entry entry : states.entrySet()) {
            String key = (String) entry.getKey();
            Double value = Double.parseDouble(
                    (String) entry.getValue());
            map.put(key, value);
        }

        double value = map.get("HAT_SIZE");

        System.out.println("Double : " + Double.toString(value));
    }
}