Array liste Verdrehen

Hi,
ich bin neu in Java ich hab soviel Ahnung davon wie mein Ungeborener Sohn :D.
Nunja aber ich mach gerade eine Ausbildung und versuche gern alles selber aber ich komm gerade nicht weiter. Ich hab noch nie vorher Programmiert oder so.
Und ich hab ein File was auf einem Externen Server liegt. Meine Aufgabe war es jetzt nach einem Monat Java "Hello World" zeugs, dieses File auszulesen und ein Programm zu schreiben welches die Werte richtig ausgibt.
Alle Bytes in diesem File sind Unsigned (mit wenigen Ausnahmen), ich habe also bei Google eine Bibliotek gefunden die das macht, weil in Java Sigend und unsigned ist so eine Sache habe ich gemerkt.
Mein Problem;
Ich will die MAC-Adresse ausgeben, was ich auch geschafft habe, allerdings soll diese Verdreht sein. hat jemand einje Idee wie man das machen kann?
Weil ich bin eher aufgeschmissen: ( MAC-Adresse ist geändert wegen Firma unso)

----------------------------------------------------------------------------------------------

//datalog
public class DataLog {
public List<Integer> macAddress;
}

//jabDataStream
public DataLog testDataStream(byte[] bytes) throws IOException {
InputStream inputStream = new ByteArrayInputStream(bytes);
LittleEndianDataInputStream dataInputStream = new LittleEndianDataInputStream(inputStream);
DataLog resultObject = new DataLog();

List<Integer> macList = new ArrayList<>();
for (int i = 0; i < 6; i++) {
macList.add(dataInputStream.readUnsignedByte());
}
resultObject.macAddress = macList;


return resultObject;
}

//output
public void showDataLog(DataLog dataLog) {
package tools;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

import static java.lang.System.out;


out.println("MAC - address................................: " + dataLog.macAddress.stream().map(v->convertToShortHex(v)).collect(Collectors.joining(":")));

Output: AD:17:00:8G:7D:37
-> soll zu Output: 17:AD:8G:00:37:7D
}

----------------------------------------------------------------------------------------------

So ich hab eine DataLog Klasse, eine Output Klasse und eine JobDataStream Klasse. Ich hoffe das ist nicht zu unübersichtlich, SORRY.


Vielen vielen Dank schonmal wenn jemand eine idee hat weil ich sitze hier und bräuchte schon neue Fingernägel ich hab alle gegessen .-.
Schönen tag noch an jeden der das ließt und seit nicht allzu böse mit mir ich brauch manchmal n bisschen. .)

PS: Sollten mehr Infos benötigt werden schreibt das einfach :D
 
Zuletzt bearbeitet:
Hallo,

es kann sein, dass es eine stringente Lösung (Stream, Bibliotheksfunktion,...) statt dem "zu-Fuss-Vorschlag" gibt:
Output: AD:17:00:8G:7D:37
-> soll zu Output: 17:AD:8G:00:37:7D
Man interpretiert den Output als Array mit 6 Elementen und jedem zweiten ' : ' als Trennzeichen, teilt diesen in je 3 Arrays a 2 Elemente auf, revertiert diese Arrays jeweils und lässt das Ergebnis hintereinander ausgeben. Siehe https://www.geeksforgeeks.org/program-for-array-rotation-continued-reversal-algorithm/ A wäre [AD,17], B [00,8G] C [7D,37]
 
Hallo,

es kann sein, dass es eine stringente Lösung (Stream, Bibliotheksfunktion,...) statt dem "zu-Fuss-Vorschlag" gibt:

Man interpretiert den Output als Array mit 6 Elementen und jedem zweiten ' : ' als Trennzeichen, teilt diesen in je 3 Arrays a 2 Elemente auf, revertiert diese Arrays jeweils und lässt das Ergebnis hintereinander ausgeben. Siehe https://www.geeksforgeeks.org/program-for-array-rotation-continued-reversal-algorithm/ A wäre [AD,17], B [00,8G] C [7D,37]
Hi,
Also ich verstehe was du meinst, jedoch habe ich ja nicht diese Werte, denn bei mir kann die MAC je nach Versionsnummer entweder hintzen oder Vorne stehen, das heißt ich brauche etwas was sie automatisch umstellt (wenn es sowas überhaupt gibt?).
Also mit

