Java/Language Basics/Binary Bit

Binary Digits

 
/**
 * Template for standalone, line-mode main program.
 * @author Ian F. Darwin, http://www.darwinsys.ru/
 * @version $Id: BinaryDigits.java,v 1.3 2004/02/09 03:33:56 ian Exp $
 */
public class BinaryDigits {
  public static void main(String[] argv) {
    //+
    String bin = "101010";
    System.out.println(bin + " as an integer is " + Integer.valueOf(bin, 2));
    int i = 42;
    System.out.println(i + " as binary digits (bits) is " + 
      Integer.toBinaryString(i));
    //-
  }
}

Bit-level unpacking of floating-point data

 
/*
Java Programming for Engineers
Julio Sanchez
Maria P. Canton

ISBN: 0849308100
Publisher: CRC Press
*/
// Java for Engineers
//Filename: BitOps
//Reference: Chapter 24
//Description:
//         Bit-level unpacking of floating-pioint data
//Requires:
//         Keyin class in current directory

class BitOps {
  public static void main(String[] args) {
    // Definition of bit field masks for double
    final long SIGN = 0x8000000000000000L;
    final long EXPN = 0x7ff0000000000000L;
    final long SGNF = 0x000fffffffffffffL;
    final long BIT1 = 0x8000000000000000L;
    // Storage for bit fields
    long s; // Sign
    long e; // Exponent field
    long m; // Significand (mantissa) field
    String eS; // For conversions
    double num;
    long binVal;
    long t;
    // Get user input
    num = 3.4d;
    binVal = Double.doubleToRawLongBits(num);
    // Display hex bits
    System.out.println("As long = " + Long.toHexString(binVal));
    // Display bit fields of double format
    s = binVal & SIGN;
    if (s != 0)
      System.out.println("Sign = -");
    else
      System.out.println("Sign = +");
    // Mask out exponent field
    e = (binVal & EXPN);
    eS = Long.toHexString(e);
    System.out.println("Exponent = " + eS);
    // Mask out significand field
    m = (binVal & SGNF);
    eS = Long.toHexString(m);
    System.out.println("Significand = " + eS);
    System.out.println("\nFields in binary");
    if (s != 0)
      System.out.println("Sign bit = 1");
    else
      System.out.println("Sign bit = 0");
    // Display binary exponent
    // Eliminate sign bit
    e = e << 1;
    System.out.print("Exponent = ");
    for (int k = 0; k < 11; k++) {
      t = e & BIT1;
      // System.out.println(Long.toHexString(t));
      if (t != 0)
        System.out.print("1");
      else
        System.out.print("0");
      e = e << 1;
    }
    System.out.println("\n           |-11 bits-|");
    // Display binary significand
    // Eliminate exponent and sign bits
    m = m << 12;
    System.out.print("Significand = 1.");
    for (int j = 0; j < 51; j++) {
      t = m & BIT1;
      if (t != 0)
        System.out.print("1");
      else
        System.out.print("0");
      m = m << 1;
    }
    System.out.println("\n              ^ |");
    System.out.println("implicit bit -| | ----- 52 bits -->");
  }
}

Bitwise AND (&)

 

public class Main {
  public static void main(String[] a) {
    System.out.println(9 & 7);
  }
}
//1

Bitwise complement (~): inverts ones and zeroes in a number

 
public class Main {
  public static void main(String[] a) {
    int i = 1;
    System.out.println(i);
    int j = ~i + 1;
    System.out.println(j);
    i = ~j + 1;
    System.out.println(i);
  }
}
/*
1
-1
1
*/

Bitwise Demo

 
/* From http://java.sun.ru/docs/books/tutorial/index.html */
/*
 * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * -Redistribution of source code must retain the above copyright notice, this
 *  list of conditions and the following disclaimer.
 *
 * -Redistribution in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *
 * Neither the name of Sun Microsystems, Inc. or the names of contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
 * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
 * OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN")
 * AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE
 * AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
 * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST
 * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
 * INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY
 * OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * You acknowledge that this software is not designed, licensed or intended
 * for use in the design, construction, operation or maintenance of any
 * nuclear facility.
 */
public class BitwiseDemo {
    static final int VISIBLE = 1;
    static final int DRAGGABLE = 2;
    static final int SELECTABLE = 4;
    static final int EDITABLE = 8;
    public static void main(String[] args)
    {
        int flags = 0;
        flags = flags | VISIBLE;
        flags = flags | DRAGGABLE;
        if ((flags & VISIBLE) == VISIBLE) {
            if ((flags & DRAGGABLE) == DRAGGABLE) {
                 System.out.println("Flags are Visible and Draggable.");
            }
        }
        flags = flags | EDITABLE;
        if ((flags & EDITABLE) == EDITABLE) {
      System.out.println("Flags are now also Editable.");
        }
    }
}

Bitwise OR (|)

 
public class Main {
  public static void main(String[] a) {
    System.out.println(19 | 7);
  }
}
//23

Bitwise XOR (^)

 
public class Main {
  public static void main(String[] a) {
    System.out.println(9 ^ 7);
  }
}
//14

