Comment utiliser un opérateur bitwise pour transmettre plusieurs valeurs Integer dans une fonction pour Java?

En application des cadres je continue à voir des cadres qui permettent de passer plusieurs valeurs Int (généralement utilisé à la place d'un enum) dans une fonction.

Par exemple:

public class Example
{ 
    public class Values
    {
        public static final int ONE = 0x7f020000;
        public static final int TWO = 0x7f020001;
        public static final int THREE = 0x7f020002;
        public static final int FOUR = 0x7f020003;
        public static final int FIVE = 0x7f020004;
    }

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

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

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

    public static void multiValueExample(int values){
        //Logic that properly evaluates bitwise values
        ...
    }
}

De sorte à ce que la logique devrait exister dans multiValueExample pour moi d'évaluer correctement les multiples int les valeurs sont passées à l'aide de l'opérateur au niveau du bit?

source d'informationauteur AtariPete | 2009-03-15

Vos valeurs doivent être des puissances de 2.

De cette façon, vous ne perdez pas de toutes les informations lorsque vous bit à bit OU.

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;

etc.

Ensuite, vous pouvez faire ceci:

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.
}

Comme cela a déjà été mentionné, envisager l'utilisation d'énumérations au lieu de la valeur des bits.

Selon Efficace Java 2: "Article 32: l'Utilisation EnumSet au lieu de champs de bits"

Utilisation de EnumSet est assez efficace pour l'utilisation de la mémoire et très pratique.

Voici un exemple:

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");
    }
  }
}

5

Vous permet de configurer les valeurs entières pour être des puissances de deux, de sorte que chaque valeur énumérée est un peu unique dans la représentation binaire.
```
int ONE = 0x1;    //0001
int TWO = 0x2;    //0010
int THREE = 0x4;  //0100
int FOUR = 0x8;   //1000
```
Puis vous utilisez bit-wise OU de combiner les valeurs et au niveau du bit ET de tester les valeurs de consigne.
```
int test_value = (ONE | FOUR);   //-> 1001
bool has_one = (test_value & ONE) != 0;  //-> 1001 & 0001 -> 0001 -> true
```
4

Les valeurs que vous les combinez avec | (binaire OU, pas de logique OU de [ | | ]) ne doit pas avoir de chevauchement "1"dans leur représentation binaire. Par exemple,
```
ONE = 0x1 =   0000 0001
TWO = 0x2 =   0000 0010
THREE = 0x3 = 0000 0011
FOUR = 0x4 =  0000 0100
```
Ensuite, vous pouvez les combiner en UNE et DEUX, par exemple:
```
ONE | TWO = 0000 0011
```
Mais vous ne pouvez pas les distinguer l'UNE | DEUX, de TROIS, parce qu'il y a chevauchement des bits. Les numéros vous combinez devraient donc être des puissances de deux, de telle sorte qu'ils ne se chevauchent pas quand OU ed ensemble. Pour tester si un nombre est passé de "valeurs", n':
```
if (values & ONE) {
    //... then ONE was set
}
```
De mieux comprendre pourquoi et comment cela fonctionne, je vous recommande de lire un peu sur la représentation binaire et logique. Une bonne place est Chapitre 3 de l'Art de l'Assemblée.

Bien si elles sont des puissances de 2, vous feriez quelque chose comme le "display" de la méthode dans le code ci-dessous.

Voici un lien dans wikipedia sur le sujet et ce qui doit expliquer pourquoi vous voulez des puissances de 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();
}
}

À l'aide des masques de bits ont été très populaires lorsque tous les bits compté. Une autre façon de le faire aujourd'hui est d'utiliser les énumérations sont plus simples à manipuler et à étendre.

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.
}
}
}

Tout d'abord, vous ne pouvez pas définir les Valeurs de cette façon de faire des comparaisons au niveau du bit. Au lieu de cela, les différentes bits:

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

Seconde, vous devriez probablement utiliser des java.util.BitSet pour ces sortes d'opérations:

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}"

0

La Java Tutoriel chapitre sur les opérations bit à bit sont à

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

Il est très concis, mais bon pour la référence.

Vous devez vous connecter pour publier un commentaire.