private DataLog getMacAddress(byte[] bytes, DataLog dataLog) {
Code:
//        byte[] mac;

//        mac = new byte[6];

//

//        mac[1] = bytes[position++];

//        mac[0] = bytes[position++];

//        mac[3] = bytes[position++];

//        mac[2] = bytes[position++];

//        mac[5] = bytes[position++];

//        mac[4] = bytes[position++];

//

//        dataLog.macAddress = new ArrayList<>();

//        for (int i = 0; i < mac.length; i++) {

//            dataLog.macAddress.add(mac & 0xFF);

//        }

//

//        return dataLog;
komm ich leider nicht weit...
aber dankö
vlt weißt du ja ws anderes, oder ich habs falsch verstanden, wenn ja bitte genauer erklären ich bin manchmal ein kleiner dussel:p
 
Meine Aufgabe war es jetzt nach einem Monat Java "Hello World" zeugs
LOL.

Alle Bytes in diesem File sind Unsigned (mit wenigen Ausnahmen), ich habe also bei Google eine Bibliotek gefunden die das macht, weil in Java Sigend und unsigned ist so eine Sache habe ich gemerkt.
Wenn Du ein byte (Datentyp!) b als vorzeichenlose Zahl darstellen willst, musst Du es lediglich per b & 0xff in ein int umwandeln.

Zum Problem selbst: das verstehe ich ehrlich gesagt nicht. Du bekommst ein Array mit 6 bytes. Dieses Array kannst Du doch ausgeben, wie Du willst. Von vorne nach hinten:
Java:
StringJoiner j = new StringJoiner(":");
for (int i = 0; i < bytes.length; i++) {
    j.add(String.format("%02x", bytes[i] & 0xff));
}
return j.toString();
oder von hinten nach vorne:
Java:
StringJoiner j = new StringJoiner(":");
for (int i = bytes.length-1; i >= 0; i--) {
    j.add(String.format("%02x", bytes[i] & 0xff));
}
return j.toString();
 
LOL.


Wenn Du ein byte (Datentyp!) b als vorzeichenlose Zahl darstellen willst, musst Du es lediglich per b & 0xff in ein int umwandeln.

Zum Problem selbst: das verstehe ich ehrlich gesagt nicht. Du bekommst ein Array mit 6 bytes. Dieses Array kannst Du doch ausgeben, wie Du willst. Von vorne nach hinten:
Java:
StringJoiner j = new StringJoiner(":");
for (int i = 0; i < bytes.length; i++) {
    j.add(String.format("%02x", bytes[i] & 0xff));
}
return j.toString();
oder von hinten nach vorne:
Java:
StringJoiner j = new StringJoiner(":");
for (int i = bytes.length-1; i >= 0; i--) {
    j.add(String.format("%02x", bytes[i] & 0xff));
}
return j.toString();
Hi,
danke erstmal dir/euch für deine Zeit :)
Also ich hab früher mit 0xFF gearbeitet, aber meine Ausbilderin meine das ist ihr zu lang, ich hatte iwie 5 zeilen code und jetzt 3... nunja und ich muss ehrlicherweise sagen das ich etwas überfordert bin mit der ganzen Aufgabe (dieses Forum wird mein neues Leben sein hoffe ich xD).
Das problem ist die MAC ist nicht fest, das heißt sie kann mal bei Position 4-10 liegen oder dann bei 20-26.
Und ich gebe die MAC halt als Liste aus, das heißt: 11:22:33:44
ich brauch aber 22:11:44:33
und das würd ich gern rausfinden
davor hab ich mit einem position wert gearbeitet und den imemr weiter erhöht.
also
Code:
 mac[1] = bytes[position++];
