字符串转换为二进制？ 爪哇

Question

我必须将String转换为二进制代码。 我的第一个任务是通过用户输入为“ ipv4header”输入一些值。

结果看起来像： 4-5-24-5-0-000-0-32-0-0-195.168.1.102-223.168.1.102这不是问题，现在我必须将此结果转换为二进制。

预期结果应为： 0100 0101 00011000 0000000000000101 0000000000000000 000 000000000000000100000 00000000 0000000000000001 11000011101010000000000011100110 11011111101010000000000110100000

请帮我。

谢谢。

是否可以直接从String转换为Binary？ 当我尝试将字符串转换为int然后转换为二进制时，开头的0会丢失

导入java.util.Scanner; 公共类IPv4Header {

public static void main(String[] args){

    String version;
    String ihl = "5";
    String tos;
    String paketlaenge = "5";
    String kennung;
    String flags;
    String fragmentOffset;
    String ttl;
    String headerChecksum;
    String protokoll;
    String quellIP;
    String zielIP;

    //#######################
    //
    //#######################

    Scanner sc = new Scanner(System.in);

    System.out.println("Bitte Version eingeben");
    version = sc.next();
    int versionInt = Integer.parseInt(version);
    System.out.println("Binärcode von " + version + " = " + Integer.toBinaryString(versionInt));

    System.out.println("Bitte TOS eingeben");
    tos = sc.next();
    int tosInt = Integer.parseInt(tos);
    System.out.println("Binärcode von " + tos + " = " + Integer.toBinaryString(tosInt));

    System.out.println("Bitte Kennung eingeben");
    kennung = sc.next();
    int kennungInt = Integer.parseInt(kennung);
    System.out.println("Binärcode von " + kennung + " = " + Integer.toBinaryString(kennungInt));

    System.out.println("Bitte Flags eingeben");
    flags = sc.next();
    int flagsInt = Integer.parseInt(flags);
    System.out.println("Binärcode von " + flags + " = " + Integer.toBinaryString(flagsInt));

    System.out.println("Bitte Fragment-Offset eingeben");
    fragmentOffset = sc.next();
    int fragmentOffsetInt = Integer.parseInt(fragmentOffset);
    System.out.println("Binärcode von " + fragmentOffset + " = " + Integer.toBinaryString(fragmentOffsetInt));

    System.out.println("Bitte TTL eingeben");
    ttl = sc.next();
    int ttlInt = Integer.parseInt(ttl);
    System.out.println("Binärcode von " + ttl + " = " + Integer.toBinaryString(ttlInt));

    System.out.println("Bitte Protokoll eingeben");
    protokoll = sc.next();
    int protokollInt = Integer.parseInt(protokoll);
    System.out.println("Binärcode von " + protokoll + " = " + Integer.toBinaryString(protokollInt));

    System.out.println("Bitte Header-Checksum eingeben");
    headerChecksum = sc.next();
    int headerChecksumInt = Integer.parseInt(headerChecksum);
    System.out.println("Binärcode von " + headerChecksum + " = " + Integer.toBinaryString(headerChecksumInt));

    System.out.println("Bitte Quell-IP-Adresse angeben");
    quellIP = sc.next();

    System.out.println("Bitte Ziel-IP angeben");
    zielIP = sc.next();

    int ihlInt = Integer.parseInt(ihl);
    int paketlaengeInt = Integer.parseInt(paketlaenge);

    System.out.println("Ausgabe: " + version + "-" + ihl + "-" + tos + "-"
            + paketlaenge + "-" + kennung + "-" + flags + "-" + fragmentOffset + "-" 
            + ttl + "-" + headerChecksum + "-" + protokoll + "-" + quellIP + "-" 
            + zielIP);

    }}

Answer 1

头校验和和“预期结果”之间似乎没有任何冲突，说实话，我认为其中有错字或与头校验和有关的内容都是虚构的。 例如，将IP号转换为8位二进制值，然后附加在一起以形成32位二进制数，但是所谓的“预期结果”中每个二进制数的最后8位与标头中提供的不匹配校验和字符串。 这在事情范围上是次要的，我们稍后再讨论。

由于您尚未提供用于建立“预期结果”的模型（如@nullpointer所建议的那样），因此您需要自己进行此操作。

这是一个小方法，您可以在迭代和拆分Header Checksum字符串以创建二进制字符串时使用。 您可以为二进制数提供任意大小的位数（它所做的只是用零填充左键）：

private static String integerToBinaryString(int number, int bitSize) {
        String binary = (String)Integer.toString(number, 2);
        binary = String.format("%0" + bitSize + "d", Integer.valueOf(binary));
        return binary;
}

要获得整数5的8位二进制数字字符串，您可以执行以下操作：

String binaryString = integerToBinary(5, 8);
System.out.println(binaryString);

现在，我不知道将Header Checksum转换为二进制字符串的转换模型可能是什么，但是我想出了一个快速的方法，它产生了一个我认为是正确的输出，并且我认为它相当糟糕：

