Java/Collections Data Structure/BitSet
Содержание
- 1 Another Bitset demo
- 2 BitOHoney
- 3 BitOps
- 4 Convert bitset to int array and string
- 5 Implementation of a bit map of any size, together with static methods to manipulate int, byte and byte[] values as bit maps
- 6 Java 1.5 (5.0) Changes to the API: several of the new bit manipulation methods in Integer.
- 7 Manipulating the BitSet
- 8 Operations on bit-mapped fields.
- 9 Operations on series of numbers
- 10 The use of BitSet
Another Bitset demo
<source lang="java">
/*
- Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002.
- All rights reserved. Software written by Ian F. Darwin and others.
- $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions
- are met:
- 1. Redistributions of source code must retain the above copyright
- notice, this list of conditions and the following disclaimer.
- 2. Redistributions 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.
- THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS""
- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
- BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- POSSIBILITY OF SUCH DAMAGE.
- Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee
- cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s,
- pioneering role in inventing and promulgating (and standardizing) the Java
- language and environment is gratefully acknowledged.
- The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for
- inventing predecessor languages C and C++ is also gratefully acknowledged.
- /
/** Show various forms of nested classes.
- Not all nested classes are "inner classes".
- /
public class A extends Object {
public class B { // member class
public class BB {
public void print() {
System.out.println("Hello from BB");
}
}
public void print() {
BB bb = new BB();
bb.print();
}
}
public void print() {
class C { // local class
}
Object d = new Object() {
// anonymous inner class
};
System.out.println("Here are an A, a B, a C, and d.");
System.out.println(this + " " + new B() + " " +
new C() + " " + d);
new B().print();
}
public static void main(String[] av) {
new A().print();
}
}
</source>
BitOHoney
<source lang="java">
import java.util.BitSet; public class BitOHoney1 {
public static void main(String args[]) {
String names[] = { "Hershey"s Kisses", "Nestle"s Crunch", "Snickers",
"3 Musketeers", "Milky Way", "Twix", "Mr. Goodbar", "Crunchie",
"Godiva", "Charleston Chew", "Cadbury"s", "Lindt", "Aero",
"Hebert", "Toberlone", "Smarties", "LifeSavers", "Riesen",
"Goobers", "Raisenettes", "Nerds", "Tootsie Roll",
"Sweet Tarts", "Cotton Candy" };
BitSet bits = new BitSet();
for (int i = 0, n = names.length; i < n; i++) {
if ((names[i].length() % 2) == 0) {
bits.set(i);
}
}
System.out.println(bits);
System.out.println("Size : " + bits.size());
System.out.println("Length: " + bits.length());
for (int i = 0, n = names.length; i < n; i++) {
if (!bits.get(i)) {
System.out.println(names[i] + " is odd");
}
}
BitSet bites = new BitSet();
bites.set(0);
bites.set(1);
bites.set(2);
bites.set(3);
bites.andNot(bits);
System.out.println(bites);
}
}
</source>
BitOps
<source lang="java">
import java.util.BitSet; public class BitOps {
public static void main(String args[]) {
BitSet set = new BitSet();
set.set(1);
set.set(2);
set.set(3);
set.set(4);
set.set(5);
System.out.println(set);
BitSet set2 = new BitSet();
set2.set(1);
set2.set(3);
set2.set(5);
set2.set(7);
BitSet set3 = (BitSet) set.clone();
set3.and(set2);
System.out.println(set3);
set3 = (BitSet) set.clone();
set3.or(set2);
System.out.println(set3);
set3 = (BitSet) set.clone();
set3.xor(set2);
System.out.println(set3);
set3 = (BitSet) set.clone();
set3.andNot(set2);
System.out.println(set3);
set3.andNot(null);
}
}
</source>
Convert bitset to int array and string
<source lang="java">
import java.util.BitSet; public class Main {
public static void main(String[] args) {
BitSet bs = new BitSet();
bs.set(31);
bs.set(15);
bs.set(18);
int[] intArray = bits2Ints(bs);
for (int i = 0; i < intArray.length; i++)
System.out.println(toBinary(intArray[i]));
}
static int[] bits2Ints(BitSet bs) {
int[] temp = new int[bs.size() / 32];
for (int i = 0; i < temp.length; i++)
for (int j = 0; j < 32; j++)
if (bs.get(i * 32 + j))
temp[i] |= 1 << j;
return temp;
}
static String toBinary(int num) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 32; i++) {
sb.append(((num & 1) == 1) ? "1" : "0");
num >>= 1;
}
return sb.reverse().toString();
}
}
</source>
Implementation of a bit map of any size, together with static methods to manipulate int, byte and byte[] values as bit maps
<source lang="java">
/* Copyright (c) 2001-2009, The HSQL Development Group
* All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. * * Redistributions 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 the HSQL Development Group nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG, * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
/**
* Implementation of a bit map of any size, together with static methods to * manipulate int, byte and byte[] values as bit maps. * * @author Fred Toussi (fredt@users dot sourceforge.net) * @version 1.9.0 * @since 1.8.0
- /
public class BitMap {
int defaultCapacity;
int capacity;
int[] map;
int limitPos;
public BitMap(int initialCapacity) {
int words = initialCapacity / 32;
if (initialCapacity % 32 != 0) {
words++;
}
defaultCapacity = capacity = words * 32;
map = new int[words];
limitPos = 0;
}
public int size() {
return limitPos;
}
public void setSize(int size) {
limitPos = size;
}
/**
* Resets to blank with original capacity
*/
public void reset() {
map = new int[defaultCapacity / 32];
capacity = defaultCapacity;
limitPos = 0;
}
/**
* Sets pos and returns old value
*/
public int set(int pos) {
while (pos >= capacity) {
doubleCapacity();
}
if (pos >= limitPos) {
limitPos = pos + 1;
}
int windex = pos >> 5;
int mask = 0x80000000 >>> (pos & 0x1F);
int word = map[windex];
int result = (word & mask) == 0 ? 0
: 1;
map[windex] = (word | mask);
return result;
}
/**
* Unsets pos and returns old value
*/
public int unset(int pos) {
while (pos >= capacity) {
doubleCapacity();
}
if (pos >= limitPos) {
limitPos = pos + 1;
return 0;
}
int windex = pos >> 5;
int mask = 0x80000000 >>> (pos & 0x1F);
int word = map[windex];
int result = (word & mask) == 0 ? 0
: 1;
mask = ~mask;
map[windex] = (word & mask);
return result;
}
public int get(int pos) {
while (pos >= capacity) {
doubleCapacity();
}
if (pos >= limitPos) {
limitPos = pos + 1;
return 0;
}
int windex = pos >> 5;
int mask = 0x80000000 >>> (pos & 0x1F);
int word = map[windex];
return (word & mask) == 0 ? 0
: 1;
}
public boolean isSet(int pos) {
return get(pos) == 1;
}
public byte[] getBytes() {
byte[] buf = new byte[(limitPos + 7) / 8];
if (buf.length == 0) {
return buf;
}
for (int i = 0; ; ) {
int v = map[i / 4];
buf[i++] = (byte) (v >>> 24);
if (i == buf.length) {
break;
}
buf[i++] = (byte) (v >>> 16);
if (i == buf.length) {
break;
}
buf[i++] = (byte) (v >>> 8);
if (i == buf.length) {
break;
}
buf[i++] = (byte) v;
if (i == buf.length) {
break;
}
}
return buf;
}
private void doubleCapacity() {
int[] newmap = new int[map.length * 2];
capacity *= 2;
System.arraycopy(map, 0, newmap, 0, map.length);
map = newmap;
}
/**
* copy the byte value into the map at given position (0, 24)
*/
public static int setByte(int map, byte value, int pos) {
int intValue = (value & 0xff) << (24 - pos);
int mask = 0xff000000 >>> pos;
mask = ~mask;
map &= mask;
return (map | intValue);
}
public static int set(int map, int pos) {
int mask = 0x80000000 >>> pos;
return (map | mask);
}
public static byte set(byte map, int pos) {
int mask = 0x00000080 >>> pos;
return (byte) (map | mask);
}
public static int unset(int map, int pos) {
int mask = 0x80000000 >>> pos;
mask = ~mask;
return (map & mask);
}
public static boolean isSet(int map, int pos) {
int mask = 0x80000000 >>> pos;
return (map & mask) == 0 ? false
: true;
}
public static boolean isSet(byte map, int pos) {
int mask = 0x00000080 >>> pos;
return (map & mask) == 0 ? false
: true;
}
public static boolean isSet(byte[] map, int pos) {
int mask = 0x00000080 >>> (pos & 0x07);;
int index = pos / 8;
if (index >= map.length) {
return false;
}
byte b = map[index];
return (b & mask) == 0 ? false
: true;
}
public static void unset(byte[] map, int pos) {
int mask = 0x00000080 >>> (pos & 0x07);
mask = ~mask;
int index = pos / 8;
if (index >= map.length) {
return;
}
byte b = map[index];
map[index] = (byte) (b & mask);
}
public static void set(byte[] map, int pos) {
int mask = 0x00000080 >>> (pos & 0x07);
int index = pos / 8;
if (index >= map.length) {
return;
}
byte b = map[index];
map[index] = (byte) (b | mask);
}
/**
* AND count bits from source with map contents starting at pos
*/
public static void and(byte[] map, int pos, byte source, int count) {
int shift = pos & 0x07;
int mask = (source & 0xff) >>> shift;
int innermask = 0xff >> shift;
int index = pos / 8;
if (count < 8) {
innermask = innermask >>> (8 - count);
innermask = innermask << (8 - count);
}
mask &= innermask;
innermask = ~innermask;
if (index >= map.length) {
return;
}
byte b = map[index];
map[index] = (byte) (b & innermask);
b = (byte) (b & mask);
map[index] = (byte) (map[index] | b);
if (shift == 0) {
return;
}
shift = 8 - shift;
if (count > shift) {
mask = ((source & 0xff) << 8) >>> shift;
innermask = 0xff00 >>> shift;
innermask = ~innermask;
b = map[index + 1];
map[index + 1] = (byte) (b & innermask);
b = (byte) (b & mask);
map[index + 1] = (byte) (map[index + 1] | b);
}
}
/**
* OR count bits from source with map contents starting at pos
*/
public static void or(byte[] map, int pos, byte source, int count) {
int shift = pos & 0x07;
int mask = (source & 0xff) >>> shift;
int index = pos / 8;
if (index >= map.length) {
return;
}
byte b = (byte) (map[index] | mask);
map[index] = b;
if (shift == 0) {
return;
}
shift = 8 - shift;
if (count > shift) {
mask = ((source & 0xff) << 8) >>> shift;
b = (byte) (map[index + 1] | mask);
map[index + 1] = b;
}
}
/**
* overlay count bits from source on map contents starting at pos
*/
public static void overlay(byte[] map, int pos, byte source, int count) {
int shift = pos & 0x07;
int mask = (source & 0xff) >>> shift;
int innermask = 0xff >> shift;
int index = pos / 8;
if (count < 8) {
innermask = innermask >>> (8 - count);
innermask = innermask << (8 - count);
}
mask &= innermask;
innermask = ~innermask;
if (index >= map.length) {
return;
}
byte b = map[index];
b = (byte) (b & innermask);
map[index] = (byte) (b | mask);
if (shift == 0) {
return;
}
shift = 8 - shift;
if (count > shift) {
mask = ((source & 0xff) << 8) >>> shift;
innermask = 0xff00 >>> shift;
innermask = ~innermask;
b = map[index + 1];
b = (byte) (b & innermask);
map[index + 1] = (byte) (b | mask);
}
}
public static int compare(byte[] a, byte[] b) {
int shortLength = a.length > b.length ? b.length
: a.length;
for (int i = 0; i < shortLength; i++) {
if (a[i] == b[i]) {
continue;
}
return (((int) a[i]) & 0xff) > (((int) b[i]) & 0xff) ? 1
: -1;
}
if (a.length == b.length) {
return 0;
}
return a.length > b.length ? 1
: -1;
}
public static byte[] and(byte[] a, byte[] b) {
int length = a.length > b.length ? a.length
: b.length;
int shortLength = a.length > b.length ? b.length
: a.length;
byte[] map = new byte[length];
for (int i = 0; i < shortLength; i++) {
map[i] = (byte) (a[i] & b[i]);
}
return map;
}
public static byte[] or(byte[] a, byte[] b) {
int length = a.length > b.length ? a.length
: b.length;
int shortLength = a.length > b.length ? b.length
: a.length;
byte[] map = new byte[length];
if (length != shortLength) {
byte[] source = a.length > b.length ? a
: b;
System.arraycopy(source, shortLength, map, shortLength,
length - shortLength);
}
for (int i = 0; i < shortLength; i++) {
map[i] = (byte) (a[i] | b[i]);
}
return map;
}
public static byte[] xor(byte[] a, byte[] b) {
int length = a.length > b.length ? a.length
: b.length;
int shortLength = a.length > b.length ? b.length
: a.length;
byte[] map = new byte[length];
if (length != shortLength) {
byte[] source = a.length > b.length ? a
: b;
System.arraycopy(source, shortLength, map, shortLength,
length - shortLength);
}
for (int i = 0; i < shortLength; i++) {
map[i] = (byte) (a[i] ^ b[i]);
}
return map;
}
public static byte[] not(byte[] a) {
byte[] map = new byte[a.length];
for (int i = 0; i < a.length; i++) {
map[i] = (byte) ~a[i];
}
return map;
}
public static boolean hasAnyBitSet(byte[] map) {
for (int i = 0; i < map.length; i++) {
if (map[i] != 0) {
return true;
}
}
return false;
}
public static byte[] leftShift(byte[] map, int shiftBits) {
byte[] newMap = new byte[map.length];
int shiftBytes = shiftBits / 8;
if (shiftBytes >= map.length) {
return newMap;
}
shiftBits = shiftBits % 8;
if (shiftBits == 0) {
for (int i = 0, j = shiftBytes; j < map.length; i++, j++) {
newMap[i] = map[j];
}
} else {
for (int i = 0, j = shiftBytes; j < map.length; i++, j++) {
int shifted = (map[j] & 0xff) << shiftBits;
newMap[i] = (byte) shifted;
if (i > 0) {
newMap[i - 1] |= (byte) (shifted >>> 8);
}
}
}
return newMap;
}
}
</source>
Java 1.5 (5.0) Changes to the API: several of the new bit manipulation methods in Integer.
<source lang="java">
public class Bits {
public static void main(String args[]) {
int n = 170; // 10101010
System.out.println("Value in binary: 10101010");
System.out.println("Number of one bits: " + Integer.bitCount(n));
System.out.println("Highest one bit: " + Integer.highestOneBit(n));
System.out.println("Lowest one bit: " + Integer.lowestOneBit(n));
System.out.println("Number of leading zeros : " + Integer.numberOfLeadingZeros(n));
System.out.println("Number of trailing zeros : " +Integer.numberOfTrailingZeros(n));
System.out.println("\nBeginning with the value 1, " + "rotate left 16 times.");
n = 1;
for(int i=0; i < 16; i++) {
n = Integer.rotateLeft(n, 1);
System.out.println(n);
}
}
}
</source>
Manipulating the BitSet
<source lang="java">
import java.util.BitSet; public class TwoBitPlanets {
public static void main(String args[]) {
String names[] = { "Mercury", "Venus", "Earth", "Mars", "Jupiter",
"Saturn", "Uranus", "Neptune", "Pluto" };
int moons[] = { 0, 0, 1, 2, 16, 18, 17, 8, 1 };
int namesLen = names.length;
BitSet bits = new BitSet(namesLen);
for (int i = 0; i < namesLen; i++) {
if ((moons[i] % 2) == 0) {
bits.set(i);
}
}
for (int i = 0; i < namesLen; i++) {
System.out.println(names[i] + " Even # Moons (" + moons[i] + ")? "
+ bits.get(i));
}
}
}
</source>
Operations on bit-mapped fields.
<source lang="java">
/*
* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */
/**
*Operations on bit-mapped fields.
* * @author Apache Jakarta POI * @author Scott Sanders (sanders at apache dot org) * @author Marc Johnson (mjohnson at apache dot org) * @author Andrew C. Oliver (acoliver at apache dot org) * @author Stephen Colebourne * @author Pete Gieser * @author Gary Gregory * @since 2.0 * @version $Id: BitField.java 437554 2006-08-28 06:21:41Z bayard $ */
public class BitField {
private final int _mask; private final int _shift_count; /***
Creates a BitField instance.
*
* @param mask the mask specifying which bits apply to this
* BitField. Bits that are set in this mask are the bits
* that this BitField operates on
*/
public BitField(int mask) {
_mask = mask;
int count = 0;
int bit_pattern = mask;
if (bit_pattern != 0) {
while ((bit_pattern & 1) == 0) {
count++;
bit_pattern >>= 1;
}
}
_shift_count = count;
}
/**
* Obtains the value for the specified BitField, appropriately * shifted right.
**
Many users of a BitField will want to treat the specified * bits as an int value, and will not want to be aware that the * value is stored as a BitField (and so shifted left so many * bits).
*
* @see #setValue(int,int)
* @param holder the int data containing the bits we"re interested
* in
* @return the selected bits, shifted right appropriately
*/
public int getValue(int holder) {
return getRawValue(holder) >> _shift_count;
}
/**
* Obtains the value for the specified BitField, appropriately * shifted right, as a short.
**
Many users of a BitField will want to treat the specified * bits as an int value, and will not want to be aware that the * value is stored as a BitField (and so shifted left so many * bits).
*
* @see #setShortValue(short,short)
* @param holder the short data containing the bits we"re
* interested in
* @return the selected bits, shifted right appropriately
*/
public short getShortValue(short holder) {
return (short) getValue(holder);
}
/**
* Obtains the value for the specified BitField, unshifted.
*
* @param holder the int data containing the bits we"re
* interested in
* @return the selected bits
*/
public int getRawValue(int holder) {
return holder & _mask;
}
/**
* Obtains the value for the specified BitField, unshifted.
*
* @param holder the short data containing the bits we"re
* interested in
* @return the selected bits
*/
public short getShortRawValue(short holder) {
return (short) getRawValue(holder);
}
/**
* Returns whether the field is set or not.
**
This is most commonly used for a single-bit field, which is * often used to represent a boolean value; the results of using * it for a multi-bit field is to determine whether *any* of its * bits are set.
*
* @param holder the int data containing the bits we"re interested
* in
* @return true if any of the bits are set,
* else false
*/
public boolean isSet(int holder) {
return (holder & _mask) != 0;
}
/**
* Returns whether all of the bits are set or not.
**
This is a stricter test than {@link #isSet(int)},
* in that all of the bits in a multi-bit set must be set
* for this method to return true.
*
* @param holder the int data containing the bits we"re
* interested in
* @return true if all of the bits are set,
* else false
*/
public boolean isAllSet(int holder) {
return (holder & _mask) == _mask;
}
/**
* Replaces the bits with new values.
*
* @see #getValue(int)
* @param holder the int data containing the bits we"re
* interested in
* @param value the new value for the specified bits
* @return the value of holder with the bits from the value
* parameter replacing the old bits
*/
public int setValue(int holder, int value) {
return (holder & ~_mask) | ((value << _shift_count) & _mask);
}
/**
* Replaces the bits with new values.
*
* @see #getShortValue(short)
* @param holder the short data containing the bits we"re
* interested in
* @param value the new value for the specified bits
* @return the value of holder with the bits from the value
* parameter replacing the old bits
*/
public short setShortValue(short holder, short value) {
return (short) setValue(holder, value);
}
/**
* Clears the bits.
*
* @param holder the int data containing the bits we"re
* interested in
* @return the value of holder with the specified bits cleared
* (set to 0)
*/
public int clear(int holder) {
return holder & ~_mask;
}
/**
* Clears the bits.
*
* @param holder the short data containing the bits we"re
* interested in
* @return the value of holder with the specified bits cleared
* (set to 0)
*/
public short clearShort(short holder) {
return (short) clear(holder);
}
/**
* Clears the bits.
*
* @param holder the byte data containing the bits we"re
* interested in
*
* @return the value of holder with the specified bits cleared
* (set to 0)
*/
public byte clearByte(byte holder) {
return (byte) clear(holder);
}
/**
* Sets the bits.
*
* @param holder the int data containing the bits we"re
* interested in
* @return the value of holder with the specified bits set
* to 1
*/
public int set(int holder) {
return holder | _mask;
}
/**
* Sets the bits.
*
* @param holder the short data containing the bits we"re
* interested in
* @return the value of holder with the specified bits set
* to 1
*/
public short setShort(short holder) {
return (short) set(holder);
}
/**
* Sets the bits.
*
* @param holder the byte data containing the bits we"re
* interested in
*
* @return the value of holder with the specified bits set
* to 1
*/
public byte setByte(byte holder) {
return (byte) set(holder);
}
/**
* Sets a boolean BitField.
*
* @param holder the int data containing the bits we"re
* interested in
* @param flag indicating whether to set or clear the bits
* @return the value of holder with the specified bits set or
* cleared
*/
public int setBoolean(int holder, boolean flag) {
return flag ? set(holder) : clear(holder);
}
/**
* Sets a boolean BitField.
*
* @param holder the short data containing the bits we"re
* interested in
* @param flag indicating whether to set or clear the bits
* @return the value of holder with the specified bits set or
* cleared
*/
public short setShortBoolean(short holder, boolean flag) {
return flag ? setShort(holder) : clearShort(holder);
}
/**
* Sets a boolean BitField.
*
* @param holder the byte data containing the bits we"re
* interested in
* @param flag indicating whether to set or clear the bits
* @return the value of holder with the specified bits set or
* cleared
*/
public byte setByteBoolean(byte holder, boolean flag) {
return flag ? setByte(holder) : clearByte(holder);
}
}
</source>
Operations on series of numbers
<source lang="java">
import java.util.BitSet; public class NumSeries {
public static void main(String[] args) {
for (int i = 1; i <= months.length; i++)
System.out.println("Month # " + i);
for (int i = 0; i < months.length; i++)
System.out.println("Month " + months[i]);
BitSet b = new BitSet();
b.set(0); // January
b.set(3); // April
for (int i = 0; i<months.length; i++) {
if (b.get(i))
System.out.println("Month " + months[i] + " requested");
}
}
/** The names of the months. See Dates/Times chapter for a better way */
protected static String months[] = {
"January", "February", "March", "April",
"May", "June", "July", "August",
"September", "October", "November", "December"
};
}
</source>
The use of BitSet
<source lang="java">
import java.util.BitSet; public class BitOHoney {
public static void main(String args[]) {
String names[] = { "Java", "Source", "and",
"Support"};
BitSet bits = new BitSet();
for (int i = 0, n = names.length; i < n; i++) {
if ((names[i].length() % 2) == 0) {
bits.set(i);
}
}
System.out.println(bits);
System.out.println("Size : " + bits.size());
System.out.println("Length: " + bits.length());
for (int i = 0, n = names.length; i < n; i++) {
if (!bits.get(i)) {
System.out.println(names[i] + " is odd");
}
}
BitSet bites = new BitSet();
bites.set(0);
bites.set(1);
bites.set(2);
bites.set(3);
bites.andNot(bits);
System.out.println(bites);
}
}
</source>
