Byte Array inkrementieren

[Gelöschtes Mitglied 10077]

hi zusammen,

da ich nicht weiter weiß, poste ich meine anfängerfrage mal, in der hoffnung, dass mich jmd hört



es schaut wie folgt aus.

ich habe einen "genullten" vorgegebenen byte array

byte[] code = new byte[5]; 

for (int j = 0; j < 5; j++) code[j] = 0

---------
da es ein kryptographie praktikum geht und der algorithmus etwas probieren muss
wird bei jedem fehlgeschlagenen vergleich der byte array inkrementiert.
bzw versuche ich das gerade zu implementieren

sprich, wenn ein vgl mit einem anderen codestück fehlschlägt, dann wird dieser array stellenweise inkrementiert, bis ich ein passendes stück selbstgenerierten "code" gefunden habe


das inkrementieren müsste also zbsp folgendes liefern:

[0,0,0,0,0] --> [0,0,0,0,1]
[0,0,0,0,255] --> [0,0,0,1,0]
[0,123,0,23,0] --> [0,123,0,23,1] usw..

frage ist, wie ich das anstelle, ohne 1 mio verschachtelte if und for schleifen zu benutzen
und ob es schon etwas dafür in java gibt


für jede antwort dankbar


buggi

 

[Der Müde Joe]

<< >>> >>

so sehen die aus

eine Stelle shiften : <<

also 0001 << 1 = 0010

binär versteht sich

EDIT:
heissen glaue ich
Shiftoperatoren oder Verschiebeoperatoren
http://www.programmersbase.net/Content/Java/Content/Tutorial/Java/Operator.htm

 

[Gelöschtes Mitglied 10077]

hm

es geht mir ja nicht darum, dass die stellen verschoben werden,
sondern dass der gesamte array inkrementiert wird

 

[Gelöschtes Mitglied 10077]

momentan bin ich soweit:

	    	boolean inc = false;  /*steht auf true sobald inkrementiert wurde */
	    	for (int x=0; x < codeBlk.length; x++, inc = false){
	    		
	    		if (codeBlk[x] < 256) {
	    			codeBlk[x]++; 
	    			inc = true;
	    			}else {
	    				codeBlk[x]=0;
	    				}	
    		
	    	}

da ich aber noch totaler java anfänger bin, weiß ich nicht, obs das tut
da ich nicht jede stelle inkrementieren will, sondern nur 1 mal die nächste stelle, setze ich eine hilfsboolean direkt auf true, wenn inkrementiert wurde.
aber auch da bin ich nicht sicher, ob der for schleifeneinstieg stimmt. oder ob ich das einer for schleife überhaupt abverlangen kann.
ansonsten müsste der boolean check in die if mit rein. aber auch da habe ich die syntax für eine zweite bedingung nicht heraus gefunden

 

[SlaterB]

tja, ob es das nun gibt oder nicht kann nur der sagen, der weiß, dass es das gibt

von mir nur die Meinung: kann ich mir nicht vorstellen,
ist ja auch mit wenigen Zeilen selber programmiert und dann hast du volle Kontrolle über weitere Features,

und noch ein Tipp:
byte geht von -128 bis +127

-------

zu deinem Code: von hinten (rechts im Array) anfangen!,
und wenn auf 0 gesetzt wird, dann die boolean-Variable nicht auf true setzen, weil ja das nächste Feld auch noch incrementiert werden muss

 

[schalentier]

und noch ein Tipp:
byte geht von -128 bis +127

Neee, byte is von 0..256 und char von -128 bis 127, oder?

/edit: Mein Fehler, byte geht doch von -128 bis 127 und char is 16 Bit lang (Unicode usw). Nimm am besten int...

Fang im Array von Hinten an, und zaehl die Zahl dort um 1 hoch. Is das dann 256, setzt du diese Stelle auf null und machst das gleiche fuer die Stelle davor. Das ganze im Loop bis zur 0. Stelle, ist die auch 256 bist du durch.

 

[byte]

Du könntest die Bytes aber folgendermaßen unsigned interpretieren:

(int) b & 0xFF

 

[Der Müde Joe]

nimm doch ein long ....nimm nur 40 bit ..also 5 * ein byte
und mach ein ++...

dann haste das gleiche ohne Array...

 

[Der Müde Joe]

so als ansporn

long b = 512;
System.out.println((int)b & 0xFF);
b >>>= 8; //shift 8 bit
System.out.println((int)b & 0xFF);
b >>>= 8;
System.out.println((int)b & 0xFF);

sollte

0
2
0

ausgeben

 

[Gelöschtes Mitglied 10077]

problem ist, dass mein byte array über mehrere klassen hinweg fest implementiert ist. ich könnte das vllt typecasten und zurück casten usw..

