JAVA在文件中从字符串转换为二进制，然后再转换回字符串

我想从文件中读取文本，该文件是

“Hello”

，然后我想将该文本转换为相应的二进制格式，如：

01001000 011001001 011001100 01101100100 011011011111

现在，在二进制转换之后，我想再次转换相同的

01001000 011001001 011001100 01101100100 011011011111

到

Hello

并将其写入文件

对于像“Hello World我的名字是XYZ”这样的多个单词，如何做到同样的效果呢

---

我怎么可能做到呢？请帮助

我没有详细介绍如何读/写文件，因为你可以查一下。但是，要实现您的目标：

• 您将需要一个方法将一个字转换为二进制
• 然后，您将需要另一种方法将二进制转换为单词

代码如下：

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class HelloWorld{

 public static void main(String []args) throws FileNotFoundException {
   File file = new File("input.txt");
   Scanner sc = new Scanner(file);
   String word=sc.nextLine();
   String receivedBinary=stringToBinary(word);
   System.out.println();
   String receivedWord=BinaryToString(receivedBinary);
 }
 public static String stringToBinary(String text)
 {
     String bString="";
     String temp="";
     for(int i=0;i<text.length();i++)
     {
         temp=Integer.toBinaryString(text.charAt(i));
         for(int j=temp.length();j<8;j++)
         {
             temp="0"+temp;
         }
         bString+=temp+" ";
     }

     System.out.println(bString);
     return bString;
 }
 public static String BinaryToString(String binaryCode)
 {
     String[] code = binaryCode.split(" ");
     String word="";
     for(int i=0;i<code.length;i++)
     {
         word+= (char)Integer.parseInt(code[i],2);
     }
     System.out.println(word);
     return word;
 }
}

导入java.io.File；
导入java.io.FileNotFoundException；
导入java.util.Scanner；
公共类HelloWorld{
公共静态void main（字符串[]args）引发FileNotFoundException{
File File=新文件（“input.txt”）；
扫描仪sc=新扫描仪（文件）；
字符串字=sc.nextLine（）；
字符串receivedBinary=stringToBinary（word）；
System.out.println（）；
字符串receivedWord=BinaryToString（receivedBinary）；
}
公共静态字符串stringToBinary（字符串文本）
{
字符串bString=“”；
字符串temp=“”；
对于（int i=0；iOK，因为我喜欢迷惑，因为Java语言可以对这种低级数组操作提供更多支持。我创造了术语bitgets来表示0和1的字符表示，以及一个方法
toBitgets
来打印字节的所有8位

这个类还使用一些正则表达式fu来确保解析的字符串具有所请求的精确表示：8位后跟空格或输入的结尾

import static java.nio.charset.StandardCharsets.US_ASCII;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class S2B2S {

    public S2B2S() {

    }

    public void toBitgets(StringBuilder sb, byte b) {
        for (int i = 0; i < Byte.SIZE; i++) {
            sb.append('0' + ((b >> (Byte.SIZE - i - 1))) & 1);
        }
    }

    public String encode(String s) {
        byte[] sdata = s.getBytes(US_ASCII);
        StringBuilder sb = new StringBuilder(sdata.length * (Byte.SIZE + 1));
        for (int i = 0; i < sdata.length; i++) {
            if (i != 0) {
                sb.append(' ');
            }
            byte b = sdata[i];
            toBitgets(sb, b);
        }
        return sb.toString();
    }

    public String decode(String bs) {
        byte[] sdata = new byte[(bs.length() + 1) / (Byte.SIZE + 1)];
        Pattern bytegets = Pattern.compile("([01]{8})(?: |$)");
        Matcher bytegetsFinder = bytegets.matcher(bs);
        int offset = 0, i = 0;
        while (bytegetsFinder.find()) {
            if (bytegetsFinder.start() != offset) {
                throw new IllegalArgumentException();
            }
            sdata[i++] = (byte) Integer.parseInt(bytegetsFinder.group(1), 2);

            offset = bytegetsFinder.end();
        }
        if (offset != bs.length()) {
            throw new IllegalArgumentException();
        }
        return new String(sdata, US_ASCII);
    }

    public static void main(String[] args) {
        String hello = "Hello";
        S2B2S s2b2s = new S2B2S();
        String encoded = s2b2s.encode(hello);
        System.out.println(encoded);
        String decoded = s2b2s.decode(encoded);
        System.out.println(decoded);
    }
}

导入静态java.nio.charset.StandardCharsets.US\u ASCII；
导入java.util.regex.Matcher；
导入java.util.regex.Pattern；
公共类S2B2S{
公共S2B2S（）{
}
公共无效toBitgets（StringBuilder sb，字节b）{
for（int i=0；i（Byte.SIZE-i-1））&1）；
}
}
公共字符串编码（字符串s）{
字节[]sdata=s.getBytes（US_ASCII）；
StringBuilder sb=新的StringBuilder（sdata.length*（Byte.SIZE+1））；
对于（int i=0；i
看看Integer.toString（…）、Integer.parseInt（…）、String.getBytes（…）和字符串（byte[]，…）方法和构造函数。@GregS
BitSet
如果需要直接编程位访问，也可以部署在String.getBytes的结果上。该类必须有一些用例？学习如何除以2…并学习如何逐字节读写文件。
Integer.tobinarysting
并不总是打印一个字节的所有位，也许你应该将其作为子例程。
word+=（char）Integer.parseInt（code[i]，2）；
感觉不正确。是的，我没有注意到，只是添加了一些填充，所以它总是显示8个字符。只需要一次调试运行，我在这方面做得很好：）