Because you are relying on autoboxing when you wrote

Object prova = 9.2;

If you want it to be a Float, try

Object prova = 9.2f;

Remember that java.lang.Float and java.lang.Double are sibling types; the common type is java.lang.Number

If you want to express a Number in whatever format, use the APIs, for example Number.floatValue()

Because you are relying on autoboxing when you wrote

Object prova = 9.2;

If you want it to be a Float, try

Object prova = 9.2f;

Remember that java.lang.Float and java.lang.Double are sibling types; the common type is java.lang.Number

If you want to express a Number in whatever format, use the APIs, for example Number.floatValue()

You can fix this by adding @specialized(Float) to the A: ClassTag type parameter.

Here's a slightly simplified version of your code with the added @specialized(Float) tag. (I also added @specialized(Int) to make the example more complete.)

import scala.reflect.ClassTag

class Test[@specialized(Float, Int) A: ClassTag] {
  def apply(count: Int): Array[A] = Array.tabulate(count) { 
    i => (1.5 + i).asInstanceOf[A];
  }
}

val floatTest = new Test[Float];
println(floatTest(5).mkString(", ")); // 1.5, 2.5, 3.5, 4.5, 5.5
// Works because code is specialized for float
// and primitive double is cast to primitive float.

val doubleTest = new Test[Double];
println(doubleTest(5).mkString(", ")); // 1.5, 2.5, 3.5, 4.5, 5.5
// Works although code is not specialized for double
// but Double object can be cast to Double object.

val intTest = new Test[Int];
println(intTest(5).mkString(", ")); // 1, 2, 3, 4, 5
// Works because code is specialized for int
// and primitive double is cast to primitive int.

val longTest = new Test[Long];
println(longTest(5).mkString(", ")); // ClassCastException
// Fails because code is not specialized for long
// and Double object cannot be cast to Long object.
// Works if you add @specialized(Long).

(The no-op cast from Double object to Double object is called identity conversion.)

You can also omit the list of types from @specialized. In this case, the class will be specialized for all primitive types:

class Test[@specialized A: ClassTag] {
...

Be aware though that this will generate a lot more class files. For example, if all Scala collection classes would be specialized for all primitive types, the Scala language library would suddenly become about ten times as large.

The root problem is this: The casting rules for boxed primitives are very different from the casting rules for unboxed primitives.

In this case (using Java syntax):

double d = 1.0 / 5.0; // 0.2 as a double primitive value
float f = (float)d; // 0.2f as a float primitive value

Works as expected. The cast from double to float is known as narrowing primitive conversion.

But this doesn't work:

java.lang.Double d = 1.0 / 5.0; // 0.2, but in a java.lang.Double object
java.lang.Float f = (java.lang.Float)d; // ClassCastException

No narrowing or widening conversion from java.lang.Double to java.lang.Float is possible because neither is a subclass of the other, and boxing and unboxing conversions are not applied either. More precisely, there is an implicit boxing conversion from double to java.lang.Double in the first line, but no implicit boxing or unboxing conversion is applied in the second line.

Scala makes the issue even more confusing because it tries to hide the distinction - Scala only has type Double, but no type double. Depending on context, the Scala type Double is sometimes (I think most of the time) mapped to the Java primitive type double and sometimes to the Java reference type java.lang.Double.

This would be a normal symptom for some corruption in how the Map from myService.calculateData was constructed in the first place; it's not really a Map<String, Float>, it's got Doubles in it. That's usually an indication that there were some suppressed unsafe casts or rawtypes.

The cast to Float would be implicitly inserted into the map.get("key1") call at compile time, as part of how generics are normally implemented.

If I'm not mistaken, 0.5 are decimal numbers; thus, making it a float value.

You should not rely solely on your intuition when learning a new programming language.

In fact, 0.5 is a double literal. For a float literal you need to write 0.5f.

As The Java Language Specification (JLS 3.10.2) states:

A floating-point literal is of type float if it is suffixed with an ASCII letter F or f; otherwise its type is double and it can optionally be suffixed with an ASCII letter D or d.

See also:

• The Oracle Java Tutorial > Primitive Data Types

Just cast your double to a float.

double d = getInfoValueNumeric();
float f = (float)d;

Also notice that the primitive types can NOT store an infinite set of numbers:

float range: from 1.40129846432481707e-45 to 3.40282346638528860e+38
double range: from 1.7e–308 to 1.7e+308

Well, your second statement is correct by Java's standards, but in your first example Java is probably trying to prevent you from converting doubles to floats due to a loss of precision that must be explicitly asked for by the programmer, as so:

double a = //some double;
float b = (float) a;  //b will lose some of a's precision

Use the doubleValue() function.

For example:

import javax.swing.JOptionPane;

public class Excercise613 {
    // Display the prompt to the user; wait for the user to enter a whole number; 
    // return it.  
    public static int askInt(String prompt) {    
        String s = JOptionPane.showInputDialog(prompt);
        Double d = Double.parseDouble(s);                     
        return d >= 0 ? (int) d.doubleValue() : (int) (d.doubleValue() - 1);
    } // End of method
} // End of class

Or you can remove the (int) casts and just call d.intValue(). For example: return d >= 0 ? d.intValue() : (d.intValue() - 1);

It would help if you provide a stacktrace.

Otherwise, the standard solution is to replace (Float) someLongValue with someLongValue.floatValue()

If you are dealing with primitive types, you can just cast from long to float, although it is a 5.1.2 Widening Primitive Conversion, but one that may lose precision, so be careful! Obviously you have the wrapper type Long, which cannot implicitly be converted, thus you get the classcastexception. This may be because of autoboxing, or explicit Long object creation.

Some more uninvited advice: if your valid values are decimals in the range of -10 to +10 the standard data type is int (primitive). avoid float if you mean exact numbers. long is also not optimal, because it is not fully atomic like int and it takes 2x the memory. If you allow a different state "not assigned" then Integer, which may take null, is also OK.

It turns out you have to declare it with an f suffix like so:

public Float myFloat = 20f;

You cannot cast directly from Double to Integer. You need to do the following:

Double d = new Double(1.23);
int i = d.intValue();

as suggested in How to convert Double to int directly?