# char[]-Array Wert '0-9','A-F' in long-Wert [0-9,10-15] umwandeln



## alta-schwede (16. Jan 2012)

Hallo Leute,
ich stehe vor folgendem Problem,was wahrscheinlich/hoffentlich sehr einfach zu lösen ist.
Aufgabe ist es, eine 8-stellige Hexadezimalzahl als Zeichenkette als String einzulesen, sie muss immer 8 Zeichen lang sein->habe ich hinbekommen, mit string.length realisiert.
Als nächstes sollen die einzelnen Stellen in ein char[]-Array umgewandelt werden.
Auch dass war mit Hilfe einer for-Schleife kein Problem.
Nur an einer Stelle komme ich jetzt seit Stunden nicht voran. Wie ich hexadezimal rechnerisch in Dezimal umwandle,weiss ich. Nur wie wandle ich die einzelnen Variablen des char[]-Arrays in mehrere long-Variablen oder eine long-Variable um?
Mit 
	
	
	
	





```
long dezimal0 = (long) (hex_char[0] - '0');
```
funktioniert es zumindest bei 0-9...aber wie schaffe ich es, aus einem char A bspw. ein long 10 zu machen?
Liebe Grüße und schonmal vielen Dank,
alta-schwede.


----------



## Final_Striker (16. Jan 2012)

z.b so:



> String hex = "2A";
> int intValue = Integer.parseInt(hex, 16);


----------



## irgendjemand (16. Jan 2012)

alternativ bei solch großen zahlen natürlich dann

```
long value=Long.parseLong("dein hex string", 16);
```


----------



## irgendjemand (16. Jan 2012)

was mir grad noch einfällt

8 hex zeichen entsprechen 32bit ... würde also noch in einen int passen
probleme würdest aber bekommen sobald du größere zahlen als 2,1 milliarden darstellen willst da primivitive datentypen grundsätzlich signed sind ..
wenn du also die vollen 4,2 milliarden im positiven bereich darstellen willst brauchst du long ... wie es ja auch deine aufgabenstellung verlangt


----------



## alta-schwede (16. Jan 2012)

aber es geht ja darum die char[]-Werte in long umzuwandeln, nicht den String.
Oder verstehe ich etwas falsch!?

```
String hex_string = "A70000A5";

    char[] hex_char = new char[hex_string.length()];

    for(int i=0; i<hex_string.length();i++)
    {
      hex_char[i] = hex_string.charAt(i);
    }
```
Jetzt möchte ich den Dezimalwert aus den einzelnen char-Arrays als long-Variable berechnen.

Bspw. long dezimal0 = Dezimalwert von hex_char[0], in diesem Fall A => 10

Sodass ich hinterher aus den long-Variablen die Formel zur Berechnung der Dezimalzahl "per Hand" schreiben kann.


----------



## irgendjemand (16. Jan 2012)

wenn du schon einen hex-string hast und aus diesem einen long machen solltest nimm einfach

```
Long.parseLong(String, int);
```
wenn du das selber bauen willst schau dir den code dazu im src.zip in deinem jdk-verzeichnis an


----------



## alta-schwede (16. Jan 2012)

sorry aber dass verstehe ich nicht, oder du verstehst mich falsch.
Ich will die char-Werte in long-Werte umwandeln, nicht den string-Wert!
z.B. char[0] = 'A' = long dezimal0 = 10


----------



## alta-schwede (16. Jan 2012)

ich danke euch, es klappt wunderbar mit den von euch gezeigten Beispielen.
Habe es verstanden, die char[]-Variablen benötige ich nur zur Überprüfung der Eingabe,d.h. ob auch nur 0.9 bzw. A-F eingegeben wurden. Wenn mir noch kurz einer sagen könnte wie ich das am Einfachsten mache wäre ich glücklich 

