modyfikacje strumienia ejściowego

Witam...

Mam pewien plik który wczytuje bajt po bajcie. Wczytuję go do tablicy bajtowej:

 int numberBytes = fis.available();
            byte bytearray[] = new byte[numberBytes];
            fis.read(bytearray);

fis jest srumieniem wejściowym utworzonym poprzez użycie datainputstream i fileinputstream.
gdy chce wypisać zawartość tablicy :

for (int i = 0; i < bytearray.lenght; i++) {  
                System.out.println(bytearray[i] + " " + i);
            } 

wypisuje mi tak:
51 0
52 1
46 2
55 3
51 4
57 5
49 6
55 7
45 8
48 9
46 10...itd.
czyli do każdej komórki tablicy bytearray zapisuje się jeden bajt ze strumienia...
Moje następne zadanie polega na scaleniu dwóch bajtów w jedną komórkę...Czyli w tym przypadku pierwsza komórka byłaby (00110011=51 i 00110100=52) :0011001100110100.Czyli zawierałaby 2bajty. W następnej komórce byłby wynik scalenia 2 i 3 bajtu w następnej scalenie 4 i 5 bajtu itd.
Wiem że bajt ma maxymalnie 8 bitów czyli musiałbym po odczytaniu tych bajtów zmienić je na inny typ...i tu moje pytanie...na jaki. Nie mam w ogóle koncepcji jak to sprawnie zrobić.

Czy może ktoś wie jak to ugryźć?
pozdr.

Moim zdaniem, jak chcesz się bawić w takie 'sklejanie' zer i jedynek, to zostaje string albo tablica charów, boolów ... Ewentualnie jakaś dwuelementowa tablica Byte ... A potem zamiana z powrotem na byte ...

robiłem coś takiego :
String[] str = new String[numberBytes];
for (int i = 0; i < bytearray.length; i++) {
str[i] = Byte.toString(bytearray[i]);

            System.out.println(bytearray[i] + " " + i);

        }

a później tworzyłem następną pętle :
for (int i = 0; i < str.lenght; i++) {
str[i] +=str[i+1];

            System.out.println(str[i] + " " + i);

        }

jednakże jak widzicie jest ona zła ponieważ do aktualnej komórki dodaje następną...przy kolejnej iteracji jest już błąd :/
Poza tym...plik jest rozmiaru 50 Mb więc trochę tych bajtów jest :/ Więc występuje tu od razu problem z pamięcią :/

Dwa bajty możesz zmieścić w jednej zmiennej short.

Wystarczy przeznaczyć pierwszych 8 bitów na jedną liczbę i drugie 8 na drugą.

byte high = 2;
byte low = 4;
short b = (short) ((high << 7) + low);

(ofc chodziło o ((high << 8) | low))

Gdyby byte w Javie był dodatni, to sytuacja byłaby dużo łatwiejsza.

byte high = -128;
byte low = -128;
short b = (short) ((high << 8) | low);

daje w wyniku b=-128

Najlepiej chyba przyjąć (high << 8) + low.
Dla tego wzoru nie ma powtórzeń.
Demonstruje to poniższy program (nic nie wypisuje):

Set<Short> shorts = new HashSet<Short>();
for (byte high = -128; ; high++){
	for (byte low = -128; ; low++) {
		short b = (short) ((high << 8) + low);

		if (shorts.contains(b)) {
			System.out.println(""+ low + " " + high);
		}
		shorts.add(b);
		if (low == 127) {
			break;
		}
	}
	if (high == 127) {
		break;
	}
}

hmm...sądząc po stopniu trudności treści pierwszej tego zadania uważam że trochę pokomplikowaliście (mogę się mylić). Scalić to chyba poporostu dodać tak by długość tablicy się zmniejszyła dwukrotnie. Dwa bajty scalić to fakt-tylko do shorta ... ale rozważałbym po prostu & ...