Hello!

In the moment I try to solve the following problem: I need a class
with a "bitwise xor-method (exclusive-or)" to calculate

the checksum of an array like this:

Byte[] bytes = new Byte[20];
bytes[0] = new Byte((byte)0x00);
bytes[1] = new Byte((byte)0x00);
..
bytes[19] = new Byte((byte)0x00);

The algorithm should work like this: A loop calculates the xor-result
for bytes[0] and bytes[1]. The result is beeing used to

calculate the xor-value with the bytes[2]-value and so on. But this
algorithm is not my problem (just to explain the task I

have to solve).
I've tried a lot, but I wasn't able to solve this problem. I got big
trouble for example with the conversation "Byte" to

"byte" and Back. I know there is an BitSet-Class-Package with a
available, but the conversation-problem from Byte or byte to

BitSet (and back) seems to be unsolvable for me. Then I've tryed
program my own class. You can take a look on it, but I don't

think it is a good solution (doesn't work). If you wonder: I did it
this way (lots of methods, less internal calculation) to

control the way of calculation the xor-result from outside the class.
I think the best solution would use the BitSet-xor. But till now my
problem is the conversation "byte or Byte to BitSet" and

back.

Thank you for helping me!

Michael L.

-----------------------------------------------------------------
import java.util.*;
import java.lang.reflect.Array;

class ByteBitSet {
    //Klassenvariablen
    private boolean[] byteBitSet1;     //byte as kind of BitSet
    private boolean[] byteBitSet2;
    private byte jbyteValueBS1;        //byte als byte
    private byte jbyteValueBS2;
   
    //constructor fills array with 8 false-values
    public ByteBitSet(){
        for(int i=0;i<8;i++) {
            byteBitSet1[i] = false;
            byteBitSet2[i] = false;
            }
        }

    //Byte to byte
    public byte convertBytebyte(Byte inByte) {
        byte inbyte = inByte.byteValue();
        return inbyte;
        }

    //byte to Byte   
    public Byte convertbyteByte(byte outbyte){
        Byte outByte = new Byte(outbyte);
        return outByte;
        }
   
    // math-functin for internal use only   
    private byte pow(int power) {
        byte result = 1;
        byte factor = 2;
        byte factor0 = 1;
        for(int j=1;j<power;j++) {
            result *= factor;   
            }
            if (power==0) {
                result=factor0;
                }       
        return result;
        }   
       
    //byte -> ByteBitSet
    public void byteToByteBitSet(int cv) {       
        if(cv == 1) {
            byte byteVal = this.jbyteValueBS1;
            for(int i=7;i>=0;i--) {
                byte help = this.pow(i);
                if((byteVal/help)>=1){           
                    this.byteBitSet1[i] = true;
                    byteVal -= help;
                }
                else {
                    this.byteBitSet1[i] = false;
                    }
                }   
            }
        if(cv == 2) {
            byte byteVal = this.jbyteValueBS2;
            for(int i=7;i>=0;i--) {
                byte help = this.pow(i);
                if((byteVal/help)>=1){           
                    this.byteBitSet2[i] = true;
                    byteVal -= help;
                }
                else {
                    this.byteBitSet2[i] = false;
                    }
                }   
            }   
        }
       
    //ByteBitSet -> byte
    public void bitSetTobyte(int cv) {
        if(cv==1) {
            byte byteval = 0;
            for(int i=7;i>=0;i--){
                if(this.byteBitSet[i]){
                    byteval += pow(i);
                    }
                this.jbyteValueBS1 = byteval;
                }
            }
        if(cv==2) {
            byte byteval = 0;
            for(int i=7;i>=0;i--){
                if(this.byteBitSet[i]){
                    byteval += pow(i);
                    }
                this.jbyteValueBS2 = byteval;
                }
            }
        }
   
       
    //setting byte
    public void setbyte(byte byteVal, int cv){
        if(cv==1) {
            this.jbyteValueBS1 = byteVal;
            }
        if(cv==2) {
            this.jbyteValueBS2 = byteVal;
            }
        }
       
    //getting byte
    public byte getbyte(int cv){
        if(cv==1) {
            return this.jbyteValueBS1;
            }
        if(cv==2) {
            return this.jbyteValueBS2;
            }
        }

    // exclusive-OR
    public void xor() {
        boolean[] bitbyte= new boolean[8];    //temporary kind of BitSet
        bitbyte = this.tempByteBitSet;
        for (int i=0;i<8;i++) {
            if(((bitbyte[i]==true)&&(byteBitSet[i]==false))||((bitbyte[i]==false)&&(byteBitSet[i]==true)))
{
                byteBitSet[i]=true;    //true-false
                }
            else
                byteBitSet[i]=false;    //true-true or false-false
            }
        //    return byteBitSet;
        }
    }