How to use

toBinaryString

method

in

java.lang.Long

/**
 * 获得数字对应的二进制字符串
 * 
 * @param number 数字
 * @return 二进制字符串
 */
public static String getBinaryStr(Number number) {
  if (number instanceof Long) {
    return Long.toBinaryString((Long) number);
  } else if (number instanceof Integer) {
    return Integer.toBinaryString((Integer) number);
  } else {
    return Long.toBinaryString(number.longValue());
  }
}

 public static void print(double d){
  System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d)));
}

@Override
public String apply(Number input) {
 if (input instanceof Long) {
  return "0b" + Long.toBinaryString(input.longValue()) + "L";
 }
 if (input instanceof Integer) {
  return "0b" + Integer.toBinaryString(input.intValue());
 }
 throw new IllegalArgumentException("unsupported non integer or long " + input);
}

 float f = 0.27f;
double d2 = (double) f;
double d3 = 0.27d;

System.out.println(Integer.toBinaryString(Float.floatToRawIntBits(f)));
System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d2)));
System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d3)));

  /**
   * return binary string of bitbuf
   */
  public String toString() {
    String s = "00000000000000000000000000000000" + Long.toBinaryString(bitbuf);
    s = s.substring(s.length() - 32);
    return s.substring(0, 8) + " " + s.substring(8, 16)
        + " " + s.substring(16, 24) + " " + s.substring(24, 32)
        + " " + bitsLeft;
  }
}

@Override
protected String toStringOf(Long l) {
 return toGroupedBinary(Long.toBinaryString(l), 64);
}

public static String toBinaryString(int value) {
  String formatted = Long.toBinaryString( value );
  StringBuilder buf = new StringBuilder( StringHelper.repeat( '0', 32 ) );
  buf.replace( 64 - formatted.length(), 64, formatted );
  return buf.toString();
}

  public static String toBinaryString(long value) {
    String formatted = Long.toBinaryString( value );
    StringBuilder buf = new StringBuilder( StringHelper.repeat( '0', 64 ) );
    buf.replace( 64 - formatted.length(), 64, formatted );
    return buf.toString();
  }
}

protected String toStringOf(Double d) {
 return toGroupedBinary(Long.toBinaryString(Double.doubleToRawLongBits(d)), 64);
}

@Override
public void writeLong(BlockBuilder blockBuilder, long value)
{
  try {
    toIntExact(value);
  }
  catch (ArithmeticException e) {
    throw new PrestoException(GENERIC_INTERNAL_ERROR, format("Value (%sb) is not a valid single-precision float", Long.toBinaryString(value).replace(' ', '0')));
  }
  blockBuilder.writeInt((int) value).closeEntry();
}

@Override
public void writeLong(BlockBuilder blockBuilder, long value)
{
  try {
    toIntExact(value);
  }
  catch (ArithmeticException e) {
    throw new PrestoException(GENERIC_INTERNAL_ERROR, format("Value (%sb) is not a valid single-precision float", Long.toBinaryString(value).replace(' ', '0')));
  }
  blockBuilder.writeInt((int) value).closeEntry();
}

/** 测试 */
public static void main(String[] args) {
  SnowflakeIdWorker idWorker = new SnowflakeIdWorker(0, 0);
  for (int i = 0; i < 1000; i++) {
    long id = idWorker.nextId();
    System.out.println(Long.toBinaryString(id));
    System.out.println(id);
  }
}

public static BuilderInstruction buildConstant(double value, int register) {
  long longBits = Double.doubleToLongBits(value);
  String binaryValue = Long.toBinaryString(longBits);
  BuilderInstruction result;
  if (binaryValue.endsWith(LAST_48_BITS_ZERO)) {
    result = new BuilderInstruction21lh(Opcode.CONST_WIDE_HIGH16, register, longBits);
  } else {
    result = new BuilderInstruction51l(Opcode.CONST_WIDE, register, longBits);
  }
  return result;
}

private static String dumpRef(long ref) {
 return StringUtils.leftPad(Long.toBinaryString(ref), 64, "0") + " o="
   + Ref.getOffset(ref) + " s=" + Ref.getStateByte(ref) + " l=" + Ref.hasList(ref)
   + " h=" + Long.toBinaryString(Ref.getHashBits(ref));
}

static String toString(Collection<Long> cuboids) {
  StringBuilder buf = new StringBuilder();
  buf.append("[");
  for (Long l : cuboids) {
    if (buf.length() > 1)
      buf.append(",");
    buf.append(l).append("(").append(Long.toBinaryString(l)).append(")");
  }
  buf.append("]");
  return buf.toString();
}

@Test
public void testStableIdCalculation() {
 mLayoutOutput.setComponent(mTestComponent);
 long stableId =
   calculateLayoutOutputId(mLayoutOutput, LEVEL_TEST, OutputUnitType.CONTENT, SEQ_TEST);
 long stableIdSeq2 =
   calculateLayoutOutputId(
     mLayoutOutput, LEVEL_TEST + 1, OutputUnitType.CONTENT, SEQ_TEST + 1);
 assertThat(toBinaryString(stableId)).isEqualTo("100000001000000000000000001");
 assertThat(toBinaryString(stableIdSeq2)).isEqualTo("100000010000000000000000010");
}

@Test
public void testStableIdCalculation() {
 mVisibilityOutput.setComponent(mComponent);
 long stableId = calculateVisibilityOutputId(
   mVisibilityOutput,
   LEVEL_TEST,
   SEQ_TEST);
 long stableIdSeq2 = calculateVisibilityOutputId(
   mVisibilityOutput,
   LEVEL_TEST + 1,
   SEQ_TEST + 1);
 assertThat(toBinaryString(stableId)).isEqualTo("100000001000000000000000001");
 assertThat(toBinaryString(stableIdSeq2)).isEqualTo("100000010000000000000000010");
}

@Test
public void testStableIdForegroundType() {
 mLayoutOutput.setComponent(mTestComponent);
 mLayoutOutput.setId(
   calculateLayoutOutputId(mLayoutOutput, LEVEL_TEST, OutputUnitType.FOREGROUND, SEQ_TEST));
 long stableId = mLayoutOutput.getId();
 assertThat(toBinaryString(stableId)).isEqualTo("100000001100000000000000001");
}

@Test
public void testStableIdBackgroundType() {
 mLayoutOutput.setComponent(mTestComponent);
 mLayoutOutput.setId(
   calculateLayoutOutputId(mLayoutOutput, LEVEL_TEST, OutputUnitType.BACKGROUND, SEQ_TEST));
 long stableId = mLayoutOutput.getId();
 assertThat(toBinaryString(stableId)).isEqualTo("100000001010000000000000001");
}

@Test
public void testStableIdHostType() {
 mLayoutOutput.setComponent(mTestComponent);
 mLayoutOutput.setId(
   calculateLayoutOutputId(mLayoutOutput, LEVEL_TEST, OutputUnitType.HOST, SEQ_TEST));
 long stableId = mLayoutOutput.getId();
 assertThat(toBinaryString(stableId)).isEqualTo("100000001110000000000000001");
}