почему мой код всегда возвращает тот же результат независимо от ввода? [Дубликат]

Сценарий из @larsmans немного улучшился:

#!/bin/sh

set -x
CURRENT=`git rev-parse --abbrev-ref HEAD`
git fetch --all
for branch in "$@"; do
  if ["$branch" -ne "$CURRENT"]; then
    git checkout "$branch" || exit 1
    git rebase "origin/$branch" || exit 1
  fi
done
git checkout "$CURRENT" || exit 1
git rebase "origin/$CURRENT" || exit 1

После завершения работы, рабочая копия удаляется из той же ветви, что и до вызова сценария.

Версия git pull:

#!/bin/sh

set -x
CURRENT=`git rev-parse --abbrev-ref HEAD`
git fetch --all
for branch in "$@"; do
  if ["$branch" -ne "$CURRENT"]; then
    git checkout "$branch" || exit 1
    git pull || exit 1
  fi
done
git checkout "$CURRENT" || exit 1
git pull || exit 1
70
задан Makoto 28 October 2015 в 17:41
поделиться

13 ответов

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

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

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

97
ответ дан Jason C 22 August 2018 в 04:25
поделиться
  • 1
    +1, и он всегда округляется. int i = .99999999 устанавливает int в 0. Более конкретно, он принимает целочисленную часть и отбрасывает остальную часть. – Byron Whitlock 13 January 2011 в 22:30
  • 2
    Он округляется до нуля " который является "вниз" для значений больше нуля. (+0.9 округляется до 0, -0.9 также округляется до 0.) – Adrian Smith 13 January 2011 в 22:32
  • 3
    @Byron: Да, точно. Я не считаю, что процессор фактически делает любое округление, так как деление реализовано по-разному, но удобно придумать его таким образом. – Noldorin 13 January 2011 в 22:32
  • 4
    Нет, не округление: Усечение – Basil Bourque 2 July 2016 в 03:03
  • 5
    @BasilBourque В java-терминологии округление DOWN равно нулю. Округление FLOOR направлено на отрицательную бесконечность. – Andreas 31 December 2016 в 19:12

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

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

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

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

int x = ...;
int y = ...;
double value = ((double) x) / y;
15
ответ дан Adrian Smith 22 August 2018 в 04:25
поделиться

Преобразование в 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
1
ответ дан AxelH 22 August 2018 в 04:25
поделиться

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

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

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

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

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

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

-1
ответ дан Basil Bourque 22 August 2018 в 04:25
поделиться
  • 1
    Этот ответ ошибочен. Не существует Type Casting или Type Conversion, участвующих во всем целочисленном devision, таком как 1/2, а не на целевом языке (java). Вы просто вызываете целочисленное деление, которое приведет к целочисленному результату. Тип Casting происходит только из-за повышающего преобразования из int в double во время назначения. – YoYo 2 April 2018 в 15:24
  • 2
    @YoYo Вы говорите, что 0.5 - целое число? Я так не думаю, мистер. – sova 3 April 2018 в 00:33
  • 3
    этот homie ничего не сказал о 0.5. Просто, в Java, 1/2 - целочисленное деление, в результате чего получается нулевое целое число. Вы можете назначить ноль в double, он все равно будет равен нулю, хотя и 0.0 double. – YoYo 3 April 2018 в 00:47

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

-1
ответ дан Brian Knoblauch 22 August 2018 в 04:25
поделиться
  • 1
    Просто любопытно ... что не так с этим ответом? Я использовал этот подход, когда впервые столкнулся с проблемой. Будет оценено объяснение того, что не так с этим решением. Заранее спасибо. – Mr. Port St Joe 4 February 2018 в 13:04
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
ответ дан chevybow 22 August 2018 в 04:25
поделиться

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

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

double g = 1.0/3.0;
1
ответ дан DanielGibbs 22 August 2018 в 04:25
поделиться

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

public static void main(String[] args) {
        double g = 1.0 / 3;
        System.out.printf("%.2f", g);
    }
0
ответ дан Maruf Hossain 22 August 2018 в 04:25
поделиться

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

0
ответ дан Reboot 22 August 2018 в 04:25
поделиться

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

public static void main(String d[]){
    double g=1f/3;
    System.out.printf("%.2f",g);
}
1
ответ дан sblundy 22 August 2018 в 04:25
поделиться

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

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

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

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

int n = 1.0 / 3.0;
2
ответ дан Tom 22 August 2018 в 04:25
поделиться

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

double g=1.0/3;

или

double g=1/3.0;

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

2
ответ дан user 22 August 2018 в 04:25
поделиться

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

double g = 1.0/3.0

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

8
ответ дан Winter 22 August 2018 в 04:25
поделиться
Другие вопросы по тегам:

Похожие вопросы: