Java Binärzahl in Array einlesen

[Lord Horu$]

Moin liebe CB Community.

Ich hab vor kurzem meine Ausbildung angefangen und somit auch das Programmieren in Java.
Eher zum Zeitvertreib bastel ich momentan an ein Paar eigenen Sachen um mir Java selber beizubringen und so ganz schlecht läuft das auchnich.

Mein momentanes Projekt ist ein binärrechner.
Zahlen von Dezimal in Binär umrechnen klappt schon 1a nun gehts daran das Ganze umzudrehen und eben da häng ich.

Meine Intention ist die folgende (Es gibt sicher bessere Lösungen, nur ist das so der Stand des Wissens, welches ich mir bis jetzt angeeignet habe.)

Ich habe vor eine Binärzahl in ein Array mit 64 Stellen vom Typ Short einzulesen. Nehmen wir mal die 42 das wäre wenn mich mein Kopf nicht täuscht 101010. Jeder Platz des Arrays soll hier dann nur eine einzige Stelle der Zahl beinhalten also:
i=0 wäre 1
i=1 wäre 0
i=2 wäre 1
i=3 wäre 0
i=4 wäre 1
i=5 wäre 0

Die Potenz zur Berechnung wäre dann der Arrayindikator, nachdem er eingelesen hat (hier 5) und zum rechnen denn halt (2 ^[{Arrayindikator-Potenz}*{-1}])*Arrayinhalt+x. -Ich hoff die Rechnung war etz richtig ich hab gerade n RIESEn Strucktogramm vor mir - X wäre dann die Arraystelle, welche zuvor berechnet wurde. Das in ner Schleife solange bis das Array durch ist.
Also hier:
(2^(0-5)*(-1))*1+0 = 32
(2^(1-5)*(-1))*0+32 = 32
(2^(2-5)*(-1))*1+32 = 40
(2^(3-5)*(-1))*0+40 = 40
(2^(4-5)*(-1))*1+40 = 42
(2^(5-5)*(-1))*0+42 = 42
ENDE (Oh mann. Wie bin ich nur auf diese Rechnung gekommen?)
Nun zum eigentlichen Problem:
Wie bekomme ich die einzelnen Stellen in das Array wie oben beschrieben? Es ist bei dieser Methode nun wirklich notwendig dass die Binärzahlstellen in die einzelnen Arrayzellen eingelesen werden und nicht die ganze Zahl in eine Zelle.
Ich hoffe das is verständlich (und richtig) ich hab mich gerade nämlich selber etwas verwirrt .

MFG
Horu$

 

[honky-tonk]

in welcher form liegen dir denn die zahlen momentan vor? am einfachsten wäre den kram erstmal in einen string zu stopfen und dann die einzelnen stellen des strings in das array mit einer for schleife zu lesen

 

[deveth0]

Ich nehme an, du meinst einlesen von der Konsole?

Recht einfach:
Mach einen String der eingelesen werden soll, überprüfe ob dieser maximal 64 Stellen lang ist.
Dann kannst du mit String.charAt die einzelnen Zeichen parsen und überprüfen, ob sie nur 0 oder 1 sind. wenn ja, schreibste dass dann an die passende Stelle in deinem Array.

Wobei ich das Array einfach als Boolean machen würde und dann sowas hier:

final Array binary = new Array<Boolean>[MyString.length];
boolean tmp;
for(int i = 0; i < MyString.length; i ++){
    if(MyString.charAt(i) == '0'){
       binary[i] = false;
    }
    else if(MyString.charAt(i) == '1'){
       binary[i] = true;
    }
    else{
       throw new RuntimeException();   //Hier dann deine Fehlerbehandlung 
    }
}

Mit sowas könntest du dann auch eine beliebig lange Binärzahl parsen und verarbeiten.

 

[toxn]

Es gibt verschiedene Varianten. Am einfachsten in String konvertieren und anschliessend mit String.toBinary() umwandeln.
Etwas komplizierter ist die Variante mit Bitoperatoren.

for(int i=0; i < anzahlBitStellen; i++)
     array[i] = (x>>i)&1;

So haettest du dann das gewollte Array. x ist in diesem Fall eine Intergerzahl. Der Code verschiebt die Bits immer um eine Stelle nach rechts und prueft dann mit logischem Und und 1 ob die letzte Bitstelle eine 1 oder 0 ist. Das sollte funktionieren.

 

[deveth0]

Naja, er will aber ja selbst umrechnen

 

[toxn]

Na macht doch mein Code auch. Wenn er die Zahl 42 hat dann hat er am Ende genau das gewollte Bitarray und kann dann seine oben beschriebene Rechnung durchfuehren.
Es ist ja im Moment noch unklar inwiefern die Binaerzahl vorliegt. Ich bin davon ausgegangen, dass sie garnicht vorliegt

 

[ice-breaker]

Ich habe vor eine Binärzahl in ein Array mit 64 Stellen vom Typ Short einzulesen.

Short hat 16 Bits, mir ist da nicht ganz klar, wie du da ein Array mit 64 Bits hineinquetschen willst.
Bedenke zudem, dass wenn du das vorderste Bit auf 1 setzt du negative Zahlen im Zweierkomplett bekommst.

 

[deveth0]

Short hat 16 Bits, mir ist da nicht ganz klar, wie du da ein Array mit 64 Bits hineinquetschen willst.
Bedenke zudem, dass wenn du das vorderste Bit auf 1 setzt du negative Zahlen im Zweierkomplett bekommst.

