# In einem Byte-Array nach einer gewissen Zahlenfolge suchen



## richiking (15. Dez 2011)

Hallo liebe Community,

bin Java-Neuling und beschäftige mich derzeit mit dem auslesen einer virtuellen Schnittstelle. 
Folgendes Problem habe ich dabei.

Ich bekomme vom Inputstream ein schönes Byte-Array zurück. Die Daten stellen Messwerte eines Mikrokontrollers da, der bei jedem Datensatz einen Header einfügt mit folgender Form: [85, -1, 24]

Jetzt werden pro Datensatz 27 Bytes (incl. Header gesendet)... beim ersten mal werden noch 4 zusätzliche Bytes gesendet....

Beispiel für das erste Datenarray: [85 0 1 2 85 -1 24 x x x x x x x x x x x x x....] wobei x jene Daten darstellt die ich benötige. 

Nun ist mein Problem, dass ich nicht weiß, wie ich die Headerbytes wegschneiden kann, da ich diese nicht benötige und mich nur an der Verarbeitung hindern. Gibt dann noch eine Umwandlung von Little Endian auf Big Endian usw... tut "noch" nichts zur sache.

Jetzt gibt es ja bei den sogenannten primitiven Arrays nicht wirklich die möglich nach etwas zu suchen... dacht ich mir ich nehme ArrayLists... da aber bin ich mir nicht sicher wie ich nach genau der Header-Zahlenreihenfolge suchen kann und diese rauslöschen kann.... 


Hoffe es ist halbwegs verständlich.

lg


----------



## irgendjemand (15. Dez 2011)

java.util.Arrays.binarySearch(...)


----------



## Evil-Devil (15. Dez 2011)

Ich würde einfach immer 27 Byte bzw. beim ersten 31 Byte lesen und auch den Header vergleichen.


----------



## richiking (15. Dez 2011)

Irgendetwas stimmt noch nicht! Hab zwar eure Idee implementiert (lt. Debugger auch richtig), nur kommen bei mir noch Werte raus die keinen Sinn machen. Jetzt meine Frage... byte ist von java ja automatisch signed oder? problem ist aber... dass die werte als unsigned (sprich werte höher 128? können vorkommen)... wie kann ich ihm beibringen, dass die werte die aus in.read(buffer); rauskummen unsigned sind? sonst speichert er mir die ja gleich falsch in den buffer?!


```
byte[] buffer = new byte[35];
        	byte[] data = new byte[27];
        
        	byte[] realdata = new byte[24];
        	int[] convert = new int[24];

        	int counter=0;
        	

        	
            int len = -1;


            try
            {
                while (true)
                {
                		if(counter==1)
                		{
                			in.read(buffer);
                			for(int i=0;i<buffer.length-11;i++)
                			{
                				realdata[i]=buffer[i+11]; // 11 da die ersten 11 bytes acknowledge bytes sind beim ersten mal
                				
                			}

                		}
                		else if(counter>1)
                		{
                			in.read(data);
                			for(int i=0;i<data.length-3;i++)
                			{
                				realdata[i]=data[i+3]; // 4 da bei jedem datenset der header dabei ist
                				
                			}

                		}
                		
                		
                			
                		byte LSB = realdata[18]; // Position des Winkels LSB
                                
                                byte MSB = realdata[19];  // Position des Winkels MSB
                                int d = MSB << 8 | (255 & LSB);                                 
         System.out.println(d);                                                		                		              	
                		counter++;
                }
```


----------



## Gastredner (15. Dez 2011)

Die Werte sind korrekt, lediglich die Darstellung bzw. Interpretation der Bitmuster ändert sich. Das Bitmuster ist und bleibt dasselbe (zumindest sollte es so bleiben).
Willst du in der Ausgabe unsigned bytes statt der signed bytes sehen, kannst du auch einfach *in der Ausgabe* 255 auf die Bytes aufaddieren und anschließend logisch UND-verknüpfen mit 0xFF (der Ergebnistyp ist int, wodurch die Darstellung von 0..255 kein Problem ist).

```
public class UnsignedByte {

	public static void main(String[] args) {
		byte[] bytes = readBytesFromSomewhere();
		for (byte b: bytes) {
			System.out.println("0x" + Integer.toHexString((b + 256) & 0xFF).toUpperCase());
		}
	}

	private static byte[] readBytesFromSomewhere() {
		return new byte[] {(byte) 0xFF, 0x7F, (byte) 0xAA, (byte) 0x80, (byte) 255, 0};
	}
}
```
Produziert als Ausgabe:

```
0xFF
0x7F
0xAA
0x80
0xFF
0x0
```


----------



## AngryDeveloper (16. Dez 2011)

Das + 256 kann man sich aber auch sparen. b & 0xFF reicht auch aus.


----------



## Gastredner (16. Dez 2011)

Stimmt, danke für die Korrektur.


----------



## richiking (16. Dez 2011)

Danke! 
Wird getestet sobald die anderen Probleme gelöst sind ;(


----------

