# hex string ausdruck in binär umwandeln



## unrockstar (18. Apr 2011)

hallo ich habe folgendes problem 
und zwar hab ich ein string array gegeben mit 2 hex ausdrücken und muss diese in binär umwandeln
meine idee ist folgende
ich wandle den string in einen stringbuffer um um ihn ändern zu können und will dann mit einer for schleife und meheren if bedingungen sagen dass zum beispiel "a" == 1010 ist 
aber dort hapert es an der umsetzung 
hier mein program bisher:

```
public class Rechner {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
    String [] sa;
    sa = new String[10];
    sa[0] = "457e76";
    sa[1] = "55db1";
    String zeichen = sa[0];
    String zeichen2 = sa[1];
    StringBuffer feld1= new StringBuffer (zeichen);
    StringBuffer feld2= new StringBuffer (zeichen2);
        for(int i =0;i<=feld1.length();i++){
        	System.out.println(feld1.charAt(i));
        	
        	}
        }
    	
    	}
```

ach dazu kommt noch das wir folgende methoden nicht benutzen sollen :
• %
• ^
• Integer.valueOf()
• Integer.parseInt()
o Zur Umrechnung zwischen Zahlensystemen verboten, als reiner Typecast jedoch erlaubt
• Character.forDigit()
• Character.getNumericValue()


----------



## SlaterB (18. Apr 2011)

wie kann es da hapern?
schon ein "if (c == 'a')" wie du es sagst, wäre viel mehr als bisher dort an Code steht 
(c als lokale Variable, möglichst nicht 30x feld1.charAt(i) schreiben)


----------



## unrockstar (18. Apr 2011)

aber wie implemtier ich das genau?
es ist vielleicht so simpel aber ich komm nicht drauf -.-


----------



## SlaterB (18. Apr 2011)

kannst du die Frage irgendwie anders formulieren als 'bitte für mich Quellcode posten?'? das wird nämlich nicht passieren,

ich kann dir noch die Erkenntnis abnehmen, dass ein Vergleich mit 'a' letzlich nicht viel bringen wird,
es wäre zwar praktisch, einfach nur die 16 Zeichen auf 16 Bitmuster abzubilden, aber dann rechnest du ja überhaupt nichts,
sicher eher jedes Zeichen in eine Zahl von 0-15 umwandeln, und dann durch Rechnung bestimmen welches Bit gesetzt ist,
das erste z.B. wenn größer 7


----------



## unrockstar (18. Apr 2011)

ohh je -.-
wir haben schon in der uni überlegt wir durch rechnung viel leichter und mit viel weniger code schreiben können wie man den ausdruck abbildet 
aber wir kommen auf keine lösung -.-
und dieser teil der aufgabe gibt nur 1 punkt -.-
kannst du mir einen tipp für den allgemeinen allgorithmus geben den ich zum rechnen benutzen könnte?
das würde denke ich schon viel weiterhelfen


----------



## WIaimy (18. Apr 2011)

Jede Hex-Zahl lässt sich schnell in eine binär-Zahl umwandeln, da ein Zeichen deines Hex-Ausdruckes durch vier Binär-Zahlen darstellbar ist. Ich würde deinen String mit der .toCharArray()-Methode in ein Array packen und dann entsprechend umgewandelt ausgeben. Falls ein Buchstabe auftritt, musst du natürlich den entsprechenden Zahlenwert nehmen. Dabei hilft die ASCII-Tabelle.


----------



## unrockstar (18. Apr 2011)

Ja okay den Ansatz hatte ich auch.du meinst wenn der Ausdruck 45e52a ist. Dann diesen Ausdruck so in das Array hineinspeichern das gilt c(0) ist 4 c(1) ist 5 usw dann den alg. Fuer die zahlen definieren und falls ein Buchstabe auftritt dann mit If den binaerwert zuweisen. Richtig so?  Schreib grade vom Handy entschuldigen wenns nicht ganz korrekt geschrieben ist


----------



## Landei (18. Apr 2011)

(ungetestet)

```
Map<Character, String> hex2bin = new HashMap<Character, String>() {{
  put('0',"0000");
  put('1',"0001");
  put('2',"0010");
  put('3',"0011");
  put('4',"0100");
  put('5',"0101");
  put('6',"0110");
  put('7',"0111");
  put('8',"1000");
  put('9',"1001");
  put('a',"1010");
  put('b',"1011");
  put('c',"1100");
  put('d',"1101");
  put('e',"1110");
  put('f',"1111");
}};

...
String s = "3437Ab4".toLowerCase();
StringBuilder sb = new StringBuilder();
for(int i = 0; i < s.length(); i++) {
   sb.append(hex2bin.get(s.charAt(i)));
}
String bin = sb.toString();
```

Sind es nur kurze Zahlen, reicht natürlich [c]Long.toBinaryString(Long.parseLong(s, 16));[/c]


----------



## unrockstar (18. Apr 2011)

das könnte auch eine lösung sein da mus ich mich aber erstmal auseinander setzen mit nun danke dir


----------



## unrockstar (19. Apr 2011)

ich nun folgendes probiert :
ich wandel den string in ein char array um doch anstatt die einzelnen buchstaben an jeweils einen platz in dem array gespeichert werden, wird jeweils der ganze ausdruck an einem platz gespeichert 

```
public class Rechner {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
    String [] sa;
    sa = new String[10];
    sa[0] = "457e76";
    sa[1] = "55db1";
    String zeichen = sa[0];
    String zeichen1= sa[1];
    char [] feld1 = zeichen.toCharArray();
    for ( int i=0;i<=feld1.length;i++){
    	System.out.print(feld1);
    }


        	}

}
```

kann mir da vielleicht jemand helfen?


----------



## jgh (19. Apr 2011)

das macht er nicht...du musst natürlich in deiner for-schleife auch auf das einzelne element zugreifen:


```
for (int i = 0; i <= feld1.length-1; i++) {
			System.out.println(feld1[i]);
		}
```


----------



## SlaterB (19. Apr 2011)

einen weiteren x-beliebigen String zu posten und den in chars aufzusplitten ist nix neues, du postest quasi nichts, 
nicht mal Verständnisfragen zum bisherigen, 
'ich weiß nix, helfen' ist eine Frage die noch nie inhaltlich funktioniert hat, als Betteln um Lösung, naja, funktioniert natürlich besser als gar nix 

sie bewirkt z.B., dass ich dich auf eine weitere Vereinfachung hinweisen kann, falls du darauf Wert legst:
vergiss ganze Strings und mit Schleife darüber zu iterieren,
es reicht völlig wenn du erstmal nur einen einzigen char c hast:

```
char c = '4';
```
finde dazu die Umwandlung, also berechne sie allgemein, wenn das fertig ist und auch für (manuell getestet) andere chars funktioniert, dann später in die Schleife über einen String einbauen,
du musst zum char c lediglich 4 einzelne Bits berechnen, sofern du nicht eine fertige Map wie von Landei benutzen willst,
fürs erste Bit hatte ich dir den kompletten Rechenweg schon genannt, aber das sagt dir wahrscheinlich gar nichts,

zusammen mit einer weiteren Beleidigung (du verstehst ja gar nichts, bäh) verrate ich dir dann für dieses erste Bit den kompletten Code:

```
String bits = "";
if (cAlsInt > 7)  { 
  bits += "1";
} else {
  bits += "0";
}
```
das war nun so schwer dass man tagelang nicht darauf kommt?
wobei die genaue Berechnung auch nicht das interessanteste sein muss,
allein schon

```
String bits = "";
bits += "1";
bits += "1";
bits += "1";
bits += "1";
System.out.println("bits for char .. = "+bits);
```
wäre Code der gewisse Bearbeitung von dir zeigt, ganz egal ob die Bits bisher falsch sind,

etwas nicht sofort korrekt zu berechnen ist keine Schande, 
aber überhaupt nicht an der Aufgabe zu arbeiten, keine Vorstellung von Irgendwas, von einer Dummy-Ausgabe usw. zu haben, das ist schon bedenklicher,
obwohl du ja die Schleife über den String hast, in gewisser Weise komplizierter..


----------



## Landei (19. Apr 2011)

Etwas kürzer (ungetestet):

