Деление Int: Почему результат 1/3 == 0?

Ответ 1

Два операнда (1 и 3) являются целыми числами, поэтому используется целочисленная арифметика (деление здесь). Объявление переменной результата как double приводит к тому, что после деления происходит неявное преобразование.

Целочисленное разделение конечно возвращает истинный результат деления, округленный до нуля. Результат 0.333... таким образом округляется до 0 здесь. (Обратите внимание, что процессор фактически не делает никакого округления, но вы можете думать об этом таким образом.)

Также обратите внимание, что если оба операнда (числа) заданы как float; 3.0 и 1.0, или даже просто первый, тогда используется арифметика с плавающей запятой, дающая вам 0.333....

Ответ 2

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

Вам нужно хотя бы одно из них быть float или double.

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

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

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

Ответ 3

Явным образом добавьте его как double

double g = 1.0/3.0

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

Ответ 4

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

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

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

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

int n = 1.0 / 3.0;

Ответ 5

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

double g=1.0/3;

или

double g=1/3.0;

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

Ответ 6

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

Ответ 7

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

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

double g = 1.0/3.0;

Ответ 8

Создайте 1 поплавок и поплавок.

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

Ответ 9

Преобразование в 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 не будет таким простым:

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).

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

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

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

Это верно для двоичных операторов, но не для "Операторы присваивания", например +=

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

int i = 1;
i += 1.5f;

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

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

Ответ 10

Самое простое решение - просто сделать это

double g = ((double) 1 / 3);

То, что это делает, поскольку вы не ввели 1.0/3.0, позволяет вам вручную преобразовать его в тип данных double, поскольку Java предполагала, что это целочисленное деление, и это будет сделано, даже если это означает сужение преобразования. Это то, что называется оператором приведения.

Ответ 11

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

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

Ответ 12

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

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

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

Ответ 13

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

Ответ 14

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

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

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

Что такое литье (преобразование типов/типов), которое вы задаете?

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

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

Ответ 15

Попробуйте это:

public static void main(String[] args) {
    double a = 1.0;
    double b = 3.0;
    double g = a / b;
    System.out.printf(""+ g);
}