Что делает оператор ^ в Java?

Какую функцию выполняет ^оператор (caret) в Java?

Когда я пытаюсь это:

int a = 5^n;

... это дает мне:

для n = 5 возвращает 0
для n = 4, возвращает 1
для n = 6, возвращает 3

... так что я думаю, что это не выполняет возведения в степень. Но что это тогда?

Оператор ^ в Java

^ в Java это оператор с исключительным или ("xor").

Давайте возьмем в 5^6качестве примера:

(decimal)    (binary)
     5     =  101
     6     =  110
------------------ xor
     3     =  011

Это таблица истинности для побитового ( JLS 15.22.1 ) и логического ( JLS 15.22.2 ) xor:

^ | 0 1      ^ | F T
--+-----     --+-----
0 | 0 1      F | F T
1 | 1 0      T | T F

Проще говоря, вы также можете думать о xor как о «том или ином, но не обоем !».

Смотрите также

• Википедия: эксклюзив или

Экспонирование в Java

Что касается целочисленного возведения в степень, то, к сожалению, в Java такого оператора нет. Вы можете использовать double Math.pow(double, double)(приведение результата к intнеобходимости).

Вы также можете использовать традиционный трюк со сдвигом битов для вычисления некоторых степеней двойки. То есть (1L << k)это два к k-й степени для k=0..63.

Смотрите также

• Википедия: Арифметический сдвиг

Примечание о слиянии: этот ответ был объединен с другим вопросом, в котором предполагалось использовать возведение в степень для преобразования строки"8675309"вintбез использованияInteger.parseIntв качестве упражнения по программированию (^обозначает возведение в степень теперь). Намерением ФП было вычислить8*10^6 + 6*10^5 + 7*10^4 + 5*10^3 + 3*10^2 + 0*10^1 + 9*10^0 = 8675309; Следующая часть этого ответа посвящена тому, что возведение в степень не является необходимым для этой задачи.

Схема Хорнера

Для удовлетворения ваших конкретных потребностей вам не нужно вычислять различные степени 10. Вы можете использовать так называемую схему Хорнера , которая не только проста, но и эффективна.

Поскольку вы делаете это как личное упражнение, я не буду давать код Java, но вот основная идея:

8675309 = 8*10^6 + 6*10^5 + 7*10^4 + 5*10^3 + 3*10^2 + 0*10^1 + 9*10^0
        = (((((8*10 + 6)*10 + 7)*10 + 5)*10 + 3)*10 + 0)*10 + 9

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

В форме таблицы:

step   result  digit  result*10+digit
   1   init=0      8                8
   2        8      6               86
   3       86      7              867
   4      867      5             8675
   5     8675      3            86753
   6    86753      0           867530
   7   867530      9          8675309=final

Как уже отмечали многие люди, это оператор XOR . Многие люди также уже отметили, что если вы хотите возвести в степень, то вам нужно использовать Math.pow .

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

Operator    Name         Example     Result  Description
a & b       and          3 & 5       1       1 if both bits are 1.
a | b       or           3 | 5       7       1 if either bit is 1.
a ^ b       xor          3 ^ 5       6       1 if both bits are different.
~a          not          ~3          -4      Inverts the bits.
n << p      left shift   3 << 2      12      Shifts the bits of n left p positions. Zero bits are shifted into the low-order positions.
n >> p      right shift  5 >> 2      1       Shifts the bits of n right p positions. If n is a 2's complement signed number, the sign bit is shifted into the high-order positions.
n >>> p     right shift  -4 >>> 28   15      Shifts the bits of n right p positions. Zeros are shifted into the high-order positions.

От сюда .

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

Это побитовое XOR, Java не имеет оператора возведения в степень, вы должны использовать Math.pow()вместо этого.

Правило оператора XOR =>

0 ^ 0 = 0
1 ^ 1 = 0
0 ^ 1 = 1
1 ^ 0 = 1

Двоичное представление 4, 5 и 6:

4 = 1 0 0 
5 = 1 0 1
6 = 1 1 0

