We Keep Coding

How to divide a figure and convert it to decimal but the remainder

I want to be able to divide 9245 by 1000 and get 9.245, and then push this number to my textview.
my code gives me 9.0 and not the remainder. Hope do I keep the remainder?
String playerScore1 = gameInfo.getGame_time() / 1000;
playerscore1.setText(Double.toString(playerScore1));

If getGame_time() method does not return a double/float, you need to explicitly add .0 to dividend, or cast it to double/float type.
gameInfo.getGame_time() / 1000.0;
Java by default performs integer division, which truncates the decimal part of result. To force floating point division you can also use suffix notation:
int/1000f
int/1000d

use 1000.0 then it'll convert it into Double, if you divide it by 1000 it will automatically cast it into an integer. and use data type Double for playerScore1 as it will return Double not String
Double playerScore1 = gameInfo.getGame_time() / 1000.0;
playerscore1.setText(Double.toString(playerScore1));

When using arithmetic operators, Java will always widen to the widest type used. One exception to this rules are arithmetic operations on types byte, char, and short, they are always converted to int. This is the reason why
byte b = 1;
b = b + 1;
will fail to compile due to type mismatches. But funnily enough
byte b = 1;
b += 1;
will compile and work as expected.
Back to topic: If you divide two ints, you get an int as result. If you divide an int and a float, you will get a float, ... Thus, the easiest way to make your expression behave as you want it to is to make one of the values either a float or a double.
You can denote a float literal by appending an f or F to a floating point number.
For double, you can:
just write a floating point number, they will default to double
add a ´.0´ to an integer literal to make it a double literal
append a d or D on a floating point number, to make it extra verbose that it is a double
Applying this to your code, one possible solution is:
double playerScore1 = gameInfo.getGame_time() / 1000.0;

How to get the int value from a floating point number?

If I am getting a random double, how to get only the int?
Examples:
1) 114.999 - get the "114" as an int
2) 565.343234 - get the "565" as an int.

Given the value :
float f = 114.999f;
int i = (int) f;
use a cast to downcast it to an int.

The simplest way would be to cast your double value to an int. For example,
(int) 114.9999 == 114
However, the double type can represent numbers beyond the range of an int. You may need to check if your double is below the smallest possible integer or beyond the largest possible integer to avoid integer overflow issues.

The easiest way to get the integer part of a floating point number would be a simple cast:
double d = 14.999;
int i = (int)d; //14
If you have a primitive wrapper like Double you can use the method intValue() that all subclasses of Number need to provide. However, since those are objects the references can be null and that has to be handled:
Double d = 14.999; //this makes use of auto-boxing
int i = d != null ? d.intValue() : 0; //here 0 is the default value if d is null
Note that this will just truncate the value which can lead to unexpected results due to precision issues, especially when calculations are involved. Due to that you could end up with a number like 14.999999999 when you'd expect 15 or something higher.
Another issue might be that you won't get the next smaller integer for negative values but the next higher, i.e. -14.999 will be truncated to -14.
You should keep that in mind and if those are issues for you have a look at the functions provided by the classes Math, BigDecimal etc.

Write code that assigns to double 'b' the result of rounding double 'a' to the nearest integer

I don't know what to do... I have two doubles and I need b to be the result of a rounded to the nearest integer...
// Enter a value to test here
double a = ;
double b;
// Enter your code here

I have two doubles and I need b to be the result of a rounded to the nearest integer.
You could use Math.round(double) which (per the Javadoc) returns the value of the argument rounded to the nearest long value.
double b = Math.round(a);

As Elliott mentioned you can use the Math.round() function but when you give it a parameter of type double it returns a value of type long but according to the javaDoc if you supply it with a parameter of type long, you will get an integer which is the desired result therefore you have 2 ways of doing so:
casting the double into a long and then as so:
Math.round((long) a);
If you don't like the first way for some reason you can just wrap it with another round() function as so:
/* as you can see the first one converts the double into a long and the second rounds the long into an int which gives the same result as the first option */
Math.round(Math.round(a));

