Programmfehler mit Array

[javastudent25]

Hallo zusammen

Ich bin neu hier im Forum und benötige etwas Hilfe.
Mein Programm funktioniert irgendwie nicht, weil ich ein Array nicht ausgeben kann. Ich komme offensichtlich über die Arraygrösse hinaus. Ich komme aber nicht ganz drauf, was genau das Problem ist. Ich denke es fängt an mit der Zeile 38, falls das hier später angezeigt wird

Hier ist der Code

import java.io.*;

public class dezimalzahl {

    public static void main(String[] args) throws IOException {

        // ab hier wird eine Zahl eingelesen und ausgegeben
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        System.out.print("Gib eine Zahl ein: ");
        String eingabe = br.readLine();
        int Zahl = Integer.parseInt(eingabe);
        System.out.println("Du hast die Zahl " + Zahl + " eingegeben.");

        // ab hier wird eine Basis eingelesen und ausgegeben
        InputStreamReader isr2 = new InputStreamReader(System.in);
        BufferedReader br2 = new BufferedReader(isr2);
        System.out.print("Gib eine Basis ein: ");
        String eingabe2 = br2.readLine();
        int Basis = Integer.parseInt(eingabe2);
        System.out.println("Du hast die Basis " + Basis + " eingegeben.");

        int Dividend = Zahl;
        int Rest = 0;
        int i = 0;

        while (Dividend > 0) { // notwendige Grösse des Arrays berechnen

            Dividend = Dividend / Basis;
            i++;
        }

        Dividend = Zahl;
        int[] Array = new int[i]; // Array festlegen
        int s = 0;

        while (Dividend >= 0) { // Dividend und Rest (Binärcode = Rest) berechnen mittels Modulo Operator

            Rest = Dividend % Basis;
            Dividend = Dividend / Basis;
            Array[s] = Rest; // Binärcode ins Array von hinten ausgehend schreiben
            s++;
            if (s > 4) {
                Dividend = 0;
            }

        }

        // oder anders
//        for (int a = 0; a <= Array.length; a++) { // Binärcode darstellen
//            if (a > Array.length) {
//                a = Array.length;
//            }
//            System.out.println(Array[a]);
//        }
    }
}

 

[Tarrew]

Probiers mal mit:

while (Dividend > 0) {
//...
}

bei der zweiten while-Schleife.

Die if-Abfrage kannste rausnehmen. Aber im Moment schreibst du die Zahlen noch von vorne ausgehend ins Array und nicht wie es in deinem Kommentar steht von hinten ausgehend.

Achja, du solltest dir angewöhnen Variablennamen klein zu schreiben.

 

[javastudent25]

Hallo Tarrew

Vielen Dank für deinen Hinweis. Ich habe den Code angepasst, den Kommentar hatte ich wie es scheint vergessen zu ändern.

Leider funktioniert es immer noch nicht, mein Latein ist hier leider schon zu Ende.
Ich habe absolut keine Ahnung warum das nicht tut.

das ist der Fehler:

Gib eine Zahl ein: 22
Du hast die Zahl 22 eingegeben.
Gib eine Basis ein: 2
Du hast die Basis 2 eingegeben.
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
    at dezimalzahl.main(dezimalzahl.java:52)

und hier der Code

import java.io.*;

public class dezimalzahl {

    public static void main(String[] args) throws IOException {

        // ab hier wird eine Zahl eingelesen und ausgegeben
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        System.out.print("Gib eine Zahl ein: ");
        String eingabe = br.readLine();
        int zahl = Integer.parseInt(eingabe);
        System.out.println("Du hast die Zahl " + zahl + " eingegeben.");

        // ab hier wird eine Basis eingelesen und ausgegeben
        InputStreamReader isr2 = new InputStreamReader(System.in);
        BufferedReader br2 = new BufferedReader(isr2);
        System.out.print("Gib eine Basis ein: ");
        String eingabe2 = br2.readLine();
        int basis = Integer.parseInt(eingabe2);
        System.out.println("Du hast die Basis " + basis + " eingegeben.");

        int dividend = zahl;
        int rest = 0;
        int i = 0;

        while (dividend > 0) { // notwendige Grösse des Arrays berechnen

            dividend = dividend / basis;
            i++;
        }

        dividend = zahl;
        int[] array = new int[i]; // Array festlegen
        int s = 0;

        while (dividend > 0) { // Dividend und Rest (Binärcode = Rest) berechnen mittels Modulo Operator

            rest = dividend % basis;
            dividend = dividend / basis;
            array[s] = rest; // Binärcode ins Array schreiben
            s++;

        }

      
        for (int a = array.length; a >= 0; a--) { // Binärcode von hinten ausgehend darstellen
            if (a > array.length) {
                a = array.length;
            }
            System.out.print(array[a]); // schreibt alles in eine Zeile
        }
    }
}

 

[Tarrew]

Die Berechnung stimmt jetzt, nur deine Ausgabe passt nicht.
Wenn dein Array die Länge 5 hat, dann hast du folgende Einträge:
array[0], array[1], array[2], array[3] und array[4].

In deiner Ausgabe versuchst du aber auf array[5] zuzugreifen.

Und die if-Bedingung kann auch raus

 

[javastudent25]

So einfach? Cool, vielen Dank Tarrew. Ich denke, ich hätte schon viel eher fragen sollen.
Nochmals vielen Dank

import java.io.*;

public class dezimalzahl {

    public static void main(String[] args) throws IOException {

        // ab hier wird eine Zahl eingelesen und ausgegeben
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        System.out.print("Gib eine Zahl ein: ");
        String eingabe = br.readLine();
        int zahl = Integer.parseInt(eingabe);
        System.out.println("Du hast die Zahl " + zahl + " eingegeben.");

        // ab hier wird eine Basis eingelesen und ausgegeben
        InputStreamReader isr2 = new InputStreamReader(System.in);
        BufferedReader br2 = new BufferedReader(isr2);
        System.out.print("Gib eine Basis ein: ");
        String eingabe2 = br2.readLine();
        int basis = Integer.parseInt(eingabe2);
        System.out.println("Du hast die Basis " + basis + " eingegeben.");

        int dividend = zahl;
        int rest = 0;
        int i = 0;

        while (dividend > 0) { // notwendige Grösse des Arrays berechnen

            dividend = dividend / basis;
            i++;
        }

        dividend = zahl;
        int[] array = new int[i]; // Array festlegen
        int s = 0;

        while (dividend > 0) { // Dividend und Rest (Binärcode = Rest) berechnen mittels Modulo Operator

            rest = dividend % basis;
            dividend = dividend / basis;
            array[s] = rest; // Binärcode ins Array schreiben
            s++;

        }

     
        for (int a = array.length -1; a >= 0; a--) { // Binärcode von hinten ausgehend darstellen
           
             System.out.print(array[a]); // schreibt alles in eine Zeile
        }
    }
}

 

[javastudent25]

Ich habe noch eine kleine Verständnisfrage:
Ich habe zuvor bei dem Block für die Ermittlung der Basis und der Zahl ein try und catch drin gehabt.
Jedoch hatte ich diese Entfernen müssen, da ich sonst nicht die Zuweisung int dividend = zahl; machen konnte. Das funktioniert ja mit dem try und catch nicht, warum auch immer.
Ich müsste dann entweder im ersten Block oder im 2. Block weitere Operationen vornehmen.
Da ich ja beide Variablen Zahl und Basis benötige funktioniert das ja weder noch..
Ist das so wie ich es beschreibe ungefähr verständlich?
Sprich, wenn try und catch hinzugefügt wird, funktioniert das Programm wie es geschrieben ist leider nicht mehr.

 

[Tarrew]

Poste doch mal den Code mit dem try-catch Versuch, dann kann man besser sehen was dein Problem war.

 

[javastudent25]

Hier ist der Code

Fehler sind Folgende

Exception in thread "main" java.lang.Error: Unresolved compilation problems:
zahl cannot be resolved to a variable
basis cannot be resolved to a variable
zahl cannot be resolved to a variable
basis cannot be resolved to a variable
basis cannot be resolved to a variable

at dezimalzahl.main(dezimalzahl.java:32)

import java.io.*;

public class dezimalzahl {

