Сдвиг бита на X быстрее, чем сдвиг бита в один X раз?

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

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

При использовании одинарного сдвига выполняется одна побитовая операция и выполняется присвоение x.

И, как уже говорили другие, это действительно похоже на преждевременную оптимизацию.

Однако ради ответа на ваш вопрос, по логике вещей, первый пример быстрее остальных.

Тем не менее, в зависимости от языка и компилятора, возможно, что компилятор увидит, что ваш for loop всегда выполняется 16 раз, а затем приступит к оптимизации вашего кода, изменив его на x << 16. Если это так, вы не увидите никакой разницы между каждым приведенным вами примером кода.

...чтобы мне не пришлось тратить время пользователей StackOverflow?

Вы тоже тратите свое время. Напишите полный прототип своего приложения, профилируйте его и затем оптимизируйте. Я совершенно уверен, что вы обнаружите, что узкое место не связано со сдвигом битов.

Это давно пахнет преждевременной оптимизацией.

Какова точная производительность «x ‹‹ 16»? Это та же скорость, что и "x ‹‹ 1"?

Да, это то же самое. Но с технической точки зрения это на самом деле зависит от компилятора, реализации JVM, JIT, архитектуры ЦП и т. д. Спецификация Java не накладывает никаких ограничений на время выполнения в таких случаях.

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

    long start1 = System.nanoTime();
    for (int k = 0; k < 100000000; k++) {
        int x = 5;
        x = x << 16;
    }
    long stop1 = System.nanoTime();

    long start2 = System.nanoTime();
    for (int k = 0; k < 100000000; k++) {
        int x = 5;
        for (int i = 0; i < 16; ++i) {
            x = x << 1;
        }
    }
    long stop2 = System.nanoTime();

    long start3 = System.nanoTime();
    for (int k = 0; k < 100000000; k++) {
        int x = 5;
        for (int i = 0; i < 16; ++i) {
            x = x * 2;
        }
    }
    long stop3 = System.nanoTime();

    System.out.println(stop1 - start1);
    System.out.println(stop2 - start2);
    System.out.println(stop3 - start3);

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

Вы не должны много думать об этих незначительных вещах «улучшения скорости». Скорость этих небольших арифметических/логических операций огромна, и это не сильно повлияет на производительность программы.