aber das kann ich noch viel weniger, als das hier^^


danke für den tip mit dem true/false weiter oben.


nur stehe ich immernoch da, wo ich schon war

 

[kleiner_held]

Du koenntest das Inkementieren deines Arrays rekursiv loesen:

public void increment(byte[] b)
{
   increment_rec(b, b.length - 1);
}

private void increment_rec(byte[] b, int pos)
{ 
    if (pos < 0)
    {
        throw new RuntimeException("Arrayueberlauf");
    }
    else if (b[pos] < Byte.MAX_VALUE)
    {
        b[pos]++;
    }
    else
    {
        b[pos] = 0;
        inecrement_rec(b, pos - 1);
    }
}

Das wuerde jeden Array index mit Werten zwischen 0 und 127 behandeln, wenn du [127, 127, 127, 127] incementierst knallts.

 

[Gelöschtes Mitglied 10077]

ihr habt alle samt geniale ansätze

aber ich nur ne vorgegebene klasse, an der ich an 1 stelle innerhalb 1 funktion ein paar zeilen einfügen soll, die unter anderem leisten, dass mein Byte Array inkrementiert wird


stellt euch einfach vor, dass ich einen array aus bytes habe
nun such ich einen algorythmus, der mir nach und nach via inkrekementieren jeden möglichen array bastelt.
ausgehend von [0,0,0,0], welchen ich bereits habe



:/

 

[Der Müde Joe]

guck dir das mal an

public class Test{

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		for(long i = 0 ; i < 500; i++){
			byte[] a= getArray(i);
			print(a);
		}
	}
	
	/**
	 * 0-127 normal
	 * 128 - 255 = -128 - 1
	 */
	public static byte[] getArray(long zahl){
		byte [] array = new byte[5];
		
		array[0] = (byte)(zahl & 0xFF);
		zahl>>>= 8;
		array[1] = (byte)(zahl & 0xFF);
		zahl >>>= 8;
		array[2] = (byte)(zahl & 0xFF);
		zahl >>>= 8;
		array[3] = (byte)(zahl & 0xFF);
		zahl >>>= 8;
		array[4] = (byte)(zahl & 0xFF);
		
		return array;
	}
	
	public static void print(byte[] b){
		for(byte c : b){
			System.out.print(c + " ");		
		}
		System.out.println("");
	}
}

 

[schalentier]

Die Speichersparversion:

public class ArrayInc {
    byte[] numbers;

    public ArrayInc(byte[] numbers) {
        this.numbers = numbers;
    }

    public void inc(){
        int pos=numbers.length-1;
        boolean stop = false;
        while(!stop && pos>=0 ) {
            int no = numbers[pos]&0xFF; // byte in "unsigned byte" umwandeln
            if( no<255 ) { // letzte stelle kann noch erhoeht werden?
                numbers[pos]++;
                stop = true; // dann fertig
            } else {
                numbers[pos]=0; // ansonsten auf 0 setzten und naechste stelle probieren
                pos--;
            }
        }
    }

    public String toString() {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < numbers.length; i++) {
            int number = numbers[i]&0xFF;
            if( i!=0 ) sb.append(",");
            sb.append(number);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        byte[] nums = new byte[]{0,0,0,0};
        ArrayInc inc = new ArrayInc(nums);

        for( int i=0;i<10000;i++ ) {
            inc.inc();
            System.out.println(inc);
        }

    }
}

 

[Gelöschtes Mitglied 10077]

ui genial

und hast du vllt noch ne ahnung, warum

	    	if (codeBlk[codeBlk.length] < 127){
	    		codeBlk[codeBlk.length]++;
	    	}

mir eine java.lang.ArrayIndexOutOfBoundsException: 31
codeBlk ist ein byteArray
und via system out println, seh ich dass codeBlk.length = 32 ist
es muss daran liegen, dass ich so nicht im byte array inkrementieren kann. und wenn ich statt dessen:

codeBlk[codeBlk.length] = codeBlk[codeBlk.length]+1;

oder ähnliches versuche, führt das auch zu nichts..

 

[Der Müde Joe]

das Array ist 32 lang

dh: 0 - 31 Stellen

also length-1 ist max

 

[Gelöschtes Mitglied 10077]

if (codeBlk[codeBlk.length-1] < 127){
             codeBlk[codeBlk.length-1]++;
          }

habs damit nun scheinbar mehr oder weniger zum laufen gebracht. jedoch weiß ich nicht, ob ich damit noch das letzte byte im array erreiche

 

[Gelöschtes Mitglied 10077]

habe deinen kommentar zu spät gesehen
danke für deine mühen