Сценарий из @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
Два операнда (1 и 3) являются целыми числами, поэтому используется целочисленная арифметика (деление здесь). Объявление переменной результата как double просто приводит к возникновению неявного преобразования после деления .
Целочисленное разделение конечно возвращает истинный результат деления, округленный до нуля. Таким образом, результат 0.333...
округляется до 0. (Обратите внимание, что процессор фактически не делает никакого округления, но вы можете думать об этом так же).
Также обратите внимание, что если указаны оба операнда (числа) как плавающие; 3.0 и 1.0, или даже только first , то используется арифметика с плавающей запятой, дающая вам 0.333...
.
1/3
использует целочисленное деление, поскольку обе стороны являются целыми числами.
Вам нужно, по крайней мере, одно из них быть float
или double
.
Если вы входите значения в исходном коде, такие как ваш вопрос, вы можете сделать 1.0/3
; 1.0
является двойным.
Если вы получите значения из других источников, вы можете использовать (double)
, чтобы int
превратить int
в double
.
int x = ...;
int y = ...;
double value = ((double) x) / y;
Преобразование в JAVA довольно простое, но нужно некоторое понимание. Как поясняют в JLS для целых операций :
Если целочисленный оператор, отличный от оператора сдвига, имеет хотя бы один операнд типа long, то операция выполняется используя 64-битную точность, а результат численного оператора имеет тип long. Если другой операнд не длинный, он сначала расширяется (§5.1.5), чтобы печатать длинным путем численного продвижения (§5.6).
blockquote>И пример всегда лучший способ перевести JLS;)
int + long -> long int(1) + long(2) + int(3) -> long(1+2) + long(3)
В противном случае операция выполняется с использованием 32-битной точности , а результат численного оператора имеет тип int. Если какой-либо операнд не является int, он сначала расширен, чтобы вводить int посредством числовой рекламы.
blockquote>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).
blockquote>Таким образом, продвижение выполняется по float в double.
И сочетание как целочисленного, так и плавающего значения приводит к плавающим значениям, указанным в
Если хотя бы один из операндов для двоичного оператора имеет тип с плавающей запятой, то операция является операцией с плавающей запятой, даже если другая является интегральной.
blockquote>Это верно для двоичных операторов, но не для «операторов присваивания», таких как
+=
Простой рабочий пример достаточно, чтобы доказать это
int i = 1; i += 1.5f;
Причина в том, что здесь неявное выполнение сделано, это будет выполняться подобно
i = (int) i + 1.5f i = (int) 2.5f i = 2
Многие другие не указали на реальную проблему:
Операция только для целых чисел передает результат операции целому числу.
blockquote>Это обязательно означает, что результаты с плавающей запятой, которые могли бы отображать в виде целого числа, будут усечены (вырезать десятичную часть).
Что такое литье (typecasting / type conversion) вы спрашиваете?
Это зависит от реализации языка, но Wikipedia имеет довольно полное представление, и он также говорит о принуждении который является ключевой частью информации при ответе на ваш вопрос.
1/2
, а не на целевом языке (java). Вы просто вызываете целочисленное деление, которое приведет к целочисленному результату. Тип Casting происходит только из-за повышающего преобразования из int
в double
во время назначения.
– YoYo
2 April 2018 в 15:24
0.5
. Просто, в Java, 1/2
- целочисленное деление, в результате чего получается нулевое целое число. Вы можете назначить ноль в double, он все равно будет равен нулю, хотя и 0.0
double.
– YoYo
3 April 2018 в 00:47
Сделайте «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 как целые числа, поэтому округляет результат до 0, так что это целое число.
Чтобы получить результат, который вы ищете, прямо скажите java, что числа удваивается так:
double g = 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);
}
Поскольку вы выполняете целочисленное деление.
Как говорит @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
, так как вы ввели их как целые константы.
int i = .99999999
устанавливает int в 0. Более конкретно, он принимает целочисленную часть и отбрасывает остальную часть. – Byron Whitlock 13 January 2011 в 22:30DOWN
равно нулю. ОкруглениеFLOOR
направлено на отрицательную бесконечность. – Andreas 31 December 2016 в 19:12