Эффективность арифметики int и float в Java

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

Часто вы можете найти удивительные результаты; что на затраченное время практически не влияет базовый числовой тип, или что ваш алгоритм неоптимален.

А что касается оптимизации компилятора - это реальная и действительная часть оптимизации производительности.

Если использование типа A теоретически быстрее, чем использование типа B, но ваш компилятор может оптимизировать тип B, чтобы он был быстрее в реальном сценарии, тогда это ценное свидетельство, а не источник разочарования.

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

как плавать

float f = 15 * 0.987;

как int

int i = 15 * 987 / 1000;

Дополнительное деление означает, что операция int может занять больше времени.

На моей машине целочисленное вычитание примерно в 2,5 раза быстрее, чем двойное. Однако целочисленное умножение всего в 1,5 раза быстрее, чем двойное умножение.

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

// test whether int subs are faster than double subs
public void compareIntAndFloatSubtraction(){

    int N = 100000;  // input array size
    int k = 100000;  // number of mathematical operations performed on each element

    // generate random data
    int[] ints = new int[N];
    double[] doubles = new double[N];
    Random r = new Random(1l);
    for (int i = 0; i < N; i++) {
        ints[i] = r.nextInt();
        doubles[i] = r.nextDouble();
    }

    // measure integer subtractions
    long before = System.currentTimeMillis();
    for (int i = 1; i < N; i++) {
        for (int j = 0; j < k; j++) {
            ints[i] -= ints[i-1];  // referring to another element might prevent from optimization also
        }
    }
    System.out.println(String.format("time needed for int subs [ms]: %s", System.currentTimeMillis()-before));

    // measure double subtractions
    before = System.currentTimeMillis();
    for (int i = 1; i < N; i++) {
        for (int j = 0; j < k; j++) {
            doubles[i] -= doubles[i-1];
        }
    }
    System.out.println(String.format("time needed for double subs [ms]: %s", System.currentTimeMillis()-before));

}

Если вы просто хотите сравнить веса, вы должны предпочесть int вместо float.

Как правило, вам не следует беспокоиться о выборе между int и float по соображениям производительности.

Вот выдержка из Приложения к Java Puzzlers:

Арифметика с плавающей точкой неточна. Не используйте числа с плавающей запятой там, где требуются точные результаты; вместо этого используйте целочисленный тип или BigDecimal . Предпочитайте double float.

Если у вас нет действительно веской причины, вы обычно должны предпочесть double float, если вам нужно использовать операцию с плавающей запятой. Если желателен точный результат, используйте BigDecimal ; это будет медленнее, поскольку это не примитив, но если профилирование не покажет, что это неприемлемо, часто это лучший вариант.

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

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

Я думаю, что производительность очень сильно зависит от алгоритма и платформы, на которой работает программное обеспечение.

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

На других платформах среда выполнения может быть оптимизирована для OpenCL (я не верю, что кто-то делает это прямо сейчас, но это может случиться :). Я понятия не имею, что быстрее всего работает на такой платформе и при каких условиях. Возможно, OpenCL оптимизирован для работы с целыми числами.

В этих обстоятельствах я бы сделал вывод, что на данном этапе нецелесообразно оптимизировать тип данных (float или int), а просто оптимизировать читаемость кода.

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

Но в целом просто используйте алгоритм, который вы можете понять, сохраняйте читабельность кода и, следовательно, количество ошибок будет низким. Быстрый код ничего не стоит, если результаты не верны :)

Я так не думаю.

Число с плавающей запятой составляет 4 байта. И Int в java тоже 4 байта.

Почему бы не использовать дату (java.util.Date), чтобы узнать время работы?

Вы можете определить граф, который имеет 100000 узлов. Затем рассчитайте это.