public static String translateHeaderChecksum(String headerChecksum) {
    // Declare and initialize required variables
    // Tokenize the contents of the headerChecksum string
    // variable into an Array based on the dashes (-) within
    // the string.
    String[] tokens = headerChecksum.split("-");
    String binaryString = "";
    String binaryValue = ""; 

    // Interate through the tokens[] Array and carry out convertions
    // such as convert number strings to integer and then the integer
    // numbers to the desired binary strings. The switch/case within
    // the 'for loop' handles our tranlation model as to what we're
    // going to do with each each part of the header checksum string.
    // Remember, each of those parts are now contained within the 
    // tokens[] string Array.
    for (int i = 0; i < tokens.length; i++) {
        int hcn = 0;
        // Convert the string number contained within the tokens[] Array
        // to integer so as to prep supply to the integerToBinaryString()
        // method.We only do elements 0 to 9 because elements 10 and 11
        // contain IP addresses and need to be handled separately. See 
        // case 11 & case 12 below).
        if (i >= 0 && i<=9) {
            hcn =  Integer.valueOf(tokens[i]);
        }

        // Handle each header checksum value, convert to binary
        // and ensure proper bit count.
        switch (i+1) {
            case 1: case 2: 
                binaryValue = integerToBinaryString(hcn,4);
                break;
            case 3:
                binaryValue = integerToBinaryString(hcn,8);
                break;
            case 4: case 5:
                binaryValue = integerToBinaryString(hcn,16);
                break;
            case 6:
                binaryValue = String.format("%0" + 3 + "d", hcn);
                break;
            case 7: 
                binaryValue = integerToBinaryString(hcn,15);
                break;
            case 8:
                binaryValue = binaryValue + integerToBinaryString(hcn,4);
                break;
            case 9: 
                binaryValue = integerToBinaryString(hcn,8);
                break;
            case 10:
                binaryValue = integerToBinaryString(hcn,16);
                break;
            case 11: case 12:
                // Handle the two IP addresses located at the end of
                // Header Checksum string. Place each number of the IP 
                // into a string Array variable named ipTokens[] but 
                // first we need to get rid of the periods since split()
                // doesn't play well with them, We'll change them with
                // commas (,).
                tokens[i] = tokens[i].replace('.',',');
                String[] ipTok = tokens[i].split(",");
                // Iterate through each number of the IP address we're
                // currently working on and convert it to a binary string.
                for (int j = 0; j < ipTok.length; j++) {
                    // Since the our final two binary number strings are 
                    // in fact each IP address number converted to a 8-bit
                    // binary number and all pushed together (appeneded) to
                    // one another to form a 32-bit binary number, we do that
                    // here.
                    binaryValue = binaryValue + integerToBinaryString(Integer.valueOf(ipTok[j]),8);
                }
                break;
        }

        // Here we compile our final binary string. For every
        // interation we append our determined binary number
        // strings to it.
        // We skip the application of case 7 to our final binary
        // string because case 8 is appended to it (see case 8).
        if ((i + 1) != 7) {
            binaryString+= " " + binaryValue;
            binaryValue = "";
        }
    }
    // Trim off any leading or trailing spaces we had 
    // applied to the final binary string.
    binaryString = binaryString.trim();

    // Return our final binary string.
    return binaryString;
}

这是一个简单的示例，您可以使用translateHeaderChecksum（）方法：

String headerChecksum = "4-5-24-5-0-000-0-32-0-0-195.168.1.102-223.168.1.102";
System.out.println(translateHeaderChecksum(headerChecksum));

这是您提供的标头校验和字符串：

4-5-24-5-0-000-0-32-0-0-195.168.1.102-223.168.1.102

这是您提供的“预期结果”，我认为这是有缺陷的，稍后我将告诉您原因：

0100 0101 00011000 0000000000000101 0000000000000000 000 000000000000000100000 00000000 0000000000000001 11000011101010000000000011100110 11011111101010000000000110100000

现在，如果您使用提供的Header Checksum字符串并通过我刚刚提供的translateHeaderChecksum（）方法运行它，您将得到：

0100 0101 00011000 0000000000000101 0000000000000000 000 000000000000000100000 00000000 0000000000000000 11000011101010000000000000000101100110 11011111101010000000000101100110

您会发现最后三个二进制数字之间存在差异。 让我们从末尾的16位二进制数0000000000000001的第3个开始。这是一个错字吗，因为就我的一生而言，我不知道如何从Header Checksum字符串中提供的零中得到1。

后两个32位二进制数是从位于标头校验和字符串末尾的IP地址派生而来的，这两个数字中的仅后8位与标头校验和字符串中提供的内容不匹配，“预期结果”有缺陷。

让我们首先从最后一个32位二进制数中取出第二个。 “预期结果”中的最后8位为01100110，转换为十进制为230，而不是IP 195.168.1.102的标头校验和字符串中指定的102。 但是， translateHeaderChecksum（）方法的输出确实产生了01100110的正确8位。

现在，让我们获取最后的32位二进制数。 “预期结果”中的最后8位为10100000，转换为十进制为160，而不是IP 223.168.1.102的标头校验和字符串中指定的102。 但是， translateHeaderChecksum（）方法的输出确实产生了01100110的正确8位。

如果有可以比较的东西，那么如果它至少有些准确的话，那肯定会很好。

无论如何，玉...我希望这可以对您有所帮助。