Convert a number to negative and back

 
public class Main {
  public static void main(String[] a) {
    int i = 1;
    System.out.println(i);
    int j = ~i + 1;
    System.out.println(j);
    i = ~j + 1;
    System.out.println(i);
  }
}
/*
1
-1
1
*/

Converting Between a BitSet and a Byte Array

 
import java.util.BitSet;
public class Main {
  public static void main(String[] argv) throws Exception {
     System.out.println(fromByteArray(new byte[]{1,2,3}));
  }
  // Returns a bitset containing the values in bytes.
  public static BitSet fromByteArray(byte[] bytes) {
    BitSet bits = new BitSet();
    for (int i = 0; i < bytes.length * 8; i++) {
      if ((bytes[bytes.length - i / 8 - 1] & (1 << (i % 8))) > 0) {
        bits.set(i);
      }
    }
    return bits;
  }
}
//{0, 1, 9, 16}

Left shift (<<)

 
public class Main {
  public static void main(String[] a) {
    System.out.println(9 << 7);
  }
}
//1152

Performing Bitwise Operations on a Bit Vector

 
import java.util.BitSet;
public class Main {
  public static void main(String[] argv) throws Exception {
    // Create the bitset
    BitSet bits = new BitSet();
    // Set a bit on
    bits.set(2); 
    // Retrieving the value of a bit
    boolean b = bits.get(0); 
    b = bits.get(2); 
    // Clear a bit
    bits.clear(1);
    // Setting a range of bits
    BitSet bits2 = new BitSet();
    bits2.set(1, 4); 
    // And"ing two bitsets
    bits.and(bits2); 
    // Xor"ing two bitsets
    bits.xor(bits2); 
    // Flip all bits in the bitset
    bits.flip(0, bits.length()); 
    // Andnot"ing two bitsets
    bits.andNot(bits2); 
    // Or"ing two bitsets
    bits.or(bits2); 
  }
}

Returns a byte array of at least length 1

 

import java.util.BitSet;
public class Main {
  public static void main(String[] argv) throws Exception {
    BitSet bitset = new BitSet();
    bitset.set(1);
    System.out.println(toByteArray(bitset));
  }
  public static byte[] toByteArray(BitSet bits) {
    byte[] bytes = new byte[bits.length() / 8 + 1];
    for (int i = 0; i < bits.length(); i++) {
      if (bits.get(i)) {
        bytes[bytes.length - i / 8 - 1] |= 1 << (i % 8);
      }
    }
    return bytes;
  }
}

Shift to the left

 
public class Main {
  public static void main(String[] args) {
    byte b = 11;
    System.out.println(b << 1); 
  }
}

Signed shift to the right

 
public class Main {
  public static void main(String[] argv) throws Exception {
    byte b = 11;
    System.out.println(b >> 1); 
  }
}

Unsigned shift to the right

 
public class Main {
  public static void main(String[] argv) throws Exception {
    byte b = 11;
    System.out.println(b >>> 1); 
  }
}

Using the bitwise operators

 
//: c03:BitManipulation.java
// Using the bitwise operators.
// From "Thinking in Java, 3rd ed." (c) Bruce Eckel 2002
// www.BruceEckel.ru. See copyright notice in CopyRight.txt.
import java.util.*;
public class BitManipulation {
  public static void main(String[] args) {
    Random rand = new Random();
    int i = rand.nextInt();
    int j = rand.nextInt();
    printBinaryInt("-1", -1);
    printBinaryInt("+1", +1);
    int maxpos = 2147483647;
    printBinaryInt("maxpos", maxpos);
    int maxneg = -2147483648;
    printBinaryInt("maxneg", maxneg);
    printBinaryInt("i", i);
    printBinaryInt("~i", ~i);
    printBinaryInt("-i", -i);
    printBinaryInt("j", j);
    printBinaryInt("i & j", i & j);
    printBinaryInt("i | j", i | j);
    printBinaryInt("i ^ j", i ^ j);
    printBinaryInt("i << 5", i << 5);
    printBinaryInt("i >> 5", i >> 5);
    printBinaryInt("(~i) >> 5", (~i) >> 5);
    printBinaryInt("i >>> 5", i >>> 5);
    printBinaryInt("(~i) >>> 5", (~i) >>> 5);
    long l = rand.nextLong();
    long m = rand.nextLong();
    printBinaryLong("-1L", -1L);
    printBinaryLong("+1L", +1L);
    long ll = 9223372036854775807L;
    printBinaryLong("maxpos", ll);
    long lln = -9223372036854775808L;
    printBinaryLong("maxneg", lln);
    printBinaryLong("l", l);
    printBinaryLong("~l", ~l);
    printBinaryLong("-l", -l);
    printBinaryLong("m", m);
    printBinaryLong("l & m", l & m);
    printBinaryLong("l | m", l | m);
    printBinaryLong("l ^ m", l ^ m);
    printBinaryLong("l << 5", l << 5);
    printBinaryLong("l >> 5", l >> 5);
    printBinaryLong("(~l) >> 5", (~l) >> 5);
    printBinaryLong("l >>> 5", l >>> 5);
    printBinaryLong("(~l) >>> 5", (~l) >>> 5);
  }
  static void printBinaryInt(String s, int i) {
    System.out.println(
      s + ", int: " + i + ", binary: ");
    System.out.print("   ");
    for(int j = 31; j >= 0; j--)
      if(((1 << j) &  i) != 0)
        System.out.print("1");
      else
        System.out.print("0");
    System.out.println();
  }
  static void printBinaryLong(String s, long l) {
    System.out.println(
      s + ", long: " + l + ", binary: ");
    System.out.print("   ");
    for(int i = 63; i >= 0; i--)
      if(((1L << i) & l) != 0)
        System.out.print("1");
      else
        System.out.print("0");
    System.out.println();
  }
} ///:~

