Java/Language Basics/Binary Bit — различия между версиями
Admin (обсуждение | вклад) м (1 версия) |
|
(нет различий)
|
Текущая версия на 09:47, 1 июня 2010
Содержание
- 1 Binary Digits
- 2 Bit-level unpacking of floating-point data
- 3 Bitwise AND (&)
- 4 Bitwise complement (~): inverts ones and zeroes in a number
- 5 Bitwise Demo
- 6 Bitwise OR (|)
- 7 Bitwise XOR (^)
- 8 Convert a number to negative and back
- 9 Converting Between a BitSet and a Byte Array
- 10 Left shift (<<)
- 11 Performing Bitwise Operations on a Bit Vector
- 12 Returns a byte array of at least length 1
- 13 Shift to the left
- 14 Signed shift to the right
- 15 Unsigned shift to the right
- 16 Using the bitwise operators
- 17 Utility for byte swapping of all java data types
Binary Digits
<source lang="java">
/**
* 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)); //- }
}
</source>
Bit-level unpacking of floating-point data
<source lang="java">
/* 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 -->"); }
}
</source>
Bitwise AND (&)
<source lang="java">
public class Main {
public static void main(String[] a) { System.out.println(9 & 7); }
} //1
</source>
Bitwise complement (~): inverts ones and zeroes in a number
<source lang="java">
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
- /
</source>
Bitwise Demo
<source lang="java">
/* 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."); } }
}
</source>
Bitwise OR (|)
<source lang="java">
public class Main {
public static void main(String[] a) { System.out.println(19 | 7); }
} //23
</source>
Bitwise XOR (^)
<source lang="java">
public class Main {
public static void main(String[] a) { System.out.println(9 ^ 7); }
} //14
</source>
Convert a number to negative and back
<source lang="java">
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
- /
</source>
Converting Between a BitSet and a Byte Array
<source lang="java">
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}
</source>
Left shift (<<)
<source lang="java">
public class Main {
public static void main(String[] a) { System.out.println(9 << 7); }
} //1152
</source>
Performing Bitwise Operations on a Bit Vector
<source lang="java">
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); }
}
</source>
Returns a byte array of at least length 1
<source lang="java">
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; }
}
</source>
Shift to the left
<source lang="java">
public class Main {
public static void main(String[] args) { byte b = 11; System.out.println(b << 1); }
}
</source>
Signed shift to the right
<source lang="java">
public class Main {
public static void main(String[] argv) throws Exception { byte b = 11; System.out.println(b >> 1); }
}
</source>
Unsigned shift to the right
<source lang="java">
public class Main {
public static void main(String[] argv) throws Exception { byte b = 11; System.out.println(b >>> 1); }
}
</source>
Using the bitwise operators
<source lang="java">
//: 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(); }
} ///:~
</source>
Utility for byte swapping of all java data types
<source lang="java">
/*
* (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]); }
}
</source>