работающий на int и сохраняющий его в двойном [дубликате]

1/3 использует целочисленное деление, поскольку обе стороны являются целыми числами.

Вам нужно, по крайней мере, одно из них быть float или double.

Если вы входите значения в исходном коде, такие как ваш вопрос, вы можете сделать 1.0/3; 1.0 является двойным.

Если вы получите значения из других источников, вы можете использовать (double), чтобы int превратить int в double.

int x = ...;
int y = ...;
double value = ((double) x) / y;

Потому что он обрабатывает 1 и 3 как целые числа, поэтому округляет результат до 0, так что это целое число.

Чтобы получить результат, который вы ищете, прямо скажите java, что числа удваивается так:

double g = 1.0/3.0;

Поскольку вы выполняете целочисленное деление.

Как говорит @Noldorin, если оба оператора являются целыми числами, то используется целочисленное деление.

Результат 0.33333333 не может быть представлен как целое число, поэтому к результату присваивается только целочисленная часть (0).

Если любой из операторов является double / float, тогда будет выполнена арифметика с плавающей запятой. Но у вас будет такая же проблема, если вы это сделаете:

int n = 1.0 / 3.0;

вы должны использовать

double g=1.0/3;

или

double g=1/3.0;

Целочисленное деление возвращает целое число.

Явно бросаю его как double

double g = 1.0/3.0

Это происходит потому, что Java использует операцию целочисленного деления для 1 и 3, так как вы ввели их как целые константы.

Преобразование в JAVA довольно простое, но нужно некоторое понимание. Как поясняют в JLS для целых операций :

Если целочисленный оператор, отличный от оператора сдвига, имеет хотя бы один операнд типа long, то операция выполняется используя 64-битную точность, а результат численного оператора имеет тип long. Если другой операнд не длинный, он сначала расширяется (§5.1.5), чтобы печатать длинным путем численного продвижения (§5.6).

И пример всегда лучший способ перевести JLS;)

int + long -> long
int(1) + long(2) + int(3) -> long(1+2) + long(3)

В противном случае операция выполняется с использованием 32-битной точности , а результат численного оператора имеет тип int. Если какой-либо операнд не является int, он сначала расширен, чтобы вводить int посредством числовой рекламы.

short + int -> int + int -> int

Небольшой пример использования Eclipse, чтобы показать, что даже добавление двух short s не будет таким простым:

short s = 1;
s = s + s; <- Compiling error

//possible loss of precision
//  required: short
//  found:    int

Это потребует литье с возможной потерей точности.

То же самое верно для операторов с плавающей запятой

Если хотя бы один из операндов числовой оператор имеет тип double, тогда операция выполняется с использованием 64-разрядной арифметики с плавающей запятой, а результатом численного оператора является значение типа double. Если другой операнд не является двойным, он сначала расширяется (§5.1.5), чтобы набирать double путем числовой рекламы (§5.6).

Таким образом, продвижение выполняется по float в double.

И сочетание как целочисленного, так и плавающего значения приводит к плавающим значениям, указанным в

Если хотя бы один из операндов для двоичного оператора имеет тип с плавающей запятой, то операция является операцией с плавающей запятой, даже если другая является интегральной.

Это верно для двоичных операторов, но не для «операторов присваивания», таких как +=

Простой рабочий пример достаточно, чтобы доказать это

int i = 1;
i += 1.5f;

Причина в том, что здесь неявное выполнение сделано, это будет выполняться подобно

i = (int) i + 1.5f
i = (int) 2.5f
i = 2

Многие другие не указали на реальную проблему:

Операция только для целых чисел передает результат операции целому числу.

Это обязательно означает, что результаты с плавающей запятой, которые могли бы отображать в виде целого числа, будут усечены (вырезать десятичную часть).

Что такое литье (typecasting / type conversion) вы спрашиваете?

Это зависит от реализации языка, но Wikipedia имеет довольно полное представление, и он также говорит о принуждении который является ключевой частью информации при ответе на ваш вопрос.

http://en.wikipedia.org/wiki/Type_conversion

Сделайте «double g = 1.0 / 3.0;» вместо этого.

public static void main(String[] args) {
    double g = 1 / 3;
    System.out.printf("%.2f", g);
}

Поскольку как 1, так и 3 являются ints, результат не округлен, но он усечен. Таким образом, вы игнорируете фракции и выполняете только целые.

Чтобы избежать этого, по крайней мере одно из ваших чисел 1 или 3 как десятичная форма 1.0 и / или 3.0.

(1/3) означает целочисленное деление, поэтому вы не можете получить десятичное значение из этого деления. Для решения этой проблемы используйте:

public static void main(String[] args) {
        double g = 1.0 / 3;
        System.out.printf("%.2f", g);
    }

1 и 3 являются целыми константами, поэтому Java выполняет целочисленное деление, результатом которого является 0. Если вы хотите написать двойные константы, вы должны написать 1.0 и 3.0.

Использовать 1 a float и float division

public static void main(String d[]){
    double g=1f/3;
    System.out.printf("%.2f",g);
}