Questions on hexadecimal-notation for primitive initialization

I would like to initialize a double directly by using the hexadecimal-notation. I know this works for int and Long as shown in the following example (resulting values always right):
int i = 0x10000000; // 268435456
Long li = 0x1000000000000000L; // 1152921504606846976
On the other hand, if I try do the same with doubles, it works but only in range of 4 Bytes (view comments in the code example). For the second, not valid notation the Netbeans IDE keeps telling me that is is an integer value and, thus, too large:
double d1 = 0x10000000; // 2.68435456E8
double d2 = 0x1000000000000000; // not valid
float-values work as well as they are in the range of 4 Bytes:
float f1 = 0x10000000; // 2.68435456E8
Is there a way to directly write/initialize a double with hexadecimal-notation?
Is the only reason for being able to write a Long with hex-notation that there is no "L" in this notation (in contrast to "f" for float or the not valid "." for marking doubles)?
Why is there a limitation to 4 Bytes? And why does it apply to double and not to Long?
Thank you for your advise and suggestions.

Java supports floating-point hexadecimal literals since 1.5
double d = 0x1f.1p1;

If you just want to initialize your double with an integer value in the long range, use:
double d2 = 0x1000000000000000L;
You can also supply integer hexadecimal values outside the long range using BigInteger:
double d3 = new BigInteger("123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0", 16).doubleValue();
If you need to supply hexadecimal fractions, as suggested in the previous answer, use a hexadecimal floating point literal:
double d = 0x1F.1p1;

different result in java how can it be rectified

Simple calculation gives different result in java.
int a=5363/12*5;
out.println(a);// result is 2230
But actually result should be 2234.5
How can this java result be rectified?

Two issues:
The expression 5363/12*5 gives an integer result (in particular, the division is integer).
The variable a is of type int (integer).
To fix:
double a=5363.0/12*5;
out.println(a);
Note that in general you can't expect to get exact results when using floating-point arithmetic. The following is a very good read: What Every Computer Scientist Should Know About Floating-Point Arithmetic.

5363, 12, and 5 are all being interpreted as ints. the calculation actually being performed here is:
5363/12 = 446.9… - truncated to the int value 446
446 * 5 = 2230
Try specifying a as a float, and indicate that the numbers in the calculation are also created as floats:
float a = 5363f/12f*5f

Take a as double.
Taking a as int will round it to the integer.

Because your all the literal numbers in the right hand side are integers (e.g. 5363 as opposed to 5363.0) expression is being calculated using integer arithmetic semantics i.e. / does whole number division. Thus 5262/12 equals 446 and 446*5 equals 2230. Also your variable a is an int which can only ever hold an integer value.
To fix this you need to do two things. Change the type of a to a decimal type e.g. float or double b) have at least one of 5363 and 12 represented as a decimal type e.g.
double a= 5363.0/12.0*5

Instead of using double you can re-order your expression.
Assuming 5363/12*5 = 5363*5/12 this will give you a closer answer. You have commented you want to round the result so instead you have to add half the value you are dividing by.
int a = (5363 * 5 + /* for rounding */ 6) / 12;
System.out.println(a);
prints
2235

An int is an Integer - nothing after the ..
You should be using
double a = 5363d/12*5;

It seems it has some int/double rounding issue:
double a=((double)5363/12)*5;
System.out.println("VALUE: "+a);
Prints:
VALUE: 2234.5833333333335
Edit: rounding the result to an integer value:
double a=((double)5363/12)*5;
long b=Math.round(a); //you can cast it to an int type if needed
System.out.println("ROUNDED: "+b);
Prints:
ROUNDED: 2235

Use double
double a = 5363/12*5;
System.out.println(a);
or
cast the integer, to prevent loss or precision.
int a = ((int) 5363/12*5);
System.out.println(a);