    public static void main(String[] args) throws IOException {

        // ab hier wird eine Zahl eingelesen und ausgegeben
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            System.out.print("Gib eine Zahl ein: ");
            String eingabe = br.readLine();
            int zahl = Integer.parseInt(eingabe);
            System.out.println("Du hast die Zahl " + zahl + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // ab hier wird eine Basis eingelesen und ausgegeben
        try {
            InputStreamReader isr2 = new InputStreamReader(System.in);
            BufferedReader br2 = new BufferedReader(isr2);
            System.out.print("Gib eine Basis ein: ");
            String eingabe2 = br2.readLine();
            int basis = Integer.parseInt(eingabe2);
            System.out.println("Du hast die Basis " + basis + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        int dividend = zahl;
        int rest = 0;
        int i = 0;

        while (dividend > 0) { // notwendige Grösse des Arrays berechnen

            dividend = dividend / basis;
            i++;
        }

        dividend = zahl;
        int[] array = new int[i]; // Array festlegen
        int s = 0;

        while (dividend > 0) { // Dividend und Rest (Binärcode = Rest) berechnen
                                // mittels Modulo Operator

            rest = dividend % basis;
            dividend = dividend / basis;
            array[s] = rest; // Binärcode ins Array schreiben
            s++;

        }

        for (int a = array.length - 1; a >= 0; a--) { // Binärcode von hinten
                                                        // ausgehend darstellen

            System.out.print(array[a]); // schreibt alles in eine Zeile
        }
    }
}

 

[Tarrew]

Wenn du eine Variable in einem try-catch Block deklarierst ist sie auch nur in dem Block sichtbar und nicht von außerhalb. Du hättest 'zahl' und 'basis' also außerhalb deklarieren müssen.

 

[javastudent25]

Ok, das ist genau das Problem, das sich mir stellt.
Wo genau muss ich das machen?
Innerhalb der Klasse ist es ja für alle greifbar.

Ich bekomme nun folgende Fehler:

Exception in thread "main" java.lang.Error: Unresolved compilation problems:
Cannot make a static reference to the non-static field zahl
Cannot make a static reference to the non-static field zahl
Cannot make a static reference to the non-static field basis
Cannot make a static reference to the non-static field basis
Cannot make a static reference to the non-static field zahl
Cannot make a static reference to the non-static field basis
Cannot make a static reference to the non-static field zahl
Cannot make a static reference to the non-static field basis
Cannot make a static reference to the non-static field basis

at dezimalzahl.main(dezimalzahl.java:18)

Es ist nun nur ein Teil des Codes dargestellt

import java.io.*;

public class dezimalzahl {
   
    int zahl;
    int basis;

    public static void main(String[] args) throws IOException {
       

        // ab hier wird eine Zahl eingelesen und ausgegeben
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            System.out.print("Gib eine Zahl ein: ");
            String eingabe = br.readLine();
            zahl = Integer.parseInt(eingabe);
            System.out.println("Du hast die Zahl " + zahl + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        // ab hier wird eine Basis eingelesen und ausgegeben
        try {
            InputStreamReader isr2 = new InputStreamReader(System.in);
            BufferedReader br2 = new BufferedReader(isr2);
            System.out.print("Gib eine Basis ein: ");
            String eingabe2 = br2.readLine();
            basis = Integer.parseInt(eingabe2);
            System.out.println("Du hast die Basis " + basis + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }

 

[Tarrew]

Wo sie jetzt stehen sind es Attribute der Klasse. Aber dein gesamter Code steht in der statischen main-Methode. Auf die Attribute hast du nur aus einem nicht-statischem Kontext Zugriff.
Also wenn du dir ein neues Objekt erzeugst zB.
new dezimalzahl().zahl=5; oÄ.

In deinem Beispiel kannst du die Variablen einfach am Anfang der Methode deklarieren.

 

[javastudent25]

also vor die main Methode gesetzt tut das auch nicht wirklich

Exception in thread "main" java.lang.Error: Unresolved compilation problems:
    The local variable zahl may not have been initialized
    The local variable basis may not have been initialized
    The local variable zahl may not have been initialized
    The local variable basis may not have been initialized
    The local variable basis may not have been initialized

    at dezimalzahl.main(dezimalzahl.java:35)

Teilcode

public static void main(String[] args) throws IOException {

        int zahl;
   
        // ab hier wird eine Zahl eingelesen und ausgegeben
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            System.out.print("Gib eine Zahl ein: ");
            String eingabe = br.readLine();
            zahl = Integer.parseInt(eingabe);
            System.out.println("Du hast die Zahl " + zahl + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }
   
        int basis;
        // ab hier wird eine Basis eingelesen und ausgegeben
        try {
            InputStreamReader isr2 = new InputStreamReader(System.in);
            BufferedReader br2 = new BufferedReader(isr2);
            System.out.print("Gib eine Basis ein: ");
            String eingabe2 = br2.readLine();
            basis = Integer.parseInt(eingabe2);
            System.out.println("Du hast die Basis " + basis + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }

 

[Tarrew]

Ja das ist ein anderer Fehler jetzt
Gib der Zahl einen Startwert. 0 oder irgendwas.

 

[javastudent25]

Du bist ein Fuchs Woher weisst du das??
und warum muss ich da unbedingt einen Wert geben?

 

[Tarrew]

Wenn man das nicht machen müsste, dann könnte sowas passieren:

        int zahl;
        try{
            int a = 5/0;
            zahl=a;
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println(zahl);

zahl=a wird garnicht mehr ausgeführt weil vorher eine Exception geworfen wird.
Später versuchst du aber nochmal auf die Variable zuzugreifen. Diese hat aber unter Umständen garkeinen Wert (wie genau in diesem Fall).

Bei dir kann das gleiche passieren. Bevor du in deinem try-Block zu der Zuweisung kommst, könnte eine Exception geworfen worden sein. Dann wird die Zuweisung nicht vorgenommen und die Variable hat bei deinem späteren Zugriff darauf keinen Wert. Deswegen muss sie vorher initialisiert werden.

 

[javastudent25]

Achso, weil die Exception kommt und dann sofort in der try Funktion alles Folgende ignoriert wird, alles klar
dann kann morgen die nächste Übung vorgenommen werden.
Ich bin noch sowas von grün hinter den Ohren, was das Programmieren angeht.
Vielen Dank

 

[javastudent25]

Hier ist der korrekte Code für Interessierte

import java.io.*;

//Dieses Programm wandelt eine Dezimalzahl je nach Basis in einen Binärcode um, wobei anzumerken ist, dass die Basis 16 hier nicht mehr
//korrekt funktioniert, da die Angaben >10 nicht mit Buchstaben A-F erfolgen

public class dezimalzahl {

    public static void main(String[] args) throws IOException {

        int zahl=0;
      
        // ab hier wird eine Zahl eingelesen und ausgegeben
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            System.out.print("Gib eine Zahl ein: ");
            String eingabe = br.readLine();
            zahl = Integer.parseInt(eingabe);
            System.out.println("Du hast die Zahl " + zahl + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }
      
        int basis=0;
        // ab hier wird eine Basis eingelesen und ausgegeben
        try {
            InputStreamReader isr2 = new InputStreamReader(System.in);
            BufferedReader br2 = new BufferedReader(isr2);
            System.out.print("Gib eine Basis ein: ");
            String eingabe2 = br2.readLine();
            basis = Integer.parseInt(eingabe2);
            System.out.println("Du hast die Basis " + basis + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        int dividend = zahl;
        int rest = 0;
        int i = 0;

        while (dividend > 0) { // notwendige Grösse des Arrays berechnen

            dividend = dividend / basis;
            i++;
        }

        dividend = zahl;
        int[] array = new int[i]; // Array festlegen
        int s = 0;

        while (dividend > 0) { // Dividend und Rest (Binärcode = Rest) berechnen
                                // mittels Modulo Operator

            rest = dividend % basis;
            dividend = dividend / basis;
            array[s] = rest; // Binärcode ins Array schreiben
            s++;

        }

        for (int a = array.length - 1; a >= 0; a--) { // Binärcode von hinten
                                                        // ausgehend darstellen

            System.out.print(array[a]); // schreibt alles in eine Zeile
        }
    }
}

 

[javastudent25]

Ich konnte leider keine Ruhe geben.
Ich dachte, das geht sicher schnell, aber das ist die Variante die mir auf die Schnelle eingefallen ist.
Eine Bessere habe ich leider nicht.
Das mit dem char funktioniert irgendwie nicht im 2. while.

import java.io.*;

//Dieses Programm wandelt eine Dezimalzahl je nach Basis in einen Binärcode um, wobei anzumerken ist, dass die Basis 16 hier nicht mehr
//korrekt funktioniert, da die Angaben >10 nicht mit Buchstaben A-F erfolgen

public class dezimalzahl {

    public static void main(String[] args) throws IOException {

        int zahl = 0;

        // ab hier wird eine Zahl eingelesen und ausgegeben
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            System.out.print("Gib eine Zahl ein: ");
            String eingabe = br.readLine();
            zahl = Integer.parseInt(eingabe);
            System.out.println("Du hast die Zahl " + zahl + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        int basis = 0;
        // ab hier wird eine Basis eingelesen und ausgegeben
        try {
            InputStreamReader isr2 = new InputStreamReader(System.in);
            BufferedReader br2 = new BufferedReader(isr2);
            System.out.print("Gib eine Basis ein: ");
            String eingabe2 = br2.readLine();
            basis = Integer.parseInt(eingabe2);
            System.out.println("Du hast die Basis " + basis + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        int dividend = zahl;
        int rest = 0;
        int i = 0;

        while (dividend > 0) { // notwendige Grösse des Arrays berechnen

            dividend = dividend / basis;
            i++;
        }

        dividend = zahl;
        int[] array = new int[i]; // Array festlegen
        int s = 0;

        while (dividend > 0) { // Dividend und Rest (Binärcode = Rest) berechnen
                                // mittels Modulo Operator

            rest = dividend % basis;
            dividend = dividend / basis;
            char v;
            array[s] = rest; // Binärcode ins Array schreiben
            if (basis == 16) {
                if (rest == 10) {
                    v = 65;
                    array[s] = v;
                } else if (rest == 11) {
                    v = 66;
                    array[s] = v;
                } else if (rest == 12) {
                    v = 67;
                    array[s] = v;
                } else if (rest == 13) {
                    v = 68;
                    array[s] = v;
                } else if (rest == 14) {
                    v = 69;
                    array[s] = v;
                } else if (rest == 15) {
                    v = 70;
                    array[s] = v;
                }
              
                s++;

            }

            for (int a = array.length - 1; a >= 0; a--) { // Binärcode von
                                                            // hinten
                                                            // ausgehend
                                                            // darstellen

                System.out.print(array[a]); // schreibt alles in eine Zeile
            }
        }
    }
}

 

[javastudent25]

Hallo zusammen
Ich habe heute noch versucht aus dem Int einen Char Array zu machen.
Jedoch kommt mir dann ein Fehler: Type mismatch: cannot convert from int to char.
Ich kann ja den Rest den ich berechne und die Variablen, die davon abhängen, nicht auch noch char setzen, weil ich ja werte > 255 (unsigned) verwenden möchte. Es kann ja sein, dass jemand 1000 eingibt.
Ausserdem schaffe ich es irgendwie nicht, dass mir beispielsweise der ASCII Code 70 den Buchstaben F ausgibt.
Vielen Dank

 

[Tarrew]

Am besten ist es immer wenn du deinen Code direkt mitpostest, dann sieht man wo es konkret Probleme gibt.

 

[javastudent25]

Ich habe die Änderung in Zeile 49 gemacht

Hier ist der Code:

import java.io.*;

//Dieses Programm wandelt eine Dezimalzahl je nach Basis in einen Binärcode um, wobei anzumerken ist, dass die Basis 16 hier nicht mehr
//korrekt funktioniert, da die Angaben >10 nicht mit Buchstaben A-F erfolgen

public class dezimalzahl {

    public static void main(String[] args) throws IOException {

        int zahl = 0;

        // ab hier wird eine Zahl eingelesen und ausgegeben
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            System.out.print("Gib eine Zahl ein: ");
            String eingabe = br.readLine();
            zahl = Integer.parseInt(eingabe);
            System.out.println("Du hast die Zahl " + zahl + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        int basis = 0;
        // ab hier wird eine Basis eingelesen und ausgegeben
        try {
            InputStreamReader isr2 = new InputStreamReader(System.in);
            BufferedReader br2 = new BufferedReader(isr2);
            System.out.print("Gib eine Basis ein: ");
            String eingabe2 = br2.readLine();
            basis = Integer.parseInt(eingabe2);
            System.out.println("Du hast die Basis " + basis + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        int dividend = zahl;
        int rest = 0;
        int i = 0;

        while (dividend > 0) { // notwendige Grösse des Arrays berechnen

            dividend = dividend / basis;
            i++;
        }

        dividend = zahl;
        char[] array = new char[i]; // Array festlegen
        int s = 0;

        while (dividend > 0) { // Dividend und Rest (Binärcode = Rest) berechnen
                                // mittels Modulo Operator

            rest = dividend % basis;
            dividend = dividend / basis;
            char v;
            array[s] = rest; // Binärcode ins Array schreiben
            if (basis == 16) {
                if (rest == 10) {
                    v = 65;
                    array[s] = v;
                } else if (rest == 11) {
                    v = 66;
                    array[s] = v;
                } else if (rest == 12) {
                    v = 67;
                    array[s] = v;
                } else if (rest == 13) {
                    v = 68;
                    array[s] = v;
                } else if (rest == 14) {
                    v = 69;
                    array[s] = v;
                } else if (rest == 15) {
                    v = 70;
                    array[s] = v;
                }
              
                s++;

            }

            for (int a = array.length - 1; a >= 0; a--) { // Binärcode von
                                                            // hinten
                                                            // ausgehend
                                                            // darstellen

                System.out.print(array[a]); // schreibt alles in eine Zeile
            }
        }
    }
}

 

[InfectedBytes]

rest ist nunmal ein int (32 bit ganzzahl mit vorzeichen)
array[s] ist ein char (16bit ganzzahl ohne vorzeichen)
du kannst "größere" datentypen nicht einfach einem kleineren zuweisen. Da potentiell informationen verloren gehen könnten, musst du einen expliziten typecast durchführen:

array[s] = (char)rest;

 

[javastudent25]

Hallo InfectedByte
Ok, ich verstehe, danke vielmals für deine Hilfe. Aber das wirft gerade einige Fragen auf.
Wenn mein Rest nun angenommen nur gering grösser ist als eine 16Bit Zahl, dann habe ich bereits da schon einen Fehler drin, obwohl ich das so casten und anpassen kann. Mit dem Cast ist also nicht garantiert, dass mein Rest auch wirklich immer in den Char Array passt. Verstehe ich das richtig? Kann ich überhaupt ein Array generieren, das Zeichen enthalten kann und grösser ist als 16Bit? Oder bin ich mit dem Array auf diese Dimension beschränkt?

 

[javastudent25]

Nach langem Hin und Her funktioniert übrigens nun zwar der Cast, aber wenn ich die If-Bedingung mit dem A-F einfachheitshalber weglasse, funktioniert so nicht einmal mehr meine Binärcodedarstellung.

import java.io.*;

//Dieses Programm wandelt eine Dezimalzahl je nach Basis in einen Binärcode um, wobei anzumerken ist, dass die Basis 16 hier nicht mehr
//korrekt funktioniert, da die Angaben >10 nicht mit Buchstaben A-F erfolgen

public class dezimalzahl {

    public static void main(String[] args) throws IOException {

        int zahl = 0;

        // ab hier wird eine Zahl eingelesen und ausgegeben
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            System.out.print("Gib eine Zahl ein: ");
            String eingabe = br.readLine();
            zahl = Integer.parseInt(eingabe);
            System.out.println("Du hast die Zahl " + zahl + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        int basis = 0;
        // ab hier wird eine Basis eingelesen und ausgegeben
        try {
            InputStreamReader isr2 = new InputStreamReader(System.in);
            BufferedReader br2 = new BufferedReader(isr2);
            System.out.print("Gib eine Basis ein: ");
            String eingabe2 = br2.readLine();
            basis = Integer.parseInt(eingabe2);
            System.out.println("Du hast die Basis " + basis + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        int dividend = zahl;
        int rest = 0;
        int i = 0;

        while (dividend > 0) { // notwendige Grösse des Arrays berechnen

            dividend = dividend / basis;
            i++;
        }

        dividend = zahl;
        char[] array = new char[i]; // Array festlegen
        int s = 0;

        while (dividend > 0) { // Dividend und Rest (Binärcode = Rest) berechnen
                                // mittels Modulo Operator

            rest = dividend % basis;
            dividend = dividend / basis;
            array[s] = (char) rest;    // Binärcode ins Array schreiben
            s++;

            }

            for (int a = array.length - 1; a >= 0; a--) { // Binärcode von
                                                            // hinten
                                                            // ausgehend
                                                            // darstellen

                System.out.print(array[a]); // schreibt alles in eine Zeile
            }
        }
    }

 

[javastudent25]

Weiss irgendjemand weiter oder seid ihr schon in Silvesterstimmung?

 

[Tarrew]

Du schreibst den Rest als char ins Array.
Wenn du hinterher '0' und '1' in deinem Array hast und das ausgibst dann kommen da unlesbare Zeichen raus, weil eben die Zeichen mit dem ASCII-Wert '0' und '1' ausgegeben werden.

Wenn du wieder auf die Zahlen kommen willst musst du 48 draufrechnen:

System.out.print((char)(array[a]+48));

 

[javastudent25]

Wenn ich es so mache, wie du es angegeben hast dann funktioniert es.
Jedoch aber, wenn ich wieder die if Bedingungen wegen diesen A-F Bezeichnungen hinzufüge, stimmt nicht einmal mehr die Binärcodedarstellung.

Ich versteh das einfach nicht. Da die If Anweisung nur dann bearbeitet werden soll, wenn die Basis 16 ist. Das sollte eigentlich keine Auswirkung auf die Binärcodedarstellung mit der Basis 2 oder alles andere haben ausser 16.

import java.io.*;

//Dieses Programm wandelt eine Dezimalzahl je nach Basis in einen Binärcode um, wobei anzumerken ist, dass die Basis 16 hier nicht mehr
//korrekt funktioniert, da die Angaben >10 nicht mit Buchstaben A-F erfolgen

public class dezimalzahl {

    public static void main(String[] args) throws IOException {

        int zahl = 0;

        // ab hier wird eine Zahl eingelesen und ausgegeben
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            System.out.print("Gib eine Zahl ein: ");
            String eingabe = br.readLine();
            zahl = Integer.parseInt(eingabe);
            System.out.println("Du hast die Zahl " + zahl + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        int basis = 0;
        // ab hier wird eine Basis eingelesen und ausgegeben
        try {
            InputStreamReader isr2 = new InputStreamReader(System.in);
            BufferedReader br2 = new BufferedReader(isr2);
            System.out.print("Gib eine Basis ein: ");
            String eingabe2 = br2.readLine();
            basis = Integer.parseInt(eingabe2);
            System.out.println("Du hast die Basis " + basis + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        int dividend = zahl;
        int rest = 0;
        int i = 0;

        while (dividend > 0) { // notwendige Grösse des Arrays berechnen

            dividend = dividend / basis;
            i++;
        }

        dividend = zahl;
        char[] array = new char[i]; // Array festlegen
        int s = 0;
        char v;

        while (dividend > 0) { // Dividend und Rest (Binärcode = Rest) berechnen
                                // mittels Modulo Operator

            rest = dividend % basis;
            dividend = dividend / basis;
            array[s] = (char) rest;    // Binärcode ins Array schreiben
            if (basis == 16) {
                if (rest == 10) {
                    v = 65;
                    array[s] = v;
                } else if (rest == 11) {
                    v = 66;
                    array[s] = v;
                } else if (rest == 12) {
                    v = 67;
                    array[s] = v;
                } else if (rest == 13) {
                    v = 68;
                    array[s] = v;
                } else if (rest == 14) {
                    v = 69;
                    array[s] = v;
                } else if (rest == 15) {
                    v = 70;
                    array[s] = v;
                }
            s++;

            }

            for (int a = array.length - 1; a >= 0; a--) { // Binärcode von
                                                            // hinten
                                                            // ausgehend
                                                            // darstellen

                System.out.print((char) (array[a]+48)); // schreibt alles in eine Zeile
            }
        }
    }
}

das ist das Ergebnis

Gib eine Zahl ein: 22
Du hast die Zahl 22 eingegeben.
Gib eine Basis ein: 2
Du hast die Basis 2 eingegeben.
0000000001000010000000001

 

[Tarrew]

Guck mal von wo bis wo deine while-Schleife geht

 

[javastudent25]

cool, danke.
die Binärcodedarstellung zB mit 2 funktioniert jetzt, aber mit 16 bekomme ich folgendes nach der Eingabe.
Wieso v? v hat doch einen Wert...
Ich frage mich langsam, ob das Programmieren mit den Typen so heikel ist oder ich einfach zu blöde bin dafür..

Gib eine Zahl ein: 15
Du hast die Zahl 15 eingegeben.
Gib eine Basis ein: 16
Du hast die Basis 16 eingegeben.
v

import java.io.*;

//Dieses Programm wandelt eine Dezimalzahl je nach Basis in einen Binärcode um, wobei anzumerken ist, dass die Basis 16 hier nicht mehr
//korrekt funktioniert, da die Angaben >10 nicht mit Buchstaben A-F erfolgen

public class dezimalzahl {

    public static void main(String[] args) throws IOException {

        int zahl = 0;

        // ab hier wird eine Zahl eingelesen und ausgegeben
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            System.out.print("Gib eine Zahl ein: ");
            String eingabe = br.readLine();
            zahl = Integer.parseInt(eingabe);
            System.out.println("Du hast die Zahl " + zahl + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        int basis = 0;
        // ab hier wird eine Basis eingelesen und ausgegeben
        try {
            InputStreamReader isr2 = new InputStreamReader(System.in);
            BufferedReader br2 = new BufferedReader(isr2);
            System.out.print("Gib eine Basis ein: ");
            String eingabe2 = br2.readLine();
            basis = Integer.parseInt(eingabe2);
            System.out.println("Du hast die Basis " + basis + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        int dividend = zahl;
        int rest = 0;
        int i = 0;

        while (dividend > 0) { // notwendige Grösse des Arrays berechnen

            dividend = dividend / basis;
            i++;
        }

        dividend = zahl;
        char[] array = new char[i]; // Array festlegen
        int s = 0;
        char v;

        while (dividend > 0) { // Dividend und Rest (Binärcode = Rest) berechnen
                                // mittels Modulo Operator

            rest = dividend % basis;
            dividend = dividend / basis;
            array[s] = (char) rest; // Binärcode ins Array schreiben
            if (basis == 16) {
                if (rest == 10) {
                    v = 65;
                    array[s] = v;
                } else if (rest == 11) {
                    v = 66;
                    array[s] = v;
                } else if (rest == 12) {
                    v = 67;
                    array[s] = v;
                } else if (rest == 13) {
                    v = 68;
                    array[s] = v;
                } else if (rest == 14) {
                    v = 69;
                    array[s] = v;
                } else if (rest == 15) {
                    v = 70;
                    array[s] = v;
                }

            }
            s++;
        }

        for (int a = array.length - 1; a >= 0; a--) { // Binärcode von
                                                        // hinten
                                                        // ausgehend
                                                        // darstellen

            System.out.print((char) (array[a] + 48)); // schreibt alles in eine
                                                        // Zeile
        }
    }
}

 

[Tarrew]

Weil du am Ende wieder 48 draufählst.
70+48=118 und 118 ist der ASCII-Wert für 'v'.

Einfacher wäre es so:

            if (basis == 16) {
                if (rest >= 10) {
                    array[s] = (char) (rest + 7);
                }
            }

 

[javastudent25]

vielen vielen Dank, es hat funktioniert, jetzt habe ich das mit den Typen mal richtig verstanden

Gib eine Zahl ein: 255
Du hast die Zahl 255 eingegeben.
Gib eine Basis ein: 16
Du hast die Basis 16 eingegeben.
Der Code lautet: FF

Hier ist der vollständige Code

import java.io.*;

//Dieses Programm wandelt eine Dezimalzahl je nach Basis in einen Binärcode bzw. Hexadezimalsystem um

public class dezimalzahl {

    public static void main(String[] args) throws IOException {

        int zahl = 0;

        // ab hier wird eine Zahl eingelesen und ausgegeben
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            BufferedReader br = new BufferedReader(isr);
            System.out.print("Gib eine Zahl ein: ");
            String eingabe = br.readLine();
            zahl = Integer.parseInt(eingabe);
            System.out.println("Du hast die Zahl " + zahl + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        int basis = 0;
        // ab hier wird eine Basis eingelesen und ausgegeben
        try {
            InputStreamReader isr2 = new InputStreamReader(System.in);
            BufferedReader br2 = new BufferedReader(isr2);
            System.out.print("Gib eine Basis ein: ");
            String eingabe2 = br2.readLine();
            basis = Integer.parseInt(eingabe2);
            System.out.println("Du hast die Basis " + basis + " eingegeben.");
        } catch (IOException e) {
            e.printStackTrace();
        }

        int dividend = zahl;
        int rest = 0;
        int i = 0;

        while (dividend > 0) { // notwendige Grösse des Arrays berechnen

            dividend = dividend / basis;
            i++;
        }

        dividend = zahl;
        char[] array = new char[i]; // Array festlegen
        int s = 0;
        char v;

        while (dividend > 0) { // Dividend und Rest (Binärcode = Rest) berechnen
                                // mittels Modulo Operator

            rest = dividend % basis;
            dividend = dividend / basis;
            array[s] = (char) rest; // Binärcode ins Array schreiben
            if (basis == 16 && rest >= 10) {
                array[s] = (char) (rest + 7); // rest + 7 deshalb, weil am
                                                // Schluss nach while() 48
                                                // dazugezählt wird und
                                                // 48+rest+7 ergibt genau 65 im
                                                // AsCii Code für A
            }
            s++;
        }

        System.out.print("Der Code lautet: ");

        for (int a = array.length - 1; a >= 0; a--) { // Binärcode von
                                                        // hinten
                                                        // ausgehend
                                                        // darstellen

            System.out.print(((char) (array[a] + 48))); // schreibt alles in
                                                        // eine
                                                        // Zeile
        }
    }
}

 

[Tarrew]

Kein Problem, den if-else Verteiler kannst du dir aber immer noch sparen

 

[javastudent25]

du meinst die else's rauslöschen?

 

[Tarrew]

Guck mal den Code aus meinem Beitrag weiter oben

if(basis == 16 && rest>=10){
    array[s]=(char)(rest +7)
}

Das erspart dir deine ganzen if-else.

 

[javastudent25]

Du bist Schlau wie ein Fuchs. Schon angepasst
Das ist halt das was einen guten Programmierer irgendwo ausmacht.
Ich bin mir auch sicher, dass du oder Andere das Programm auch in wenigen Zeilen schreiben könnten.
Aber vorerst bin ich zufrieden. Es geht ja noch nicht darum, den kürzesten Weg zu nehmen...
noch..

 

[Tarrew]

Danke Danke, aber hier gibt es noch wesentlich bessere Programmierer

Viel Erfolg noch!

 

[Flown]

Also generell würde ich die Konvertierung in eine Methode auslagern. Statt den BufferedInputStream würde ich auch einen Scanner verwenden.
Nachdem das jetzt auch schon fast richtig aussieht zeige ich dir mal ein paar Verbesserungsvorschläge:

import java.util.Scanner;

public class Test {
   
   public static void main(String... args) {
     final Scanner sc = new Scanner(System.in);
     System.out.print("Number to convert: ");
     int n = sc.nextInt();
     System.out.print("Base: ");
     int base = sc.nextInt();
     System.out.println("The number " + n + " to base " + base + ": " + decimalToBase(n, base));
   }
   
   public static String decimalToBase(int n, int base) {
     StringBuilder sb = new StringBuilder();
     do {
       int digit = n % base;
       sb.insert(0, (char) (digit < 10 ? '0' + digit : 'a' + digit - 10));
       n /= base;
     } while (n != 0);
     return sb.toString();
   }
}

 

[javastudent25]

Also generell würde ich die Konvertierung in eine Methode auslagern. Statt den BufferedInputStream würde ich auch einen Scanner verwenden.
Nachdem das jetzt auch schon fast richtig aussieht zeige ich dir mal ein paar Verbesserungsvorschläge:

import java.util.Scanner;

public class Test {
 
   public static void main(String... args) {
     final Scanner sc = new Scanner(System.in);
     System.out.print("Number to convert: ");
     int n = sc.nextInt();
     System.out.print("Base: ");
     int base = sc.nextInt();
     System.out.println("The number " + n + " to base " + base + ": " + decimalToBase(n, base));
   }
 
   public static String decimalToBase(int n, int base) {
     StringBuilder sb = new StringBuilder();
     do {
       int digit = n % base;
       sb.insert(0, (char) (digit < 10 ? '0' + digit : 'a' + digit - 10));
       n /= base;
     } while (n != 0);
     return sb.toString();
   }
}

Hallo
Vielen Dank noch für deine Mühe, aber mir stellen sich nun folgende Fragen:
1. Kannst du mir sagen, warum der Scanner hier besser sein soll?
2. Warum steht vor dem Scanner "final"?

Das war beim InputStreamReader auch so aber
3. Warum schreibt man in die Klammern immer das (System.in) als Parameter?
4. Warum ist deine Methode nun static?
5. Woher weiss ich, in welcher Library welche Klassen stecken und welche in einfügen muss?

Es gibt hier offensichtlich eine Klasse StringBuilder. Du erzeugst dir ein Objekt StringBuilder.
Dann berechnest du digit, aber dieses ändert sich ja nie, weil du n nie überschreibst.
6. Was du in den 2 Zeilen dann vor dem while machst, weiss ich leider überhaupt nicht..

Ich wäre dir dankbar, wenn du mich aufklären könntest.

 

[Flown]

1. Scanner beinhaltet genau die Funktionalität die du benötigst (exemplarisch: Integer.parseInt(BufferedReader.readLine()) <=> Scanner.nextInt())
2. Du verwendest bei deinem Code zwei BufferedReader auf den selben InputStream. Das ist unnötig du könntest einen verwenden. final bedeutet, dass die Variable sc nicht mehr verändert werden kann (war ein überbleibsel meines Autoformatting von Eclipse). n und base könnten übrigens auch final sein.

3. Weil es auch noch andere InputStreams gibt (z.B. Files, Internet Daten, etc.). System.in ist die Konstante für den InputHandle für die Konsole.
4. Zu Einem, da die Methode nur von ihren Parameter abhängig und nicht von dem umgebenden Objekt ist, ist sie static. Zum Anderen, da kann ich sieh von der statischen main-Methode aufrufen ohne ein Objekt anlegen zu müssen.
5. Erfahrung/Bücher/Tutorials/Google/... vor allem aber die Java Dokumentation

6. Dies nennt sich ein do-while Schleife und wird hingegen zu einer gewöhnlichen while Schleife mindestens einmal ausgeführt (zum Beispiel die Zahl 0 muss auch "0" zurückliefern).

Noch Fragen?

 

[javastudent25]

Hallo
Sei mir nicht böse, aber ich bin leider was das Programmieren mit Java und sonst auch angeht nicht so tief in der Materie drin und ich möchte hiermit sicher auch nicht sagen, dass deine Erklärungsweisen anzuzweifeln sind. Das Problem liegt sicher bei mir..
Aber Tatsache ist, dass ich nun von all den ganzen Punkten nur die Nummer 5 richtig verstanden habe. Wenn ich alles andere so lese verstehe ich ehrlich gesagt nur Bahnhof.

 

[javastudent25]

1. Scanner beinhaltet genau die Funktionalität die du benötigst (exemplarisch: Integer.parseInt(BufferedReader.readLine()) <=> Scanner.nextInt())
2. Du verwendest bei deinem Code zwei BufferedReader auf den selben InputStream. Das ist unnötig du könntest einen verwenden. final bedeutet, dass die Variable sc nicht mehr verändert werden kann (war ein überbleibsel meines Autoformatting von Eclipse). n und base könnten übrigens auch final sein.

3. Weil es auch noch andere InputStreams gibt (z.B. Files, Internet Daten, etc.). System.in ist die Konstante für den InputHandle für die Konsole.
4. Zu Einem, da die Methode nur von ihren Parameter abhängig und nicht von dem umgebenden Objekt ist, ist sie static. Zum Anderen, da kann ich sieh von der statischen main-Methode aufrufen ohne ein Objekt anlegen zu müssen.
5. Erfahrung/Bücher/Tutorials/Google/... vor allem aber die Java Dokumentation

6. Dies nennt sich ein do-while Schleife und wird hingegen zu einer gewöhnlichen while Schleife mindestens einmal ausgeführt (zum Beispiel die Zahl 0 muss auch "0" zurückliefern).

Noch Fragen?

Hallo Flown
Ich habe mich so nach deinem Beitrag nun im Internet etwas angelesen.
Die meisten meiner Fragen kann ich denke ich mit deinem Beitrag auch nun mir selbst beantworten.
Bitte korrigiere mich, wenn ich falsch liege.

Zu Punkt
1.) weiss ich jetzt was du meinst. Dazu hab ich vor einen neuen Thread zu machen und dort die Frage nochmals zu stellen.
2.) final verwende ich also, wie du auch angedeutet hast, für Variablen, die nur einmal deklariert werden und sich nie wieder ändern. Das kann entweder manuell oder durch Parameter geschehen.
3.) System.in dient also lediglich dazu, um anzugeben wie der ParameterInput stattfinden soll. In diesem Fall wie auch du es sagst, über die Konsole direkt..
4.) static verwendet man zB für Variablen oder Methoden, die entweder direkt von der Main_Methode aus gesteuert werden sollten, ohne ein Objekt zu erstellen oder einfach Variablen allgemein gültig zu verändern, sprich wenn in einer Superklasse eine Variable static definiert ist und diese verändert wird, so gilt diese für alle folgenden Subklassen, aber auch für jene die bereits erstellt worden waren.
5. hatte ich ja verstanden
6. was diese beiden Zeilen bedeuten, habe ich immer noch nicht herausgefunden
sb.insert(0, (char)(digit <10?'0'+ digit :'a'+ digit -10));
n /= base;

Vielleich kannst du mir da mal erklären, was du genau machst
was bedeutet /=?
was macht die insert Funktion in der Klammer?

und übrigens einen gutes Neues wünsche ich allen Lesenden
hoffe ihr seid gut rüber gekommen

 

[Tarrew]

6.:
Das erste nennt sich ternärer Operator.
Du kannst es auch so schreiben:

        if(digit<10){
            sb.insert(0,  (char)'0'+digit);
        }else{
            sb.insert(0,  (char)'a'+digit-10);
        }

n/=base;

ist die Kurzschreibweise für

n=n/base;

Und danke gleichfalls

 

[javastudent25]

Hallo InfectedByte
Ok, ich verstehe, danke vielmals für deine Hilfe. Aber das wirft gerade einige Fragen auf.
Wenn mein Rest nun angenommen nur gering grösser ist als eine 16Bit Zahl, dann habe ich bereits da schon einen Fehler drin, obwohl ich das so casten und anpassen kann. Mit dem Cast ist also nicht garantiert, dass mein Rest auch wirklich immer in den Char Array passt. Verstehe ich das richtig? Kann ich überhaupt ein Array generieren, das Zeichen enthalten kann und grösser ist als 16Bit? Oder bin ich mit dem Array auf diese Dimension beschränkt?

Hab grad festgestellt, dass diese Frage noch offen ist.
Hat vllt. jemand Lust das noch zu erläutern?

 

[InfectedBytes]

rest hast du wie folgt definiert:
rest = divident % basis
Deine divident ist eine positive ganze zahl und durch die modulo operation kann der rest nur zwischen 0 und basis-1 liegen.
Wenn deine Basis z.B. 10 ist, dann ist der rest immer zwischen 0 und 9

Solange deine Basis also nicht größer als 65535 ist, ist also alles gut^^

 

[javastudent25]

Hi
vielen Dank, aber meine Frage war eher allgemein gestellt bei casten.
aber deinen beitrag richtig interpretiert heisst das also, wenn ich einen Long zB in einen int caste, dann muss ich das Programm gut kennen, über alle Fälle Bescheid wissen und garantieren, dass also die gecastete Zahl immer kleiner ist als der Typ insgesamt Grösse zur Verfügung bereit stellt.

 

[kneitzel]

Das ist nur bedingt richtig. Aber Du musst genau verstehen, was Du machst und dass eben keine Informationen verloren gehen, die wichtig gewesen wären.

Beispiel: War erst gestern in einem anderen Thread: Umwandlung eines Integers in ein Byte-Array. Eine Möglichkeit dazu war, den Integer Wert (der aus 4 Bytes besteht) mehrfach in ein byte zu casten (wobei auch 3 mal die Bits verschoben waren) - und bei diesen Casts als auch bei den Bit-Verschiebungen gingen Daten verloren. Aber dies war so gewollt und durch den Code wurde sicher gestellt, das eben keine Daten verloren gegangen sind.

Konrad

 

[javastudent25]

danke euch beiden.

Konrad, kannst du mir das mit dem 4 Byte Integer mehrfach in 1 byte casten nochmals irgendwie anders erklären?

ich habe also eine

1111 1111 1111 1111 1111 1111 1111 1111

Zahl und diese wird mehrmach in ein Byte

1111 1111

gecastet.
Also darf jene Zahl, die gerade gecastet wird nicht > 255 sein oder eben 122? oder wie ist das genau.
ich bräuchte vllt. ein konkretes Beispiel..

 

[kneitzel]

Also ein int hat eine Größe von 4 Byte. Hexadezimal wäre ein int z.B. 0x04030201.

Ein byte hat nur die Größe von einem Byte - wie sollte es auch sonst sein

Wenn ich nun einen int wert in ein byte caste, werden alle Bytes bis auf das erste "weggeschmissen".

Also (byte)0x04030201 ist 0x01 - die anderen 3 Bytes (0x04, 0x03 und 0x02) gehen verloren.

Nun kann ich aber auch eine Bitweise Verschiebung durchführen über den >> bzw >>> Operator (Je nachdem, ob das Vorzeichen beachtet werden soll. Da wir die Bytes komplett verschieben wollen ohne auf ein Vorzeichen zu achten, nehmen wir >>>).

0x04030201 >>> 8 besagt, dass 8 Bits nach rechts verschoben werden sollen. Ein Byte hat 8 Bit, daher passt das ganz gut.

0x04030201 >>> 8 = 0x00040302
Wenn ich nun wieder zu byte caste, bekomme ich 0x02.

0x04030201 >>> 16 = 0x00000403 - cast zu byte: 0x03
0x04030201 >>> 24 = 0x00000004 - cast zu byte: 0x04

Somit kann man an alle 4 bytes eines Integers heran kommen. Und so könnte man z.B. aus einem Integer ein byte[] machen. Man hat aber dann 3 casts bei denen Daten verloren gehen und 3 Operationen, bei denen ebenfalls Daten verloren gehen.

Das ist das, was ich meinte.

 

[javastudent25]

Hoi Konrad

Ausgezeichnet, das hab ich jetzt verstanden
vielen Dank