Note 5/22/08:I still find it pretty incredible that I could take two years worth of CS classes and not have any class really discuss what a compiler is and the mechanics of acquiring and working one. At the time I wrote the last two paragraphs, I still thought that TextPad was the compiler and had no idea how what JDK was, even though I was told I would need it! I was just so relieved that I could finally get some programming done.
This situation was similar to my high school drivers' ed class, where the teacher assumed we already knew how to drive, and told us to just take off. I had never even started a car.
4/17/09 Update: I have started teaching web programming at Dickinson Lifelong Learning Center. It is my hope for my classes that I give enough background to allow my students to grasp the principles of programming, not just the rote information.
I recommend dowloading TextPad. This class doesn't
exactly leave much time to be learning about compilers. In fact,
that is one thing that would be really helpful about the whole CS
program - a week's worth of explanation about compilers. Considering
that being able to compiler a program has some significance to learning
how to program, this might be a good topic to cover in some class!
I got myself about a week behind trying to figure
out the Sun stuff and then another week behind trying to figure
out JCreator. I'm sure it's a fine program, but who has time to
learn it. With TextPad, 1) you write your program, 2) Ctrl 1 to
compile, 3) Ctrl 2 to run. When your program doesn't compile, it's
pretty easy to follow the notes to figure out what's happening,
if you have some experience with debugging.
Here is an algorithm that converts a decimal
integer into its binary equivalent. Keep dividing the integer
by 2, keeping track of the remainders. Stop when the number is
0. Then write the remainders as a binary number, starting with
the last one. For example:
100 / 2 = 50 R 0
50 / 2 = 25 R 0
25 / 2 = 12 R 1
12 / 2 = 6 R 0
6 / 2 = 3 R 0
3 / 2 = 1 R 1
1 / 2 = 0 R 1
Therefore, 100 in decimal is 1100100 in binary.
To give credit where it is due, the title link
above takes you to the source of the algorithm. Now the question
is how to turn it into Java code. Well, here are some things to
think about:
Things to know:
- the modulus operator gives 0 on even division
- the modulus operator gives 1 when dividing by two when it's
not an even division because .5 rounds up to 1
- a new BitSet is all 0's
- BitSet has a method that will change a particular
0 to 1 if you tell it which one to change
- BitSet has a bunch of other set methods, but they only work
if you send other parameters (besides the index).
Data storage (variables you will need):
- store the rule passed in
- store the halved number
- store the remainder
- store a BitSet to pass on
- store a counter to run through 8 bits in the BitSet
What to do:
- divide the rule by 2
- if it divides evenly, you just want a 0, so don't do anything
- if it doesn't divide evenly, you want to change that index to
1
- be careful you are starting at the correct end of the BitSet
There are other ways to do this
Don't forget to check the passed in number
to make sure it's between 0 and 255
Don't forget to comment your code.
Converting
the First BitSet into a Different BitSet with a Secret Code/Shell
Game
OK, so here we play a secret code game with our
BitSet so it transforms into a different BitSet. It's kind of like
one of those books for kids that gives them all sorts of ways to
pass test answers back and forth in code. Of couse, if they'd spend
less time figuring out how to change the answers into code, they
could spend more time learning answers. In any case, we
get to learn how to change BitSet(1) into BitSet(2).
The magic decoder ring is:
Take the digits 1 - 8 (because we have 8 slots
to fill with new binary)
Jump back 1 space (just like doing arrays
that start with 0) to get 0 - 7
Write down the binary for each number:
000 001 010 011 100 101 110 111 (notice that there are 8 binary
numbers here)
Each one of those sets represents a single
decimal number. Rub #1 is that our original BitSet also only has
8 binary numbers. That means that in order to get three digits
we have to grab the one before, the digit in question and the
one after. Rub #2 is that the first digit doesn't have one before
and the last digit doesn't have one after.
Sooooooooooo, we play a shell game and grab
the last one and stick it in front and the first one and stick
it in back. Actually what we do is pretend that the 8 binary digits
are in a circle with a specific starting place - just like a magic
decoder ring!
That means that you have to figure out how
in the heck you are going to get that original 8 places to act
like 10. Maybe you could just make it 10 places!!! And wouldn't
you know, BitSet gives us methods for doing just that! If I weren't
a completely non-programming type, I'd get all excited and say
this is lots of fun ...
Stuff to hold in a variable
The Rule (gets passed in) from the Slider
value changed to a BitSet.
The previous Line (gets passed in). Remember
that the first line might be all 0's because whatever string was
started somewhere else might just be some new BitSet, which are
all 0's. Actually, since it gets passed in, it really doesn't
matter what the heck it is as long as it's a BitSet.
The a copy of the line with a copy of the
front digit from the rule stuck to the back and a copy of the
back digit stuck to the font.
A BitSet to hold three digits at a time from
the Line.
Some counters to remember what the indexes
are if you find a match.
Disclaimer: whether you need all those variables
depends on how you make this thing work. You're stuck with the first
two because they are handed to you when you enter the method. These
can take the form of BitSets, Strings, etc., again, depending on
how you implement.
The
Following is the Information about Class
BitSet - Reference 2
It's part of java.util
A
class implements the Cloneable interface to indicate to the
Object.clone() method that it is legal for that method to make
a field-for-field copy of instances of that class.
Reference 3
Class BitSet
java.lang.Object
java.util.BitSet
All Implemented Interfaces: Cloneable, Serializable
public class BitSet
extends
Object
implements Cloneable, Serializable
This class implements a vector of bits that grows as needed. Each
component of the bit set has a boolean value. The bits of a BitSet
are indexed by nonnegative integers. Individual indexed bits can
be examined, set, or cleared. One BitSet may be used to modify
the contents of another BitSet through logical AND, logical inclusive
OR, and logical exclusive OR operations.
By
default, all bits in the set initially have the value false.
Every
bit set has a current size, which is the number of bits of space
currently in use by the bit set. Note that the size is related
to the implementation of a bit set, so it may change with implementation.
The length of a bit set relates to logical length of a bit set
and is defined independently of implementation.
Unless
otherwise noted, passing a null parameter to any of the methods
in a BitSet will result in a NullPointerException. A BitSet is
not safe for multithreaded use without external synchronization.
BitSet(int
nbits)
Creates a bit set whose initial size is large enough to explicitly
represent bits with indices in the range 0 through nbits-1.
Method
Summary
void and(BitSet set)
Performs a logical AND of this target bit set with the argument
bit set.
void andNot(BitSet set)
Clears all of the bits in this BitSet whose corresponding bit
is set in the specified BitSet.
int cardinality()
Returns the number of bits set to true in this BitSet.
void clear()
Sets all of the bits in this BitSet to false.
void clear(int bitIndex)
Sets the bit specified by the index to false.
void clear(int fromIndex, int toIndex)
Sets the bits from the specified fromIndex(inclusive) to the specified
toIndex(exclusive) to false.
Object clone()
Cloning this BitSet produces a new BitSet that is equal to it.
boolean equals(Object obj)
Compares this object against the specified object.
void flip(int bitIndex)
Sets the bit at the specified index to to the complement of its
current value.
void flip(int fromIndex, int toIndex)
Sets each bit from the specified fromIndex(inclusive) to the specified
toIndex(exclusive) to the complement of its current value.
boolean get(int bitIndex)
Returns the value of the bit with the specified index.
BitSet get(int fromIndex, int toIndex)
Returns a new BitSet composed of bits from this BitSet from fromIndex(inclusive)
to toIndex(exclusive).
int hashCode()
Returns a hash code value for this bit set.
boolean intersects(BitSet set)
Returns true if the specified BitSet has any bits set to true
that are also set to true in this BitSet.
boolean isEmpty()
Returns true if this BitSet contains no bits that are set to true.
int length()
Returns the "logical size" of this BitSet: the index
of the highest set bit in the BitSet plus one.
int nextClearBit(int fromIndex)
Returns the index of the first bit that is set to false that occurs
on or after the specified starting index.
int nextSetBit(int fromIndex)
Returns the index of the first bit that is set to true that occurs
on or after the specified starting index.
void or(BitSet set)
Performs a logical OR of this bit set with the bit set argument.
void set(int bitIndex)
Sets the bit at the specified index to true.
void set(int bitIndex, boolean value)
Sets the bit at the specified index to the specified value.
void set(int fromIndex, int toIndex)
Sets the bits from the specified fromIndex(inclusive) to the specified
toIndex(exclusive) to true.
void set(int fromIndex, int toIndex, boolean value)
Sets the bits from the specified fromIndex(inclusive) to the specified
toIndex(exclusive) to the specified value.
int size()
Returns the number of bits of space actually in use by this BitSet
to represent bit values.
String
toString()
Returns a string representation of this bit set.
void
xor(BitSet set)
Performs a logical XOR of this bit set with the bit set argument.
Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait
Constructor Detail
BitSet
public BitSet()Creates a new bit set. All bits are initially false.
BitSet
public BitSet(int nbits)Creates a bit set whose initial size is
large enough to explicitly represent bits with indices in the range
0 through nbits-1. All bits are initially false.
Parameters:
nbits - the initial size of the bit set.
Throws:
NegativeArraySizeException - if the specified initial size is negative.
Method Detail
flip
public void flip(int bitIndex)Sets the bit at the specified index
to to the complement of its current value.
Parameters:
bitIndex - the index of the bit to flip.
Throws:
IndexOutOfBoundsException - if the specified index is negative.
Since:
1.4
flip
public void flip(int fromIndex,
int toIndex)Sets each bit from the specified fromIndex(inclusive)
to the specified toIndex(exclusive) to the complement of its current
value.
Parameters:
fromIndex - index of the first bit to flip.
toIndex - index after the last bit to flip.
Throws:
IndexOutOfBoundsException - if fromIndex is negative, or toIndex
is negative, or fromIndex is larger than toIndex.
Since:
1.4
set
public void set(int fromIndex,
int toIndex)Sets the bits from the specified fromIndex(inclusive)
to the specified toIndex(exclusive) to true.
Parameters:
fromIndex - index of the first bit to be set.
toIndex - index after the last bit to be set.
Throws:
IndexOutOfBoundsException - if fromIndex is negative, or toIndex
is negative, or fromIndex is larger than toIndex.
Since:
1.4
set
public void set(int fromIndex,
int toIndex,
boolean value)Sets the bits from the specified fromIndex(inclusive)
to the specified toIndex(exclusive) to the specified value.
Parameters:
fromIndex - index of the first bit to be set.
toIndex - index after the last bit to be set
value - value to set the selected bits to
Throws:
IndexOutOfBoundsException - if fromIndex is negative, or toIndex
is negative, or fromIndex is larger than toIndex.
Since:
1.4
clear
public void clear(int fromIndex,
int toIndex)Sets the bits from the specified fromIndex(inclusive)
to the specified toIndex(exclusive) to false.
Parameters:
fromIndex - index of the first bit to be cleared.
toIndex - index after the last bit to be cleared.
Throws:
IndexOutOfBoundsException - if fromIndex is negative, or toIndex
is negative, or fromIndex is larger than toIndex.
Since:
1.4
get
public boolean get(int bitIndex)Returns the value of the bit with
the specified index. The value is true if the bit with the index
bitIndex is currently set in this BitSet; otherwise, the result
is false.
Parameters:
bitIndex - the bit index.
Returns:
the value of the bit with the specified index.
Throws:
IndexOutOfBoundsException - if the specified index is negative.
get
public BitSet get(int fromIndex,
int toIndex)Returns a new BitSet composed of bits from this BitSet
from fromIndex(inclusive) to toIndex(exclusive).
Parameters:
fromIndex - index of the first bit to include.
toIndex - index after the last bit to include.
Returns:
a new BitSet from a range of this BitSet.
Throws:
IndexOutOfBoundsException - if fromIndex is negative, or toIndex
is negative, or fromIndex is larger than toIndex.
Since:
1.4
nextSetBit
public int nextSetBit(int fromIndex)Returns the index of the first
bit that is set to true that occurs on or after the specified starting
index. If no such bit exists then -1 is returned. To iterate over
the true bits in a BitSet, use the following loop: for(int i=bs.nextSetBit(0);
i>=0; i=bs.nextSetBit(i+1)) { // operate on index i here }
Parameters:
fromIndex - the index to start checking from (inclusive).
Returns:
the index of the next set bit.
Throws:
IndexOutOfBoundsException - if the specified index is negative.
Since:
1.4
nextClearBit
public int nextClearBit(int fromIndex)Returns the index of the first
bit that is set to false that occurs on or after the specified starting
index.
Parameters:
fromIndex - the index to start checking from (inclusive).
Returns:
the index of the next clear bit.
Throws:
IndexOutOfBoundsException - if the specified index is negative.
Since:
1.4
length
public int length()Returns the "logical size" of this
BitSet: the index of the highest set bit in the BitSet plus one.
Returns zero if the BitSet contains no set bits.
Returns:
the logical size of this BitSet.
Since:
1.2
intersects
public boolean intersects(BitSet set)Returns true if the specified
BitSet has any bits set to true that are also set to true in this
BitSet.
Parameters:
set - BitSet to intersect with
Returns:
boolean indicating whether this BitSet intersects the specified
BitSet.
Since:
1.4
and
public void and(BitSet set)Performs a logical AND of this target
bit set with the argument bit set. This bit set is modified so that
each bit in it has the value true if and only if it both initially
had the value true and the corresponding bit in the bit set argument
also had the value true.
or
public void or(BitSet set)Performs a logical OR of this bit set
with the bit set argument. This bit set is modified so that a bit
in it has the value true if and only if it either already had the
value true or the corresponding bit in the bit set argument has
the value true.
xor
public void xor(BitSet set)Performs a logical XOR of this bit set
with the bit set argument. This bit set is modified so that a bit
in it has the value true if and only if one of the following statements
holds:
The bit initially has the value true, and the corresponding bit
in the argument has the value false.
The bit initially has the value false, and the corresponding bit
in the argument has the value true.
hashCode
public int hashCode()Returns a hash code value for this bit set.
The has code depends only on which bits have been set within this
BitSet. The algorithm used to compute it may be described as follows.
Suppose the bits in the BitSet were to be stored in an array of
long integers called, say, bits, in such a manner that bit k is
set in the BitSet (for nonnegative values of k) if and only if the
expression
((k>>6) < bits.length) && ((bits[k>>6] &
(1L << (bit & 0x3F))) != 0)is true. Then the following
definition of the hashCode method would be a correct implementation
of the actual algorithm:
public int hashCode() {
long h = 1234;
for (int i = bits.length; --i >= 0; ) {
h ^= bits[i] * (i + 1);
}
return (int)((h >> 32) ^ h);
}Note that the hash code values change if the set of bits is altered.
Overrides the hashCode method of Object.
Overrides:
hashCode in class Object
Returns:
a hash code value for this bit set.
See Also:
Object.equals(java.lang.Object), Hashtable
size
public int size()Returns the number of bits of space actually in
use by this BitSet to represent bit values. The maximum element
in the set is the size - 1st element.
Returns:
the number of bits currently in this bit set.
equals
public boolean equals(Object obj)Compares this object against the
specified object. The result is true if and only if the argument
is not null and is a Bitset object that has exactly the same set
of bits set to true as this bit set. That is, for every nonnegative
int index k,
((BitSet)obj).get(k) == this.get(k)must be true. The current sizes
of the two bit sets are not compared.
Overrides the equals method of Object.
Overrides:
equals in class Object
Parameters:
obj - the object to compare with.
Returns:
true if the objects are the same; false otherwise.
See Also:
size()
clone
public Object clone()Cloning this BitSet produces a new BitSet that
is equal to it. The clone of the bit set is another bit set that
has exactly the same bits set to true as this bit set and the same
current size.
Overrides the clone method of Object.
Overrides:
clone in class Object
Returns:
a clone of this bit set.
See Also:
size()
toString
public String toString()Returns a string representation of this
bit set. For every index for which this BitSet contains a bit in
the set state, the decimal representation of that index is included
in the result. Such indices are listed in order from lowest to highest,
separated by ", " (a comma and a space) and surrounded
by braces, resulting in the usual mathematical notation for a set
of integers.
Overrides the toString method of Object.
Example:
BitSet drPepper = new BitSet();Now drPepper.toString() returns
"{}".
Overrides:
toString in class Object
Returns:
a string representation of this bit set.
--------------------------------------------------------------------------------
Overview Package Class Use Tree Deprecated Index Help
JavaTM 2 Platform
Std. Ed. v1.4.2
PREV CLASS NEXT CLASS FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR
| METHOD
--------------------------------------------------------------------------------
Submit a bug or feature
For further API reference and developer documentation, see Java
2 SDK SE Developer Documentation. That documentation contains more
detailed, developer-targeted descriptions, with conceptual overviews,
definitions of terms, workarounds, and working code examples.
Copyright 2003 Sun Microsystems, Inc. All rights reserved. Use is
subject to license terms. Also see the documentation redistribution
policy.
