Obtenir n bits les moins significatifs d’un Int

Cela devrait fonctionner pour tous les N < 33 32 non négatifs.

x & ((1 << N) - 1) 

Cela vaut la peine de préciser comment cela fonctionne pour N == 31 et N == 32 . Pour N == 31 , on obtient 1 << N == Integer.MIN_VALUE . Lorsque vous soustrayez 1 à cela, Java Integer.MAX_VALUE silencieusement à Integer.MAX_VALUE , ce qui est exactement ce dont vous avez besoin. Pour N == 32 , le bit 1 est complètement décalé, donc 1 << N == 0 ; then (1 << N) - 1 == -1 , ce qui correspond à l'ensemble des 32 bits.

Pour N == 32 , malheureusement, cela ne fonctionne pas car (merci, @zssortingng!), L'opérateur << ne se déplace que par le côté droit du mod 32. Si vous souhaitez éviter de tester spécialement ce cas, vous pouvez utiliser:

 x & ((int)(1L << N) - 1) 

En décalant d'un long , vous obtenez le décalage complet de 32 bits, ce qui, après avoir rétabli un int , vous donne 0. La soustraction de 1 vous donne -1 et x & -1 n'est que x pour toute valeur int x (et x est la valeur des 32 bits inférieurs de x ).

L’approche de Ted est susceptible d’être plus rapide mais voici une autre approche

 x << -N >>> -N 

Ce décalage tout le bit en haut et en bas pour couper les bits supérieurs.

 int i = -1; System.out.println(Integer.toBinarySsortingng(i)); i = i << -5 >>> -5; System.out.println(Integer.toBinarySsortingng(i)); 

empreintes

 11111111111111111111111111111111 11111 

Vous pouvez également utiliser un masque. Si vous utilisez l’opérateur & bitwise, vous pouvez alors supprimer le bit que vous souhaitez supprimer (par exemple, les x bits les plus élevés);

 int mask = 0x7FFFFFFF //Example mask where you will remove the // most significant bit // (0x7 = 0111b and 0xF = 1111b). int result = numberToProcess & mask; //And apply the mask with the &bitwise op. 

L’inconvénient à cela est que vous devrez créer un masque pour chaque bit, c’est peut-être mieux vu comme une autre méthode d’approche en général.