Как использовать побитовый оператор для передачи нескольких значений Integer в функцию для Java?

Ответ 1

Ваши значения должны иметь значение 2.

Таким образом, вы не теряете никакой информации, когда вы побитовое ИЛИ или их.

public static final int ONE   = 0x01;
public static final int TWO   = 0x02;
public static final int THREE = 0x04;
public static final int FOUR  = 0x08;
public static final int FIVE  = 0x10;

и др.

Затем вы можете сделать это:

public static void main(String [] args) {
    Example.multiValueExample(Values.ONE | Values.THREE | Values.FIVE);
}

public static void multiValueExample(int values){
    if ((values & Values.ONE) == Values.ONE) {
    }

    if ((values & Values.TWO) == Values.TWO) {
    }

    // etc.
}

Ответ 2

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

Согласно Эффективный Java 2: "Пункт 32: Использовать EnumSet вместо битовых полей "

Использование EnumSet довольно эффективно для использования памяти и очень удобно.

Вот пример:

package enums;

import java.util.EnumSet;
import java.util.Set;

public class Example {
  public enum Values {
    ONE, TWO, THREE, FOUR, FIVE
  }

  public static void main(String[] args) {
    // should evaluate just Values.ONE
    Example.multiValueExample(EnumSet.of(Values.ONE));

    // should evalueate just values Values.ONE, Values.THREE, Values.FIVE
    Example.multiValueExample(EnumSet.of(Values.ONE, Values.THREE, Values.FIVE));

    // should evalueate just values Values.TWO , Values.FIVE
    Example.multiValueExample(EnumSet.of(Values.TWO, Values.FIVE));
  }

  public static void multiValueExample(Set<Values> values) {
    if (values.contains(Values.ONE)) {
      System.out.println("One");
    }

    // Other checks here...

    if (values.contains(Values.FIVE)) {
      System.out.println("Five");
    }
  }
}

Ответ 3

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

int ONE = 0x1;    //0001
int TWO = 0x2;    //0010
int THREE = 0x4;  //0100
int FOUR = 0x8;   //1000

Затем вы используете побитовое ИЛИ для объединения значений и побитового И для проверки установленных значений.

int test_value = (ONE | FOUR);   //-> 1001
bool has_one = (test_value & ONE) != 0;  //-> 1001 & 0001 -> 0001 -> true

Ответ 4

Значения, которые вы комбинируете с | (двоичный OR, а не логический ИЛИ [который является ||]) не должен перекрывать "1" в их представлении бит. Например,

ONE = 0x1 =   0000 0001
TWO = 0x2 =   0000 0010
THREE = 0x3 = 0000 0011
FOUR = 0x4 =  0000 0100

Затем вы можете комбинировать ONE и TWO, например:

ONE | TWO = 0000 0011

Но вы не можете отличить ONE | ДВА от ТРИ, потому что есть перекрывающиеся биты. Таким образом, числа, которые вы объединяете, должны быть равны двум, чтобы они не перекрывались, когда OR'ed вместе. Чтобы проверить, прошел ли число в "значениях", выполните:

if (values & ONE) {
    // ... then ONE was set
}

Чтобы лучше понять, почему и как это работает, я рекомендую вам немного прочитать бинарное представление и логику. Хорошее место Глава 3 Art of Assembly.

Ответ 5

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

public static final int ONE   = 0x1;  // First bit is set
public static final int TWO   = 0x2;  // Second bit is set
public static final int THREE = 0x4;  // Third bit is set
public static final int FOUR  = 0x8;  // Fourth bit is set
public static final int FIVE  = 0x10; // Fifth bit is set

Во-вторых, вы должны использовать java.util.BitSet для этих видов операций:

BitSet bits = new BitSet(5);
bits.set(2);
bits.set(4);

System.out.println("these bits are set: " + bits);
// Prints "these bits are set: {2, 4}"

BitSet otherBits = new BitSet(5);
otherBits.set(3);
otherBits.set(4);

System.out.println("these bits are set: " + bits.or(otherBits));
// Prints "these bits are set: {2, 3, 4}"

Ответ 6

Хорошо, если они имеют силу 2, вы бы сделали что-то вроде метода "display" в приведенном ниже коде.

Вот ссылка в wikipedia по этой теме, которая должна объяснить, почему вам нужны полномочия 2.

public class Main
{
    private static final int A = 0x01;
    private static final int B = 0x02;
    private static final int C = 0x04;

    public static void main(final String[] argv)
    {
        display(A);
        display(B);
        display(C);
        display(A | A);
        display(A | B);
        display(A | C);
        display(B | A);
        display(B | B);
        display(B | C);
        display(C | A);
        display(C | B);
        display(C | C);
        display(A | A | A);
        display(A | A | B);
        display(A | A | C);
        display(A | B | A);
        display(A | B | B);
        display(A | B | C);
        display(A | C | A);
        display(A | C | B);
        display(A | C | C);
        display(B | A | A);
        display(B | A | B);
        display(B | A | C);
        display(B | B | A);
        display(B | B | B);
        display(B | B | C);
        display(B | C | A);
        display(B | C | B);
        display(B | C | C);
        display(C | A | A);
        display(C | A | B);
        display(C | A | C);
        display(C | B | A);
        display(C | B | B);
        display(C | B | C);
        display(C | C | A);
        display(C | C | B);
        display(C | C | C);
    }

    private static void display(final int val)
    {
        if((val & A) != 0)
        {
            System.out.print("A");
        }

        if((val & B) != 0)
        {
            System.out.print("B");
        }

        if((val & C) != 0)
        {
            System.out.print("C");
        }

        System.out.println();
    }
}

Ответ 7

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

import static Example.Values.*;
import java.util.Arrays;

public class Example {
    public enum Values { ONE, TWO, THREE, FOUR, FIVE }

    public static void main(String [] args) {
        // should evaluate just Values.ONE
        multiValueExample(ONE);

        // should evaluate just values Values.ONE,  Values.THREE, Values.FIVE
        multiValueExample(ONE, THREE, FIVE);

        // should evaluate just values Values.TWO , Values.FIVE
        multiValueExample(TWO, FIVE);
    }

    public static void multiValueExample(Values... values){
        // Logic that properly evaluates
        System.out.println(Arrays.asList(values));
        for (Values value : values) {
            // do something.
        }
    }
}

Ответ 8

В главе "Учебник Java" по побитовым операциям находится

http://java.sun.com/docs/books/tutorial/java/nutsandbolts/op3.html

Это очень красноречиво, но полезно для справки.