Utility for byte swapping of all java data types

 
/*
 * (C) 2004 - Geotechnical Software Services
 * 
 * This code is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public 
 * License as published by the Free Software Foundation; either 
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This code is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public 
 * License along with this program; if not, write to the Free 
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, 
 * MA  02111-1307, USA.
 */
//package no.geosoft.cc.util;

/**
 * Utility class for doing byte swapping (i.e. conversion between
 * little-endian and big-endian representations) of different data types.
 * Byte swapping is typically used when data is read from a stream 
 * delivered by a system of different endian type as the present one.
 * 
 * @author 
 */   
public class ByteSwapper
{
  /**
   * Byte swap a single short value.
   * 
   * @param value  Value to byte swap.
   * @return       Byte swapped representation.
   */
  public static short swap (short value)
  {
    int b1 = value & 0xff;
    int b2 = (value >> 8) & 0xff;
    return (short) (b1 << 8 | b2 << 0);
  }
  
  /**
   * Byte swap a single int value.
   * 
   * @param value  Value to byte swap.
   * @return       Byte swapped representation.
   */
  public static int swap (int value)
  {
    int b1 = (value >>  0) & 0xff;
    int b2 = (value >>  8) & 0xff;
    int b3 = (value >> 16) & 0xff;
    int b4 = (value >> 24) & 0xff;
    return b1 << 24 | b2 << 16 | b3 << 8 | b4 << 0;
  }
  
  /**
   * Byte swap a single long value.
   * 
   * @param value  Value to byte swap.
   * @return       Byte swapped representation.
   */
  public static long swap (long value)
  {
    long b1 = (value >>  0) & 0xff;
    long b2 = (value >>  8) & 0xff;
    long b3 = (value >> 16) & 0xff;
    long b4 = (value >> 24) & 0xff;
    long b5 = (value >> 32) & 0xff;
    long b6 = (value >> 40) & 0xff;
    long b7 = (value >> 48) & 0xff;
    long b8 = (value >> 56) & 0xff;
    return b1 << 56 | b2 << 48 | b3 << 40 | b4 << 32 |
           b5 << 24 | b6 << 16 | b7 <<  8 | b8 <<  0;
  }
  
  
  /**
   * Byte swap a single float value.
   * 
   * @param value  Value to byte swap.
   * @return       Byte swapped representation.
   */
  public static float swap (float value)
  {
    int intValue = Float.floatToIntBits (value);
    intValue = swap (intValue);
    return Float.intBitsToFloat (intValue);
  }
  
  /**
   * Byte swap a single double value.
   * 
   * @param value  Value to byte swap.
   * @return       Byte swapped representation.
   */
  public static double swap (double value)
  {
    long longValue = Double.doubleToLongBits (value);
    longValue = swap (longValue);
    return Double.longBitsToDouble (longValue);
  }

  
  /**
   * Byte swap an array of shorts. The result of the swapping
   * is put back into the specified array.
   *
   * @param array  Array of values to swap
   */
  public static void swap (short[] array)
  {
    for (int i = 0; i < array.length; i++)
      array[i] = swap (array[i]);
  }
  
  
  /**
   * Byte swap an array of ints. The result of the swapping
   * is put back into the specified array.
   * 
   * @param array  Array of values to swap
   */
  public static void swap (int[] array)
  {
    for (int i = 0; i < array.length; i++)
      array[i] = swap (array[i]);
  }

  
  /**
   * Byte swap an array of longs. The result of the swapping
   * is put back into the specified array.
   * 
   * @param array  Array of values to swap
   */
  public static void swap (long[] array)
  {
    for (int i = 0; i < array.length; i++)
      array[i] = swap (array[i]);
  }

  
  /**
   * Byte swap an array of floats. The result of the swapping
   * is put back into the specified array.
   * 
   * @param array  Array of values to swap
   */
  public static void swap (float[] array)
  {
    for (int i = 0; i < array.length; i++)
      array[i] = swap (array[i]);
  }

  
  /**
   * Byte swap an array of doubles. The result of the swapping
   * is put back into the specified array.
   * 
   * @param array  Array of values to swap
   */
  public static void swap (double[] array)
  {
    for (int i = 0; i < array.length; i++)
      array[i] = swap (array[i]);
  }
}