/** Die Klasse 'Byte Array' beinhaltet Methoden zur umwandlung eines Byte-Array's in
* verschiedene Datentypen und die jeweils umgekehrte Methode dieser Datentypen in
* ein Byte-Array
* Alle Methoden wandeln um indem sie die Daten Bitweise Verschieben, es werden weder
* Vorzeichen noch andere Notationen beachtet
* @author xxxxxxxx
*
*/
public class ByteArray {
/** Die Methode <code>chkSize</code> prüft ein <code>byte[]</code> auf existenz und ausreichende Größe
* um auch wirklich einen bestimmten Datentyp ermitteln zu können.
*
* @param b das Byte-Array welches auf existens und Größe geprüft werden soll
* @param offset Startpunkt im Byte-Array
* @param size Länge die ab dem startpunkt existieren muss
* @return 'true' wenn die existens besteht und die Größe ausreicht, false wenn dies nicht zutrifft
* @throws IllegalArgumentException wenn das array nicht existiert oder es zu klein ist
*/
private static boolean chkSize(byte[] b, int offset, int size)throws IllegalArgumentException{
if (b != null && b.length >= offset + size){return true;}
else throw new IllegalArgumentException(" array zu klein ");
}
/**
* Die Methode <code>bytes2Short</code> wandelt ein <code>byte[]</code> in einen <code>short</code>
* um. Die Ergebnisvariable setzt sich aus den 2 Bytes 'b[offset]' und b[offset + 1]
* zusammen.
* Beide Bytes werden als vorzeichenlos betrachtet und einfach hintereinander gesetzt.
* <code>b[offset]</code> ist niederwertig und <code>b[offset+1]</code> höherwertig. Das Vorzeichenbit von
* <code>b[offset+1]</code> wird auch in der neuen Variablen Short zum Vorzeichenbit.
*
* @param b Quell Byte-Array
* @param offset Stelle im Array an der angefangen wird umzuwandeln
* @return gibt <code>short</code> zurück der aus dem Byte Array erstellt wurde
*/
public static short bytes2Short (byte[] b, int offset){
if (chkSize(b, offset, 2) == true){
return (short)((b[offset] & 0xff)|((b[offset+1] & 0xff)<<8));
}
return 0;
}
/** Die Methode <code>bytes2Int</code> basiert auf der Methode <code>bytes2Short</code>,
* mit dem Unterschied, dass 2 Variablen vom Typ <code>short</code> bitweise
* in einen <code>int</code> geschoben werden. Das Quellarray muss
* mindestens <code>offset+4</code> Elemente besitzen
*
* @param b Quell Byte-Array
* @param offset Stelle im Array an der angefangen wird umzuwandeln
* @return gibt <code>int</code> zurück der aus dem <code>byte[]</code> erstellt wurde
*/
public static int bytes2Int(byte[] b, int offset){
if (chkSize(b, offset, 4)){
return ((bytes2Short(b, offset)&0xffff)|((bytes2Short(b, offset + 2)&0xffff)<<16));
}
return 0;
}
/** Die Methode <code>bytes2Long</code> basiert wie die Methode <code>bytes2Int</code> auf dem
* Prinzip der Methode <code>bytes2Short</code> nur das hier 2 Variablen vom Typ <code>int</code>
* zusammengeschoben werden und sich die mindestgröße des Quallarrays somit
* auf offset+8 beläuft.
*
* @param b Quell Byte-Array
* @param offset Stelle im Array an der angefangen wird umzuwandeln
* @return gibt <code>long</code> zurück der aus dem <code>byte[]</code> erstellt wurde
*/
public static long bytes2Long(byte[] b, int offset){
if (chkSize(b, offset, 8)){
return ((long)(bytes2Int(b, offset)&0xffffffff)|((long)(bytes2Int(b, offset + 4)&0xffffffff)<<32));
}
return 0;
}
/** Die Methode <code>bytes2Float</code> wandelt ein <code>byte[]</code> in eine Variable des Typ's
* <code>float</code> um. Dazu wird zuerst die Methode <code>bytes2Int</code> aufgerufen. Dieses
* Ergebnis wird anschließend Bitweise in einen <code>float</code> geschrieben und
* zuzrückgegeben
*
* @param b Quell Byte-Array
* @param offset Stelle im Array an der angefangen wird umzuwandeln
* @return gibt <code>float</code> zurück der aus dem <code>byte[]</code> erstellt wurde
*/
public static float bytes2Float(byte[] b, int offset){
return Float.intBitsToFloat(bytes2Int(b, offset));
}
/** Die Methode 'bytes2Double' basiert auf der Methode 'bytes2Float' nur das sie
* logischerweise auf die Methode 'bytes2Long' zurückgreift.
*
* @param b Quell Byte-Array
* @param offset Stelle im Array an der angefangen wird umzuwandeln
* @return gibt <code>double</code> zurück der aus dem <code>byte[]</code> erstellt wurde
*/
public static double bytes2Double(byte[] b, int offset){
return Double.longBitsToDouble(bytes2Long(b, offset));
}
/** Die Methode <code>bytes2Char</code> macht aus 2 Bytes des Byte-Arrays <code>'b'</code> ein <code>char</code> und
* nutzt hierzu die Methode <code>bytes2Short</code>.
*
* @param b Quell Byte-Array
* @param offset Stelle im Array an der angefangen wird umzuwandeln
* @return gibt <code>char</code> zurück der aus dem <code>byte[]</code> erstellt wurde
*/
public static char bytes2Char(byte[] b, int offset){
return (char)(bytes2Short(b, offset));
}
/** Die Methode 'bytes2PascalString' gibt einen String zurück, bei dem aber das array in
* einer bestimmten Form betrachtet wird:
* b[offset] - gibt die länge des strings an 0-255
* jedes weitere Byte wird nun als ein Zeichen betrachtet.
*
* @param b Quell Byte-Array
* @param offset Stelle im Array an der angefangen wird umzuwandeln
* @return gibt <code>String</code> zurück der aus dem <code>byte[]</code> erstellt wurde
*/
public static String bytes2PascalString(byte[] b, int offset){
if (chkSize(b, offset, (short)b[offset]&0xff)==true){
byte[] erg = new byte[(short)b[offset]&0xff];
System.arraycopy(b, offset + 1, erg, 0, (short)b[offset]&0xff);
return new String(erg);
}
return "";
}
/** Die Methode 'bytes2String' wandelt ein Byte-Array in einen String um, indem
* für jedes Zeichen 2 Bytes zu einem Unicode-Zeichen umgewandelt werden.
* 'charAnz' gibt an wie viele Zeichen der entstehende String enthalten soll
* Daher Achtung die minimale Größe des ByteArray's 'b' berechnet sich
* durch: offset + (2 * charAnz)
*
* @param b Quell Byte-Array
* @param offset Stelle im Array an der angefangen wird umzuwandeln
* @param charAnz Anzahl der dargestellten Zeichen im zurückgegebenen String
* @return gibt <code>String</code> zurück der aus dem <code>byte[]</code> erstellt wurde
*/
public static String bytes2String(byte[] b, int offset, int charAnz){
char[] charBuffer = new char[charAnz];
if (ByteArray.chkSize(b, offset, charAnz * 2) == true){
for (int i = offset; i <= offset + (charAnz-1)*2; i+=2){
charBuffer[(i-offset)/2] = bytes2Char(b, i);
}
return new String(charBuffer);
}
else return "";
}
/** Die Methode <code>short2Bytes</code> ist das Gegenstück zur Methode <code>bytes2Short</code>, sie schreibt
* die ersten 8 Bit in ein <code>byte</code> und dann die letzten 8 in ein anderes. Diese werden dann
* in Form eines Array zurückgegeben.
*
* @param n die Variable die in ein Byte Array geschrieben werden soll
* @return gibt <code>byte[]</code> zurück in dem bitweise <code>n</code> steht
*/
public static byte[] short2Bytes(short n){
byte[] b = new byte[2];
b[0] = (byte)(n);
b[1] = (byte)(n>>>8);
return b;
}
/** Die Methode gibt <code>int2Bytes</code> ist das gegenstück zur Methode <code>bytes2Int</code> und basiert auf dem
* System der Methode <code>short2Bytes</code> und wandelt ein <code>int</code> in ein <code>byte[]</code> mit 4 Elementen um.
*
* @param n die Variable die in ein Byte Array geschrieben werden soll
* @return gibt <code>byte[]</code> zurück in dem bitweise <code>n</code> steht
*/
public static byte[] int2Bytes(int n){
byte[] b = new byte[4];
for (int i = 0; i <= 3; i++){
b[i] =(byte)(n>>>i*8);
}
return b;
}
/** Die Methode <code>long2Bytes</code> ist das gegenstück zur Methode <code>bytes2Long</code> und basiert auf dem
* System der Methode <code>short2Bytes</code> und wandelt ein <code>long</code> in ein </code>byte[]</code> mit 8 Elementen um.
*
* @param n die Variable die in ein Byte Array geschrieben werden soll
* @return gibt <code>byte[]</code> zurück in dem bitweise <code>n</code> steht
*/
public static byte[] long2Bytes(long n){
byte[] b = new byte[8];
for (int i = 0; i <= 7; i++){
b[i] =(byte)(n>>>i*8);
}
return b;
}
/** Die Methode <code>float2Bytes</code> ist das Gegenstück zur Methode <code>bytes2Float</code>
* und bedient sich dazu der Methode <code>int2Bytes</code>
*
* @param n die Variable die in ein Byte Array geschrieben werden soll
* @return gibt <code>byte[]</code> zurück in dem bitweise <code>n</code> steht
*/
public static byte[] float2Bytes(float n){
return int2Bytes(Float.floatToIntBits(n));
}
/** Die Methode gibt <code>double2Bytes</code> ist das Gegenstück zur Methode <code>bytes2Double</code>
* und bedient sich dazu der Methode <code>long2Bytes</code>
*
* @param n die Variable die in ein Byte Array geschrieben werden soll
* @return gibt <code>byte[]</code> zurück in dem bitweise <code>n</code> steht
*/
public static byte[] double2Bytes(double n){
return long2Bytes(Double.doubleToLongBits(n));
}
/** Die Methode <code>char2Bytes</code> wandelt ein <code>char</code> in ein <code>byte[]</code> mit 2 Elementen um
* und ist das Gegenstück zu <code>bytes2Char</code>
*
* @param c die Variable die in ein Byte Array geschrieben werden soll
* @return gibt <code>byte[]</code> zurück in dem bitweise <code>c</code> steht
*/
public static byte[] char2Bytes(char c){
return (short2Bytes((short)c));
}
/**Die Methode <code>string2Bytes</code> wandelt einen <code>String</code> in ein <code>byte[]</code> mit
* (Anzahl der Zeichen im String) * 2 Elementen. Sie ist das Gegenstück
* zu <code>bytes2String</code>
*
* @param s die Variable die in ein Byte Array geschrieben werden soll
* @return gibt <code>byte[]</code> zurück in dem bitweise <code>s</code> steht
*/
public static byte[] string2Bytes(String s) {
char[] cb = new char[s.length()];
s.getChars(0, s.length(), cb, 0);
byte[] b = new byte[cb.length*2];
byte[] bBuff = new byte[2];
for (int i = 0; i <= (cb.length-1)*2; i+=2){
bBuff = char2Bytes(cb[i/2]);
b[i]=bBuff[0];
b[i+1]=bBuff[1];
}
return b;
}
/**Die Methode <code>string2PasStrInBytes</code> wandelt einen <code>String</code> in ein <code>byte[]</code> um, bei dem
* allerdings für ein Zeichen nur ein <code>byte</code> verwendet wird, und außerdem noch ein
* <code>byte</code> mit der Länge des <code>Strings</code> vorangestellt wird daraus ergibt sich die Anzahl
* der Elemente im <code>byte[]</code> (Anzahl der Zeichen im String) + 1.
* Diese Methode ist das Gegenstück zu <code>bytes2PascalString.</code>
*
* @param s die Variable die in ein Byte Array geschrieben werden soll
* @return gibt <code>byte[]</code> zurück in dem Pascal codiert <code>s</code> steht
*/
public static byte[] string2PasStrInBytes(String s){
byte[] erg = new byte[s.getBytes().length + 1];
System.arraycopy(s.getBytes(), 0, erg, 1, s.getBytes().length);
erg[0] = (byte)s.length();
return erg;
}
}