Теперь выполните операцию XOR на 5 и 4:

     5 ^ 4 => 1  0  1   (5)
              1  0  0   (4)
            ----------
              0  0  1   => 1

Так же,

5 ^ 5 => 1   0   1    (5)
         1   0   1    (5)
       ------------
         0   0   0   => (0)


5 ^ 6 => 1   0   1  (5)
         1   1   0  (6)
        -----------
         0   1   1  => 3

Это XORпобитовый оператор.

Многие уже объяснили, что это такое и как его можно использовать, но помимо очевидного, вы можете использовать этот оператор для выполнения множества программных трюков, таких как

• XORing всех элементов в логическом массиве скажет вам, если массив имеет нечетное количество истинных элементов
• Если у вас есть массив, в котором все числа повторяются четное число раз, за ​​исключением одного, которое повторяется нечетное количество раз, вы можете найти это с помощью XORing всех элементов.
• Обмен значениями без использования временной переменной
• Нахождение пропущенного числа в диапазоне от 1 до n
• Базовая проверка данных, отправляемых по сети.

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

Как уже говорили другие, это побитовый XOR. Если вы хотите поднять число до определенной степени, используйте Math.pow(a , b), где aэто число, а bэто сила.

Правило оператора XOR

0 ^ 0 = 0
1 ^ 1 = 0
0 ^ 1 = 1
1 ^ 0 = 1

Побитовый оператор работает с битами и выполняет побитовую операцию. Предположим, если а = 60 и б = 13; теперь в двоичном формате они будут выглядеть следующим образом -

a = 0011 1100

b = 0000 1101



a^b ==> 0011 1100  (a)
        0000 1101  (b)
        -------------  XOR
        0011 0001  => 49

(a ^ b) will give 49 which is 0011 0001

Ссылка AraK указывает на определение exclusive-or, которое объясняет, как эта функция работает для двух логических значений.

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

Чтобы использовать ваш пример:

• Двоичное представление 5 - 0101.
• Двоичное представление 4 - 0100.

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

С 4 и 5 разница только в последнем месте; так

0101 ^ 0100 = 0001 (5 ^ 4 = 1).

Вместо этого вы можете использовать Math.pow:

https://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Math.html#pow%28double,%20double%29

Как уже говорилось в других ответах, это оператор «исключающее или» (XOR) . Для получения дополнительной информации о битовых операторах в Java см .: http://java.sun.com/docs/books/tutorial/java/nutsandbolts/op3.html.

Это битовый оператор xor в java, который дает 1 для другого значения бита (т.е. 1 ^ 0 = 1) и 0 для того же значения бита (то есть 0 ^ 0 = 0), когда число записывается в двоичной форме.

пример: -

Чтобы использовать ваш пример:

Двоичное представление 5 - 0101. Двоичное представление 4 - 0100.

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

0101 ^ 0100 = 0001 (5 ^ 4 = 1).

Это потому, что вы используете оператор xor.

В Java, или почти любом другом языке, ^ является побитовым xor, поэтому, конечно,

10 ^ 1 = 11. подробнее о побитовых операторах

Интересно, что в Java и C # нет оператора power.

Это битовый оператор xor в Java, который приводит 1 к другому значению (то есть 1 ^ 0 = 1) и 0 к тому же значению (то есть 0 ^ 0 = 0).

^ является двоичным (как в base-2) xor, а не возведением в степень (которое недоступно как оператор Java). Для возведения в степень см. Java.lang.Math.pow ().

Это оператор XOR. Используется для выполнения битовых операций над числами. Такое поведение таково, что когда вы выполняете операцию xor с теми же битами, скажем, 0 XOR 0/1 XOR 1, результат равен 0. Но если любой из битов отличается, результат равен 1. Итак, когда вы сделали 5 ^ 3, тогда вы можно смотреть на эти числа 5, 6 в их двоичных формах, и, таким образом, выражение становится (101) XOR (110), что дает результат (011), десятичное представление которого равно 3.

В других языках, таких как Python, вы можете сделать 10 ** 2 = 100, попробуйте.