//        mac[0] = bytes[position++];
//        mac[3] = bytes[position++];
//        mac[2] = bytes[position++];
//        mac[5] = bytes[position++];
//        mac[4] = bytes[position++];
das hat auch wunderbar funktioniert aber jetzt benutze ich irgendwelche google libarys mit sachen von denen ich noch nie was gehört hab.
Gibt es keine möglichkeit die zu verdrehen?

Zu dir nochmal: ja ich kann sie rüchwerts ausgeben (wenn ich das richtig verstanden hab) oder vorwärts, aber ich möchte jedes byte verdrehen/tauschen.

die libarys:
(import) com.google.common.io.LittleEndianDataInputStream;
(import) com.google.common.primitives.UnsignedInteger;

Edit:
Das größere Problem ist ich hab durch YouTube Tutorials alles gelernt und aufeinmal bekomme ich neue Klassen und Funktionen.
Wenn ich 6 Byte hab dann kann ich die vorwärts und rückwärts ausgeben, ich hab auch schon sachen gesehen da kann man die verschieben, ich möchte sie arber verdrehen und nicht verschieben.
Edit²: ich bastel gerade weiter und versuch iwas was mir in den Sinn kommt aber bringen tut es leider nichts
 
Zuletzt bearbeitet:
Wo ist denn jetzt das Problem, den LittleEndianDataInputStream zu verwenden? Das ist doch im Endeffekt auch nur ein Array, nur halt eines, aus dem du nur sequentiell von vorne nach hinten lesen kannst.
Eine Lösung wäre, diesen Stream einfach genauso zu behandeln wie dein Array, indem du 8 Mal readUnsignedByte() aufrufst.
 
Wo ist denn jetzt das Problem, den LittleEndianDataInputStream zu verwenden? Das ist doch im Endeffekt auch nur ein Array, nur halt eines, aus dem du nur sequentiell von vorne nach hinten lesen kannst.
Eine Lösung wäre, diesen Stream einfach genauso zu behandeln wie dein Array, indem du 8 Mal readUnsignedByte() aufrufst.
Ich probier es mal, aber wieso 8 mal? die Mac ist 6 Byte lang, nur %02X also in Hex.
Aber vielen Dank ich meld mich gleich :D
 
Java:
StringJoiner j = new StringJoiner(":");
for (int i = 0; i < bytes.length; i+=2) {
    j.add(String.format("%02x", bytes[i+1] & 0xff));
    j.add(String.format("%02x", bytes[i] & 0xff));
}
return j.toString();
 
Java:
StringJoiner j = new StringJoiner(":");
for (int i = 0; i < bytes.length; i+=2) {
    j.add(String.format("%02x", bytes[i+1] & 0xff));
    j.add(String.format("%02x", bytes[i] & 0xff));
}
return j.toString();
Hi.
Vielen Dank an alle!

Theoretisch würde es funktionieren, jedoch habe ich im Output schon dataLog.macAddress.stream().map(v->convertToShortHex(v)).collect(Collectors.joining(":")));
doppelt geht dann nicht? (Wenn falsch gerne sagen).
Jetzt funktioniert es ich habe einfach eine neue liste erstellt :D
Code:
List<Integer> macList = new ArrayList<>();
        for (int i = 0; i < 6; i++) {
            macList.add(dataInputStream.readUnsignedByte());
        }
        List<Integer> newMacList = new ArrayList<>();
        newMacList.add(macList.get(1));
        newMacList.add(macList.get(0));
        newMacList.add(macList.get(3));
        newMacList.add(macList.get(2));
        newMacList.add(macList.get(5));
        newMacList.add(macList.get(4));

        resultObject.macAddress = newMacList;
So sieht mein Code nun aus und es funktioniert.
Kann sein das einer von euch genau das von mir wollte wenn ja tut es mir sehr leid...
Trotzdem Vielen Dank nochmal!
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben