# Unicode als deximal hexadezimal und char darstellen



## puschelchen (26. Oktober 2011)

Hallo,
ich hab hier nen Code wo ich Zeichen einlese diese überprüfe ob /u0041 z.B. eingegeben wurde. Nun hab ich mit if geprüft. So nun will ich das umrechnen das herauskommt z.b. 
hex: 0041, dez: 65, char: A  Leider komm ich nicht drauf was ich machen soll soll ich die Zeichen nun zusammenfügen und dann Rechnen oder wie würdet ihr sowas lösen?

```
public class Aufg3a3 {
   public static void main(String[] args) throws Exception {
   char zeichen1 =(char) System.in.read();
//   System.out.println(zeichen1);
 
   char zeichen2 =(char)System.in.read();
   //System.out.println(zeichen2);
 
   int zeichen3 =(int)System.in.read();
   //System.out.println(zeichen3);
 
   int zeichen4 =(int) System.in.read();
  // System.out.println(zeichen4);
 
   int zeichen5 =(int)System.in.read();
  // System.out.println(zeichen5);
 
   int zeichen6 =(int)System.in.read();
  // System.out.println(zeichen6);
   
//   
   
   if (! (zeichen1=='/')){
     System.out.println("Falsche Angabe");
     return;
   }
   if (! (zeichen2=='u')){
     System.out.println("Falsche Angabe");
     return;
   }
   if (! (zeichen3=='0')){
     System.out.println("Falsche Angabe");
     return;
   }
   if (!(zeichen4>='a'&& zeichen4<='f' || zeichen4>='0' && zeichen4<='9' )){
      System.out.println("Das vierte Zeichen ist falsch");
      return;
      }
   if (!(zeichen5>='a'&& zeichen5<='f' || zeichen5>='0' && zeichen5<='9' )){
      System.out.println("Das fünfte Zeichen ist falsch");
      return;
      }
   if (!(zeichen6>='a'&& zeichen6<='f' || zeichen6>='0' && zeichen6<='9' )){
      System.out.println("Das letzte Zeichen ist falsch");
      return;
      }
 
 
//      System.out.println("dezimaler Wert: " + );
//      System.out.println("hexadezimaler Wert: " + Integer.toHexString());
//      System.out.println("Char: " + );
```


----------



## SE (26. Oktober 2011)

Davon abgesehen das ich das durchweg mit BYTE machen würde braucht man dann nur die einzelnen Zeichen als String zusammenfügen und prasen.