Naja und ein Array mit 64 Stellen à 16 Bit reicht ja wohl locker für eine kleine Binärzahl aus

 

[ice-breaker]

Ich habe ihn ehrlich gesagt so verstanden, dass in jeder Array-Position eine 1 oder eine 0 steht, und davon eben 64 Elemente. Und die würden eben nicht mehr in einen 16 Bit Datentyp passen.

 

[Lord Horu$]

Ersteinma danke.

@ice-breaker: Ich will tatsächlich pro Arrayfeld nur eine Zahl einlesen. Eben eine 0 oder eine 1.
Da braucht es keine großen Datentypen. Das belegt nur unnötig Speicher. Die 64 Stellen des Arrays werden dann meine Bit-Stellen sein.
Wie gesagt es ist evtl. nicht die eleganteste Lösung, aber es führen ja bekanntlich viele Wege nach Rom. Für den Anfang finde ich das garnich ma übel. Bin ja gerademal 2 Monate dabei.

Vorerst geht es mir um positive Zahlen. Das mit dem zweierkomplement haben wir inner Schule schon gehabt, das ist dann aber der nächste Schritt: rechnen mit Binärzahlen. Vorerst geht es mir nur ums hin und herwandeln.

EDIT:

Habe folgendes Problem jetzt:
Wollte gerade die Stringlänge herausfinden und diese in eine variable "l" einlesen.

Das sieht dann so aus:

i = String.lenghth

AHHH FUCK ICH BIN EIN DEPP!!! xD tippfehler!

EDIT2:

Nächstes Problem.
Ich hab das mal so gemacht wie AlrikvomFluss geschrieben hat mit ein paar kleinen Abwandlungen.
Ersma hab ich ne Kopf gesteuerte Whileschleife gemacht, da ich mit denen besser zurecht komme und ich hab das Array etz nicht mit boolean gemacht, da ich mit den Werten später noch rechnen will, was mit Boolean nicht möglich ist.

Folgender Erguss ist dabei herausgekommen:

    i = 0;
    while (i <= l) {
          if(a.charAt(i) == '0'){
             bin[i] = 0;
          } else if(a.charAt(i) == '1'){
             bin[i] = 1;
          } else {
            throw new RuntimeException("ERROR!");
          }
          i ++;
    }

Nun spuckt er mir beim Einlesen folgenden fehler aus:

Expection in thread "main" java.lang.StringIndexOutOfBoundsExpection: String index out of range: 1 (Wenn ich garnichts eingebe. Wenn ich etwas eingebe is das halt höher.)

Ich kann mir grob was drunter vorstellen, nur hab ich keinen Plan was das im zusammenhang soll und warum genau das auftaucht. Sicher n dummer Anfängerfehler.

 

[honky-tonk]

wenn ich es richtig verstehe dann ist bin ein array!? bei diesen arrays musst du bei der instanzierung die größe zuweisen die er haben soll!

also: int[] bin=new int(a.length())

so sollte es denk ich funtzen

edit: es könnte auch sein dass es an der while schleife hängt du also mehr elemente einlesen willst als voranden:

ändere mal while(i<a.length())

wichtig: kleiner!!! a="abc" hat eine länge von 3 aber nur charAt(0),1,2 elemente!!!!

 

[deveth0]

Oder nutze die schöne for Schleife mit Iteration

 

[Lord Horu$]

Es...war...das Gleichzeichen ^^'

Danke honky-tonk undäh das Array ist initialisiert. Das hab ich nur weggelassen.

 

[Killkrog]

Hi!

Vielleicht gibt dir das die ein oder andere Anregung

Lieben Gruß

public class Binary {

    private static long binArray2Dec(boolean[] arr) {
        long value = 0L;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]) {
                value += Math.pow(2, i);
            }
        }
        return value;
    }

    private static boolean char2bool(char c) throws Exception {
        if (c == '0') {
            return false;
        } else if (c == '1') {
            return true;
        }
        throw new Exception();
    }

    public static void main(String[] args) {
        boolean[] arr = null;
        String input = null;

        // Stimmt die äußere Form der Eingabe? (Nur ein Paramter, zwischen 1 und 64 Zeichen lang)
        if (args.length == 1 && (input = args[0]).length() > 0 && input.length() <= 64) {
            // Ja, stimmt soweit! Array initialisieren und die Eingabe einmal genau durchschauen!
            arr = new boolean[64];
            for (int i = 0; i < input.length(); i++) {
                try {
                    // Die 0 bzw 1 wird in ein boolean umgewandelt und (in umgedrehter Reihenfolge) in das
                    // Array geschrieben!
                    arr[input.length() - 1 - i] = char2bool(input.charAt(i));
                } catch (Exception e) {
                    // Wenn es etwas anderes als eine 0 oder 1 war, wirft unsere Methode eine Exception und
                    // wir setzen das Array auf null. Damit wissen wir, dass wir dem Benutzer einen Fehler
                    // ausgeben müssen!
                    arr = null;
                    break; // Und raus aus der Schleife, ein Fehler reicht uns...
                }
            }
        }
        if (arr != null) {
            // Alles ist gut gelaufen, wir können das Array verarbeiten!
            System.out.println("Bin: " + input);
            System.out.println("->");
            System.out.println("Dec: " + binArray2Dec(arr));
            return;
        }

        // Auf die Nase gefallen...
        System.err.println("ERROR: parameter must be a sequence of 1 up to 64 binary values (0|1)!");
    }
}