edit: Eigentlich ist es so nicht richtig, die Umwandlung muss tatsächlich von char[] in long erfolgen ;(
Die Aufgabenstellung lautet:
- Einlesen eines Strings und Abspeichern seiner einzelnen Zeichen in ein char-Array.Die eingegebene Zeichenkette soll eine nichtnegative Hexadezimalzahl mit 8 Ziffern darstellen, also genau 8 Zeichen umfassen, die zur Menge {0...9, A....F} gehören. Für den eingegebenen String sollen diese Bedingungen vom Programm überprüft werden. Im Fehlerfall soll die Eingabe so oft wiederholt werden, bis die Eingabe korrekt ist.
- Durchlauf des Arrays, wobei aus den gespeicherten Ziffern der Dezimalwert der Zahl berechnet wird; Abspeicherung des Werts in einer Variablen vom Typ long.
- Ausgabe des Dezimalwerts auf dem Bildschirm.


----------



## irgendjemand (16. Jan 2012)

doch .. ich hab dich schon verstanden ... nur du uns nicht

ein String ist in java nichts anderes als eine container-klasse für eine sog. CharSequenz ... was java-internet nichts anderes als ein char-array ist ... wie du es hast ...

worauf ich hinaus wollte :

aus dem char-array ein string machen und dann mit diesem parseLong() füttern ...

wenn du das alles wirklich per hand machen willst ... hier mal für dich der source von [c]public static long java.lang.Long.parseLong(String, int)[/c] aus dem src.zip vom jdk7u2

```
public static long parseLong(String s, int radix)
              throws NumberFormatException
    {
        if (s == null) {
            throw new NumberFormatException("null");
        }

        if (radix < Character.MIN_RADIX) {
            throw new NumberFormatException("radix " + radix +
                                            " less than Character.MIN_RADIX");
        }
        if (radix > Character.MAX_RADIX) {
            throw new NumberFormatException("radix " + radix +
                                            " greater than Character.MAX_RADIX");
        }

        long result = 0;
        boolean negative = false;
        int i = 0, len = s.length();
        long limit = -Long.MAX_VALUE;
        long multmin;
        int digit;

        if (len > 0) {
            char firstChar = s.charAt(0);
            if (firstChar < '0') { // Possible leading "+" or "-"
                if (firstChar == '-') {
                    negative = true;
                    limit = Long.MIN_VALUE;
                } else if (firstChar != '+')
                    throw NumberFormatException.forInputString(s);

                if (len == 1) // Cannot have lone "+" or "-"
                    throw NumberFormatException.forInputString(s);
                i++;
            }
            multmin = limit / radix;
            while (i < len) {
                // Accumulating negatively avoids surprises near MAX_VALUE
                digit = Character.digit(s.charAt(i++),radix);
                if (digit < 0) {
                    throw NumberFormatException.forInputString(s);
                }
                if (result < multmin) {
                    throw NumberFormatException.forInputString(s);
                }
                result *= radix;
                if (result < limit + digit) {
                    throw NumberFormatException.forInputString(s);
                }
                result -= digit;
            }
        } else {
            throw NumberFormatException.forInputString(s);
        }
        return negative ? result : -result;
    }
```

da du es dir so umständlich machen willst fällt eine erklärung mal flach ...
produktiv würde man sowas nie selbst machen


----------



## Final_Striker (16. Jan 2012)

alta-schwede hat gesagt.:


> Wenn mir noch kurz einer sagen könnte wie ich das am Einfachsten mache wäre ich glücklich



Am einfachsten ist es, wenn du einen String mit allen erlaubten Zeichen erstellst und vergleichst ob die eingegeben Zeichen im diesem String vorkommen.

z.B. so:


```
String chars = "0123456789ABCDEF";
		
		char a = '2';
		char b = 'R';
		
		System.out.println(chars.contains(a+"")); // true
		System.out.println(chars.contains(b+"")); // false
```


----------



## irgendjemand (16. Jan 2012)

ich denke das das mit ner RegEx sogar noch einfacher gehen würde in dem man auf [c]!pattern.match()[/c] prüft ... also so bald dann der if-block betreten wird weis man das im string nicht-erlaubte zeichen enthalten sind


----------



## alta-schwede (26. Jan 2012)

```
import java.io.*;

public class Aufgabe_4_2_korrektur
{
   public static void main(String args[]) throws IOException
   {
     BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
     String hex_string = "", auswahl = "1";

     while(auswahl.equals("1")) // || hex_string.length != 8) || hex_string.charAt(i) != [A..E] || hex_string.charAt(i) != [0..9]
       {
      System.out.println("Hexadezimal-Umrechner");
      System.out.println();
      System.out.println("(1) = Hexadezimalzahl eingeben");
      System.out.println("(anderes) = Beenden");
      auswahl = in.readLine();
      if (auswahl.equals("1"))
           {
     System.out.print("Jetzt Hexadezimalzahl eingeben: ");
     hex_string = in.readLine();
     char[] hex_char = new char[hex_string.length()];

        for(int i=0; i<hex_string.length();i++)
          {
      hex_char[i] = hex_string.charAt(i);
          }
      System.out.println("Einzelne Werte aus dem hex_char[]-Array:");
      System.out.print(hex_char[0] + " ");
      System.out.print(hex_char[1] + " ");
      System.out.print(hex_char[2] + " ");
      System.out.print(hex_char[3] + " ");
      System.out.print(hex_char[4] + " ");
      System.out.print(hex_char[5] + " ");
      System.out.print(hex_char[6] + " ");
      System.out.print(hex_char[7] + " ");
      System.out.println();
      System.out.println();
      long erg = Long.parseLong(hex_string, 16);
      System.out.println("Der Dezimalwert beträgt:  " + erg);
           }
            else
            {
              break;
            }
       }




    }

}
```

so war letztendlich mein Code...entspricht natürlich nicht ganz den Anforderungen :-(
Habe aber nochmal bis Montag Zeit bekommen, das Ganze zu korrigieren...
Das mit dem RegEx versuche ich selber hinzubekommen, die Umwandlung der einzelnen char-Werte in eine long-Dezimalzahl aber nicht...auch wenn ich die char-Werte vorher wieder in string-Werte umwandle. Habe da stundenlang rumnprobiert, ohne es ans Laufen zu bekommen,sodass der Code oben mein finaler war,sodass zumindest das Programm ohne Fehlermeldungen läuft.
Wäre super wenn ihr mir helfen könntet,Sonntag muss es fertig sein, Montag 13h muss ich es persönlich abgeben.
Hier bräuchte ich nochmal eure Hilfe


----------



## irgendjemand2 (26. Jan 2012)

gut .. und was genau ist jetzt deine frage / dein problem ?
die arbeitsweise von parseLong(String, int) habe ich dir oben gepostet ... sehr viel anderst wirst du es nicht machen können ... und ob du nun copy&paste machst oder die methode dierekt callst ... macht keinen unterschied ...

von daher : wenn dein dozent dir also sagt das du kein Long.parseLong(String, int) verwenden darfst ... dann kannst du ihm ja copy&paste an den kopf werfen ...


----------



## alta-schwede (26. Jan 2012)

irgendjemand2 hat gesagt.:


> gut .. und was genau ist jetzt deine frage / dein problem ?
> die arbeitsweise von parseLong(String, int) habe ich dir oben gepostet ... sehr viel anderst wirst du es nicht machen können ... und ob du nun copy&paste machst oder die methode dierekt callst ... macht keinen unterschied ...
> 
> von daher : wenn dein dozent dir also sagt das du kein Long.parseLong(String, int) verwenden darfst ... dann kannst du ihm ja copy&paste an den kopf werfen ...



ich darf Long.parseLong verwenden...hab es damit aber leider nicht hinbekommen, habe versucht mit 
	
	
	
	





```
String my_string = my_char.toString();
```
 das char zurück in einen String zu wandeln, hat nicht funktioniert...und auch das Umwandeln in ein long mit Long.parseLong hat nicht funktioniert...ich denke, dass es wahrscheinlich garnicht schwer ist, ich aber nur nicht weiss, wie ich es richtig anwende.
Hast ja meinen gesamten Quelltext oben,kannst es dadrin ja mal mit dem Long.parseLong versuchen...natürlich nur,wenn dass nicht zuviel Arbeit ist,aber ich fürchte fast,dass is eigentlich nur eine Sache von 2 Minuten, wenn man weiss wie


----------



## Kiri (26. Jan 2012)

so würde es gehen:


```
erg = Long.parseLong(String.valueOf(hex_char[7]), 16);
```


```
public static String valueOf(char c)

Returns the string representation of the char argument.

Parameters:
    c - a char.
Returns:
    a string of length 1 containing as its single character the argument c.
```

das ganze ist zufinden in der JAVA-API!


----------



## irgendjemand2 (27. Jan 2012)

aber die doc kennst du oder ?

um aus einem char-array ein string zu machen callst du einfach den konstruktor

[c]String string=new String(char-array);[/c]

wirklich ... DOC lesen !


----------



## alta-schwede (29. Jan 2012)

Vielen Dank @kiri und Irgendjemand2, mit euren letzten Beiträgen hat es wunderbar funktioniert...ich danke euch!


----------

