Java 7 Binary Literals

In this tutorials we are going to see the integral types (byte, short, int, and long ) in java 7. This tutorials is created by referring Oracle official web site.Some content is taken from there.

In Java 7, the integral types (byte, short, int, and long ) can also expressed using binary number system.To specify binary literal, add prefix 0b or 0B to the number.Example for binary literals:

1. 8-bit byte value :

byte b = (byte)0b00010001;

2. 16-bit short value :

short s = (short)0b1000100010001000;

3. 32-bit int values :

int i1 = 0b001;

int i2 = 0B100;

int i3 = 0b10001000101010100001000100010001;

4. 64-bit long values :

long l = (long)0b100010001010101000010001000100011000100010101010101000010001L;

Example program: program given below will give you the understanding of binary literals.

package com.ehowtonow.java7.literals;

public class BinaryLiterals {

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  byte b = (byte) 0b00010001;
  short s = (short) 0b1000100010001000;
  int i1 = 0b001;
  int i2 = 0B100;
  int i3 = 0b10100001010001011010000101000101;
  long l = (long) 0b100010001010101000010001000100011000100010101010101000010001L;

  System.out.println("Java 7 Binary literals");
  System.out.println("byte b = " + b);
  System.out.println("short s = " + s);
  System.out.println("int i1 = " + i1);
  System.out.println("int i2 = " + i2);
  System.out.println("int i3 = " + i3);
  System.out.println("long l = " + l);

 }

}

Output
Java 7 Binary literals
byte b = 17
short s = -30584
int i1 = 1
int i2 = 4
int i3 = -1589272251
long l = 615481393887750673

Binary literals can make relationships among data more apparent than they would be in hexadecimal or octal.For example, each successive number in the following array is rotated by one bit.

public static final int[] arr = {
  0b00110001,
  0b01100010,
  0b11000100,
  0b10001001,
  0b00010011,
  0b00100110,
  0b01001100,
  0b10011000
}

In hexadecimal, the relationship among the numbers is not readily apparent:

public static final int[] arr = {

    0x31, 0x62, 0xC4, 0x89, 0x13, 0x26, 0x4C, 0x98

}

You can use binary integral constants in code that you can verify against a specifications document, such as a simulator for a hypothetical 8-bit microprocessor:

public State decoder(int instruction, State state) {
  if ((instruction & 0b11100000) == 0b00000000) {
    final int register = instruction & 0b00001111;
    switch (instruction & 0b11110000) {
      case 0b00000000: return state.nop();
      case 0b00010000: return state.copyAccumTo(register);
      case 0b00100000: return state.addToAccum(register);
      case 0b00110000: return state.subFromAccum(register);
      case 0b01000000: return state.multiplyAccumBy(register);
      case 0b01010000: return state.divideAccumBy(register);
      case 0b01100000: return state.setAccumFrom(register);
      case 0b01110000: return state.returnFromCall();
      default: throw new IllegalArgumentException();
    }
  } else {
    final int address = instruction & 0b00011111;
    switch (instruction & 0b11100000) {
      case 0b00100000: return state.jumpTo(address);
      case 0b01000000: return state.jumpIfAccumZeroTo(address);
      case 0b01000000: return state.jumpIfAccumNonzeroTo(address);
      case 0b01100000: return state.setAccumFromMemory(address);
      case 0b10100000: return state.writeAccumToMemory(address);
      case 0b11000000: return state.callTo(address);
      default: throw new IllegalArgumentException();
    }
  }
}

You can use binary literals to make a bitmap more readable:

public static final short[] SHORT_ARR= {
   (short)0b0000011111100000,
   (short)0b0000100000010000,
   (short)0b0001000000001000,
   (short)0b0010000000000100,
   (short)0b0100000000000010,
   (short)0b1000011001100001,
   (short)0b1000011001100001,
   (short)0b1000000000000001,
   (short)0b1000000000000001,
   (short)0b1001000000001001,
   (short)0b1000100000010001,
   (short)0b0100011111100010,
   (short)0b0010000000000100,
   (short)0b0001000000001000,
   (short)0b0000100000010000,
   (short)0b0000011111100000

}

Note : some content in this tutorials is taken from Oracle official web site


Posts You may Like

  1. Java 7 Binary Literals
  2. Sending HTML Email using Java Mail API
  3. How to retrieve present working directory using Java
  4. How to format the String by using Locale
  5. Log4j Architecture
  6. How to add value to all types of Collections
  7. How to compare two file paths using Java
  8. How to validate Username using Java Regular Expression
  9. Java Data type and Identifier
  10. Java Tutorial – Java Introduction
  11. How to get File Last modified Date in Java
  12. How to find last occurrence of substring inside string
  13. How to get Character unicode point in a String
  14. How to create temp file using Java
  15. Java 8 Stream has already been operated upon or closed

Be the first to comment

Leave a Reply

Your email address will not be published.


*