جافا: التحقق مما إذا كان قليلا 0 أو 1 في فترة طويلة

Question

ما الطريقة التي تستخدمها لتحديد ما إذا كانت البتة التي تمثل 2 ^ x هي 1 أو 0؟

Answer 1

كنت أستخدم:

if ((value & (1L << x)) != 0)
{
   // The bit was set
}

(قد تكون قادرا على الابتعاد مع عدد أقل من الأقواس، لكنني لا أتذكر أبدا الأسبقية من عمليات bitwise.)

Answer 2

بديل آخر:

if (BigInteger.valueOf(value).testBit(x)) {
    // ...
}

Answer 3

أتساءل عما إذا كان:

  if (((value >>> x) & 1) != 0) {

  }

.. هو أفضل لأنه لا يهم ما إذا كانت القيمة طويلة أم لا، أو إذا كانت أسوأ لها لأنها أقل وضوحا.

توم حواتين - TACKLINE JL 7 في 14:16

Answer 4

تستطيع ايضا استخذام

bool isSet = ((value>>x) & 1) != 0;

تحرير: الفرق بين "(value>>x) & 1" و "value & (1<<x)"تعتمد على السلوك عندما يكون x أكبر من حجم نوع" القيمة "(32 في حالتك).

في هذه الحالة بالذات، مع "(value>>x) & 1"سيكون لديك علامة القيمة، في حين تحصل على 0 مع"value & (1<<x)"(من المفيد في بعض الأحيان الحصول على علامة الشيء إذا كانت x كبيرة جدا).

إذا كنت تفضل الحصول على 0 في هذه الحالة، يمكنك استخدام ">>>"المشغل، بدلا من ذلك إذا">>"

وبالتالي، "((value>>>x) & 1) != 0" و "(value & (1<<x)) != 0"تعادل تماما

Answer 5

ل nth LSB (الأقل أهمية كبيرة)، يجب أن تعمل ما يلي:

boolean isSet = (value & (1 << n)) != 0;

Answer 6

قد ترغب في التحقق من Bitset: http://java.sun.com/javase/6/docs/api/java/util/bitset.html.

Answer 7

تحول بت مباشرة من قبل X والتحقق من أدنى قليلا.

Answer 8

في جافا ما يلي يعمل بشكل جيد:

if (value << ~x < 0) {
   // xth bit set
} else {
   // xth bit not set
}

value و x يمكن ان يكون int أو long (ولا تحتاج أن تكون هي نفسها).

كلمة الحذر للمبرمجين غير Java: يعمل التعبير السابق في جافا لأنه في هذه اللغة ينطبق مشغلو التحول بت فقط على 5 (أو 6، في حالة long) أدنى أجزاء من المعاملات الجانبية اليمنى. هذا يترجم الضمنية التعبير إلى value << (~x & 31) (أو value << (~x & 63) إذا value يكون long).

جافا سكريبت: تعمل أيضا في JavaScript (مثل Java، يتم تطبيق أقل 5 بت من عدد التحولات). في جافا سكريبت أي number هو 32 بت.

لا سيما في C، تحرز عدد التحول السلبي السلوك غير المحدد، لذلك لن يعمل هذا الاختبار بالضرورة (على الرغم من أنه قد، اعتمادا على مزيج خاص بك من المحول البرمجي / المعالج).

Answer 9

قيمة 2 ^ × بت هو "متغير و (1 << x)"

Answer 10

أعلن درجة الحرارة الثانية وجعلها تساوي الأصلي. ثم قم بتشغيل TEMP >> X مرات، بحيث تكون الشيء الذي تريد التحقق منه هو في الموضع الأخير. ثم قم بتدرج & 0xF لإسقاط البتات السابقة. الآن اليسار مع آخر قليلا. أخيرا، إذا كان (y & 1 == 0)، إذا كان BIT أخيرا 1، فمن يجب أن يساوي 0، وإلا سوف يساوي 1. إما ذلك أو إذا كان (y +x1 == 0) ... غير متأكد جدا. أحمق ونرى

Answer 11

إذا لم يكن شخص ما مريحا للغاية من مشغلي Bitwise، فيمكن محاولة أدناه رمز لتحديد ذلك برمجيا. هناك طريقتان.

1) استخدم وظيفة لغة Java للحصول على سلسلة تنسيق ثنائية ثم تحقق من الحرف في وضع محدد

2) حافظ على تقسيم 2 وتقرر قيمة البت في موقف معين.

public static void main(String[] args) {
    Integer n =1000;
    String binaryFormat =  Integer.toString(n, 2);
    int binaryFormatLength = binaryFormat.length();
    System.out.println("binaryFormat="+binaryFormat);
    for(int i = 1;i<10;i++){
        System.out.println("isBitSet("+n+","+i+")"+isBitSet(n,i));
        System.out.println((binaryFormatLength>=i && binaryFormat.charAt(binaryFormatLength-i)=='1'));
    }

}

public static boolean isBitSet(int number, int position){
    int currPos =1;
    int temp = number;
    while(number!=0 && currPos<= position){
        if(temp%2 == 1 && currPos == position)
            return true;
        else{
            temp = temp/2;
            currPos ++;
        }
    }
    return false;
}

انتاج |

binaryFormat=1111101000
isBitSet(1000,1)false
false
isBitSet(1000,2)false
false
isBitSet(1000,3)false
false
isBitSet(1000,4)true
true
isBitSet(1000,5)false
false
isBitSet(1000,6)true
true
isBitSet(1000,7)true
true
isBitSet(1000,8)true
true
isBitSet(1000,9)true
true

Answer 12

مساهمي - تجاهل السابق

public class TestBits { 

    public static void main(String[] args) { 

        byte bit1 = 0b00000001;     
        byte bit2 = 0b00000010;
        byte bit3 = 0b00000100;
        byte bit4 = 0b00001000;
        byte bit5 = 0b00010000;
        byte bit6 = 0b00100000;
        byte bit7 = 0b01000000;

        byte myValue = 9;                        // any value

        if (((myValue >>> 3) & bit1 ) != 0) {    //  shift 3 to test bit4
            System.out.println(" ON "); 
        }
    } 
}

Answer 13

أرمزت الطبقة الثابتة الصغيرة التي تقوم ببعض الأشياء في عملية البت.

public final class Bitfield {

  private Bitfield() {}

  // ********************************************************************
  // * TEST
  // ********************************************************************

  public static boolean testBit(final int pos, final int bitfield) {
      return (bitfield & (1 << pos)) == (1 << pos);
  }

  public static boolean testNum(final int num, final int bitfield) {
      return (bitfield & num) == num;
  }

  // ********************************************************************
  // * SET
  // ********************************************************************

  public static int setBit(final int pos, final int bitfield) {
     return bitfield | (1 << pos);
  }

  public static int addNum(final int number, final int bitfield) {
      return bitfield | number;
  }

  // ********************************************************************
  // * CLEAR
  // ********************************************************************

  public static int clearBit(final int pos, final int bitfield) {
      return bitfield ^ (1 << pos);
  }

  public static int clearNum(final int num, final int bitfield) {
      return bitfield ^ num;
  }

  }

إذا كانت هناك بعض الأسئلة تحلق حولها، فاكتب لي رسالة بريد إلكتروني.

برمجة جيدة!

Answer 14

القضاء على bitshifting وتعقيداتها واستخدام لوت من أجل اليمين and المعامل.