```
private String bit(int n) { return n==0 ? "0" : "1"; }

private String hex2bin(char ch) {
   int num = "0123456789abcdef".indexOf(ch);
   return bit(num & 8) + bit(num & 4) + bit(num & 2) +bit(num & 1);
}
 
...
String s = "3437Ab4".toLowerCase();
StringBuilder sb = new StringBuilder();
for(int i = 0; i < s.length(); i++) {
   sb.append(hex2bin(s.charAt(i)));
}
String bin = sb.toString();
```


----------



## Crian (21. Apr 2011)

Ohne zu verraten, wie du das nun inhaltlich lösen musst - dazu gibt es hier ja genug Anregungen - würde ich das Problem anderes angehen. Wenn einem etwas zu komplex erscheint und man zu viele Sachen auf einmal machen will, verfrachtet man einzelne Teilaufgaben am besten in einzelne Methoden. Z.B. so:


```
package forumProblems;

public class Rechner {

    public static void main(String[] args) {
        String[] sa = new String[2];
        sa[0] = "457e76";
        sa[1] = "55db1";

        for (String hex : sa) {
            String binary = hex2bin(hex);
            System.out.println(hex + " wird zu " + binary);
        }
    }

    /**
     * Berechnet aus einem String in hexadezimaler Schreibweise (z.B. "1a")
     * einen String in binärer Schreibweise (z.B. "00011010").
     *
     * @param hex
     *            String in hexadezimaler Schreibweise
     * @return String in binärer Schreibweise
     */
    private static String hex2bin(String hex) {
        StringBuffer feld = new StringBuffer();

        for (int i=0; i<hex.length(); ++i) {
            String bits = hex2binOneCharakter(hex.charAt(i));
            feld.append(bits);
        }

        return feld.toString();
    }

    /**
     * Berechnet aus einem Zeichen in hexadezimaler Schreibweise (z.B. "1")
     * einen String in binärer Schreibweise (z.B. "0001").
     *
     * @param hex
     *            Zeichen in hexadezimaler Schreibweise
     * @return String in binärer Schreibweise
     */
    private static String hex2binOneCharakter(char hexChar) {
        // TODO Dein Code

        return null; /* hier den erzeugten String für das eine Zeichen zurückgeben. */
    }

}
```

[c]main()[/c] ist nun sehr einfach und übersichtlich. Es wird dein Stringarray [c]sa[/c] (ich würde übrigens einen anderen Namen verwenden, habe es aber mal so gelassen, damit du es wieder erkennst) gebildet und für jedes Element in dem Array wird das Gegenstück in binärer Schreibweise erzeugt.

Dieses wird dann ausgegeben.


Die Methode [c]hex2bin[/c], die einen String in hexadezimaler Schreibweise in einen solchen in binärer Schreibweise umwandelt, zerlegt den hexadezimalen String in einzelne Zeichen und lässt diese von einer anderen Methode in einen String umwandeln. Diese Strings werden zusammen gebaut und das Ergebnis zurück gegeben.

Die Methode [c]hex2binOneCharakter[/c] schließlich muss sich um nichts anderes kümmern als aus einem einzelnen Zeichen einen String mit den vier Einsen und  Nullen zusammen zu basteln.

So sind all die Aufgaben von einander getrennt und jede Teilaufgabe ist einfach und übersichtlich.

Testet man es mit der offensichtlich falschen Implementierung


```
private static String hex2binOneCharakter(char hexChar) {
        // TODO Implementierung ist FALSCH!
        return "<" + hexChar + ">";
    }
```

erhält man das Ergebnis


```
457e76 wird zu <4><5><7><e><7><6>
55db1 wird zu <5><5><d><b><1>
```

Nun muss man sich also nur noch darum kümmern, wie ein Charakter in seine Binärdarstellung umgewandelt werden soll. Ob man nun eine if - else if - Kette bildet und alles explizit hinschreibt, eine Berechnung durchführt, wie oben skizziert oder eine Map mit den richtigen Werten verwendet, ist dabei dir überlassen.



Edit: Das Array zu belegen geht etwas schöner übrigens so: [c]String[] array = { "457e76", "55db1" };[/c]


----------

