I have question about primitive types in Java (int, double, long, etc).
Question one:
Is there a way in Java to have a datatype, lets say XType (Lossless type) that can hold any of the primitive types?
Example of hypothetical usage:
int x = 10;
double y = 9.5;
XType newTypeX = x;
XType newTypeY = y;
int m = newTypeX;
Question two:
Is there away to tell from the bits if this number (primitive type) is an integer, or a double, or a float, etc?
You can use the Number class, which is the super class for all numeric primitive wrapper classes, in your first snippet:
int x = 10;
double y = 9.5;
Number newTypeX = x;
Number newTypeY = y;
The conversion between the primitive types (int, double) and the object type (Number) is possible through a feature called autoboxing. However, this line won't compile:
int m = newTypeX;
because you cannot assign the super type variable into an int. The compiler doesn't know the exact type of newTypeX here (even if it was assigned with an int value earlier); for all it cares, the variable could as well be a double.
For getting the runtime type of the Number variable, you can e.g. use the getClass method:
System.out.println(newTypeX.getClass());
System.out.println(newTypeY.getClass());
When used with the example snippet, this will print out
class java.lang.Integer class java.lang.Double
Well, you can do something like this:
Integer i = 1;
Float f = 2f;
Object[] obArr = new Object[]{i, f};
Float fReconstruct = (Float) obArr[2]
Not really primitive types, but the closest you can get!
You can use an Object to hold reference to any of these types, but it will be 'boxed' to it's wrapper (int will be hold as an Integer, long as a Long, etc.)...
Not yet (java 8), and not in the way you want to get the primitive value back. But if instead of holding a primitive type you hold a primitive type wrapper (which are classes that descend from the Object class and wrap their corresponding primitive, i.e. Byte wraps byte, Integer wraps int, Long wraps long, etc), then you could do this:
public class Holder<T extends Number> {
private final T number;
public Holder(T number) {
this.number = number;
}
public T get() {
return this.number;
}
}
You could use this Holder class to hold an instance of any subclass of Number, including primitive types wrappers. For example:
Holder<Integer> holderX = new Holder<>(5);
Holder<Double> holderY = new Holder<>(1.234);
int x = holderX.get(); // 5
double y = holderY.get(); // 1.234
The above is possible because of a feature of Java called Generics, along with another feature called autoboxing.
Extending generics to support primitive types is being considered for Java 9 or 10 (not sure), under the term Specialization. In theory, this would allow you to have:
List<int> list = new ArrayList<int>();
Generics are a facility of generic programming that were added to the Java programming language in 2004 within J2SE 5.0. They allow "a type or method to operate on objects of various types while providing compile-time type safety.
For an example I like the one on tutorialspoint:
public class GenericMethodTest
{
// generic method printArray
public static < E > void printArray( E[] inputArray )
{
// Display array elements
for ( E element : inputArray ){
System.out.printf( "%s ", element );
}
System.out.println();
}
public static void main( String args[] )
{
// Create arrays of Integer, Double and Character
Integer[] intArray = { 1, 2, 3, 4, 5 };
Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
System.out.println( "Array integerArray contains:" );
printArray( intArray ); // pass an Integer array
System.out.println( "\nArray doubleArray contains:" );
printArray( doubleArray ); // pass a Double array
System.out.println( "\nArray characterArray contains:" );
printArray( charArray ); // pass a Character array
}
}
This would produce the following result:
Array integerArray contains:
1 2 3 4 5 6
Array doubleArray contains:
1.1 2.2 3.3 4.4
Array characterArray contains:
H E L L O Array integerArray contains:
1 2 3 4 5 6
Array doubleArray contains:
1.1 2.2 3.3 4.4
Array characterArray contains:
H E L L O
For more on this link.