btw : ein Unicodezeichen ist eine Esacpesequenz ... wird also mit einem Backslash *\* begonnen ... nicht mit einem Slash */* ... also z.B. \u0041.


----------



## puschelchen (26. Oktober 2011)

danke ich darf nur int oder char verwenden und dann umrechnen


----------



## SE (26. Oktober 2011)

Gut ... dann nimmst du halt char anstatt byte ... kommt am ende aufs selbe raus *zu mal ein String den du dann parsen könntest eh aus Chars besteht *CharSequenz**.
Am Ende machst parst du noch aus dem String einen int und castest diesen zu Unicode *glaube mit Char oder so*. Das ganze lässt sich mit Klassen aus dem Paket java.lang lösen.


----------



## j2se (26. Oktober 2011)

Mir ist immer noch schleierhaft, was Du verwenden resp. nicht verwenden kannst. Jedenfalls kann das Problem mit folgenden zwei Zeilen gelöst werden:


```
char[] data = {'0', '0', '4', '1' };
		
		String input = String.copyValueOf(data);
		System.out.println("Als integer: " + Integer.parseInt(input, 16));
		System.out.println("Als char: " + (char)Integer.parseInt(input, 16));
```
Die erste Zeile speichert die eingelesen Zeichen in an Array von chars, sodann wird in der zweiten Zeile ein String aus dem Unicode-Wert erstellt und dann als int und char wieder ausgegeben.


----------



## SE (27. Oktober 2011)

Also ich weis zwar nicht warum du da mit String.copyValueOf(char[]) arbeitest ...
Geht doch viel einfacher mt String(char[]) ... aber man kann es sich auch echt umständlich machen.

@j2se
Tipp : vorher auch mal die Konstruktoren durchgehen ... und nicht nur die (static) Methoden ...


----------



## j2se (27. Oktober 2011)

@Spike: Dir empfehle ich das Buch "Effective Java Programming Language Guide" von J. Bloch, insbesondere Kapitel 2 "Creating and Destroying Objects", Item 1:



> Item 1: Consider providing static factory methods instead of constructors



Ein Klassiker.


----------



## SE (27. Oktober 2011)

Hmm ... komisch nur das ich 4 Java-Bücher hier rumstehen habe ... und dies nirgends steht.
Zu mal : ein Objekt in Java zu "zerstören" ist so in der Form eh nicht möglich ... man muss lediglich alle Referenzen auf NULL setzen ... der GC ruft dann finalize() auf und das Objekt wird aus dem Speicher entfernt.
Dazu macht es gerade bei String absolut KEINEN Unterschied ob ich nun ein Objekt mit "new String(char[])" oder mit "String.copyValueOf(char[])" erzeuge.

Ich möchte dir aber gerade zu String mal den Source zeigen um meine Theorie der "Einfacheit" zu belegen


```
public static String copyValueOf(char data[]) {
        return copyValueOf(data, 0, data.length);
    }

public static String copyValueOf(char data[], int offset, int count) {
        // All public String constructors now copy the data.
        return new String(data, offset, count);
    }

public String(char value[], int offset, int count) {
        if (offset < 0) {
            throw new StringIndexOutOfBoundsException(offset);
        }
        if (count < 0) {
            throw new StringIndexOutOfBoundsException(count);
        }
        // Note: offset or count might be near -1>>>1.
        if (offset > value.length - count) {
            throw new StringIndexOutOfBoundsException(offset + count);
        }
        this.offset = 0;
        this.count = count;
        this.value = Arrays.copyOfRange(value, offset, offset+count);
    }
```


```
public String(char value[]) {
        int size = value.length;
        this.offset = 0;
        this.count = size;
        this.value = Arrays.copyOf(value, size);
    }
```

Bei deiner Variante ergibt das einen Stack bei dem viel mehr gearbeitet wird als wenn du gleich den entsprechenden Konstruktor aufrufst bei dem lediglich Array.copyOf() aufgerufen wird ... was definitiv optimierter und performanter ist ...

Von daher : mag zwar alles stimmen was in deinem Buch steht ... aber der Source beweist es : meine Variante ist besser.


*Manchmal sollte man sich wirklich mal mit der Praxis beschäftigen und Source lesen anstatt blind solchen Büchern zu vertrauen.*


----------



## j2se (27. Oktober 2011)

Der SPiKE will nun auch den J. Bloch belehren. Du kommst nun definitiv auf die Ignorier-Liste.


----------



## SE (27. Oktober 2011)

Auch wenn du das hier nicht mehr lesen wirst ... und es ist mir persönlich auch egal da du dich selbst mir gegenüber als ziemlicher Anfänger in Java geoutet hast ... möchte ich für alle anderen die das hier noch lesen zu deiner Reaktion etwas hinzufügen :

Ich sage ja nicht das dein ach so hochgeschätzter Buchautor im allgemeinen Unrecht hat ... ich habe lediglich versucht dir klar zu machen das deine Interpretation dessen was er geschrieben hat bei String völlig daneben ist. Das ganze habe ich dir auch mit Auszügen aus dem Sun-Source der Klasse String belegt.
Du kannst mir nicht erzählen das es besser wäre einen Stack von 3 Methoden zu erzeugen , dann noch irgendwelche Vergleiche zu machen bei denen auch noch numerische Werte zusammengerechnet werden ... und zusätzlich noch RuntimeExceptions fliegen können ... als ein simples Array-Copy.

Vielleicht ist ja jemand so nett und bringt dir das noch mal auf einem Weg bei wo selbst du es einsehen wirst.

Aber das du mich ignorierst ... na und ... who cares ? Ich kenne mich in Java sehr gut aus *zwar nich in allen Bereichen ... aber das was ich kenne kenne ich auch sehr gut* und ich habe bereits größere Projekte entwickelt und veröffentlicht ... was ich so von dir bisher noch nicht gesehen habe *kann sein das du es hast ... aber dann möchte ich es auch mal sehen*.

Naja ... mach wie du denkst ... und ich so wie ich denke ... mal sehen wer mehr Probleme bekommt.


----------

