‘壹’ java中如何生成二进制文件比如我需要写入0x123456 但是如果使用bufferedwriter的write() 只能写入int...
java里对文件流分为字节流和字符流。
1，FileOutputStream：按字节写入文件
2.1，导入包
import java.io.*;
2.2，声明一个OutputStream引用
OutputStream out =null;
2.3，构造一个OutputStream对象，并在其中写入内容
try {
out = new FileOutputStream("b.txt");
String str ="java终于完了";
byte[] b = str.getBytes();
try {
out.write(b, 0, b.length);
}
catch (IOException ex1) {
ex1.printStackTrace();
}
2.4，关闭对象
finally{
try {
out.close();
}
catch (IOException ex2) {
ex2.printStackTrace();
}
}
望采纳！
‘贰’ 怎样用Java读写二进制文件
import java.util.*;
import java.io.*;
class SmallFile {
static final int HEADLEN = 24; //头总长度
byte[] fileName = new byte[16]; //列表文件名1: 长度128 想把它读到char[]里 它的编码方式不是Unicode。在不确定编码方式的时候，最好直接用byte[]来存放
int offset; //列表文件地址1: 长度32 想把它读到int里
int length = -1; //列表文件长度1: 长度32 想把它读到int里
byte[] content;
public SmallFile() {
}
public SmallFile(byte[] fn, byte[] content) {
Arrays.fill(fileName, (byte) 0);
if (fn != null) {
if (fn.length <= 16) {
System.array(fn, 0, fileName, 0, fn.length);
}
else {
System.array(fn, 0, fileName, 0, 16);
}
}
this.content = content;
if (content != null) {
this.length = content.length;
}
else {
this.length = -1;
}
}
}
public class ReadBinary {
static final int HEADLEN = 8; //头总长度
private String filename;
private byte[] filehead = new byte[4]; //文件头: 长度32 想把它读到char[]里 它的编码方式不是Unicode
private int filecount = -1; //列表长度: 长度32 想把它读到int里 假设他是3 就会有3个列表文件名
private List<SmallFile> files = null;
public void setFilehead(byte[] fh) {
if (fh == null)
return;
Arrays.fill(filehead, (byte) 0);
if (fh.length <= 4) {
System.array(fh, 0, filehead, 0, fh.length);
}
else {
System.array(fh, 0, filehead, 0, 4);
}
}
public ReadBinary(String filename) {
try {
readFromFile(filename);
}
catch (Exception ex) {
System.out.println(ex.getMessage());
System.out.println("在载入数据文件时失败，因此视同为新建一个数据文件！");
this.filename = filename;
Arrays.fill(filehead, (byte) 0);
filecount = 0;
files = new ArrayList<SmallFile> ();
}
}
public void readFromFile(String filename) throws Exception {
BufferedInputStream bin = new BufferedInputStream(new FileInputStream(
filename));
this.filename = filename;
DataInputStream in = new DataInputStream(bin);
in.read(filehead); //文件头: 长度32 想把它读到char[]里 它的编码方式不是Unicode
filecount = in.readInt(); //列表长度: 长度32 想把它读到int里 假设他是3 就会有3个列表文件名
if (files == null) {
files = new ArrayList<SmallFile> ();
}
else {
files.clear();
}
for (int i = 0; i < filecount; i++) {
SmallFile file = new SmallFile();
in.read(file.fileName);
file.offset = in.readInt(); //列表文件地址1: 长度32 想把它读到int里
file.length = in.readInt(); //列表文件长度1: 长度32 想把它读到int里
files.add(file);
}
}
public void writeToFile() throws Exception {
String temp = filename + ".tmp"; //临时文件
boolean exists = false;
RandomAccessFile raf = null;
try {
raf = new RandomAccessFile(filename, "r"); //文件存在则从文件读入
exists = true;
}
catch (Exception ex) {
System.out.println("文件不存在，因此启用内存写入模式");
}
if (filecount != files.size()) {
throw new Exception("怪事，居然不相同？？");
}
DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new
FileOutputStream(temp)));
//1、写总文件头
out.write(filehead);
out.writeInt(filecount);
//2、写列表头
int sumlength = 0;
for (int i = 0; i < files.size(); i++) {
SmallFile file = files.get(i);
out.write(file.fileName);
if (file.length < 0) {
throw new Exception("怪事，文件长度怎么可能小于0？");
}
else {
out.writeInt(ReadBinary.HEADLEN + SmallFile.HEADLEN * filecount +
sumlength);
sumlength += file.length;
out.writeInt(file.length);
}
}
//3、写文件内容
for (int i = 0; i < files.size(); i++) {
SmallFile file = files.get(i);
if (file.content != null && (file.length == file.content.length)) {
out.write(file.content);
}
else if (exists) {
raf.seek(file.offset);
byte[] b = new byte[file.length];
raf.read(b);
System.out.println("b:" + new String(b));
out.write(b);
}
else {
throw new Exception("怪事，又不能从内存读，又不能从文件读。这活没法干了!");
}
}
out.close();
if (raf != null) {
raf.close();
raf = null;
}
System.gc();
//把原先的文件删除
File f = new File(filename);
f.delete();
//再把临时文件改名到正式文件
File f2 = new File(temp);
f2.renameTo(f);
}
public void addFile(SmallFile file) {
if (files != null) {
filecount++;
files.add(file);
}
}
public static void test1(){
ReadBinary rb = new ReadBinary("f:\\temp\\rb.dat");
rb.setFilehead("".getBytes());
SmallFile f = new SmallFile("第1个文件".getBytes(), "第1个文件的内容".getBytes());
rb.addFile(f);
try {
rb.writeToFile();
}
catch (Exception ex) {
ex.printStackTrace();
}
}
public static void test2(){
ReadBinary rb = new ReadBinary("f:\\temp\\rb.dat");
rb.setFilehead("HEA".getBytes());
SmallFile f = new SmallFile("第2个文件".getBytes(), "第2个文件的内容".getBytes());
rb.addFile(f);
try {
rb.writeToFile();
}
catch (Exception ex) {
ex.printStackTrace();
}
}
public static void main(String[] args) {
//test1();
test2();
}
}
‘叁’ java 写入二进制文件问题
据我所知java的api里没有更改局部信息的输出流，必须读到内存重新写到文件里，可以选择覆盖或追加，输出流可以到jdk文档里参考OutputStream类。
‘肆’ 紧急求助！！！JAVA语言下如何将二进制数字写入文件然后读出来
/** * 二进制读写文件 */ import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.FileInputStream; import java.io.FileOutputStream; public class MainClass { /** * java.io包中的OutputStream及其子类专门用于写二进制数据。 * FileOutputStream是其子类，可用于将二进制数据写入文件。 * DataOutputStream是OutputStream的另一个子类，它可以 * 连接到一个FileOutputStream上，便于写各种基本数据类型的数据。 */ public void writeMethod1() { String fileName="c:/kuka1.dat"; int value0=255; int value1=0; int value2=-1; try { //将DataOutputStream与FileOutputStream连接可输出不同类型的数据 //FileOutputStream类的构造函数负责打开文件kuka.dat，如果文件不存在， //则创建一个新的文件，如果文件已存在则用新创建的文件代替。然后FileOutputStream //类的对象与一个DataOutputStream对象连接，DataOutputStream类具有写 //各种数据类型的方法。 DataOutputStream out=new DataOutputStream(new FileOutputStream(fileName)); out.writeInt(value0); out.writeInt(value1); out.writeInt(value2); out.close(); } catch (Exception e) { e.printStackTrace(); } } //对于大量数据的写入，使用缓冲流BufferedOutputStream类可以提高效率 public void writeMethod2() { String fileName="c:/kuka2.txt"; try { DataOutputStream out=new DataOutputStream( new BufferedOutputStream( new FileOutputStream(fileName))); out.writeInt(10); System.out.println(out.size()+" bytes have been written."); out.writeDouble(31.2); System.out.println(out.size()+" bytes have been written."); out.writeBytes("JAVA"); System.out.println(out.size()+" bytes have been written."); out.close(); } catch (Exception e) { e.printStackTrace(); } } /** * 对二进制文件比较常见的类有FileInputStream，DataInputStream * BufferedInputStream等。类似于DataOutputStream，DataInputStream * 也提供了很多方法用于读入布尔型、字节、字符、整形、长整形、短整形、 * 单精度、双精度等数据。 */ public void readMethod1() { String fileName="c:/kuka1.dat"; int sum=0; try { DataInputStream in=new DataInputStream( new BufferedInputStream( new FileInputStream(fileName))); sum+=in.readInt(); sum+=in.readInt(); sum+=in.readInt(); System.out.println("The sum is:"+sum); in.close(); } catch (Exception e) { e.printStackTrace(); } } public void readMethod2() { try { FileInputStream stream=new FileInputStream("c:/kuka.dat"); int c; while((c=stream.read())!=-1) { System.out.println(c); } } catch (Exception e) { e.printStackTrace(); } } }
晕噢，格式全乱了~~
‘伍’ java写二进制文件，不能直接编辑，该怎么操作
一直以来都在用java编程，以前在Java写一些二进制格式的文件，就用DataOutputStream很方法，例如它的writeInt，writeLong等，我今天在看一些代码的时候发现DataOutputStream在处理多字节的数字的时候，使用的是BIG_ENDIAN(即将高位的字节放在内存地址的低地址上)，相应的DataInputStream的读取方式也使用的是BIG_ENDIAN。
这样就引出一个问题，如果我是用Java之外的语言，比如C语言读取由DataOutputStream生成的文件，而平台正好是LITTLE_ENDIAN(用得很广泛的x86的系统都是LITTLE＿ENDIAN)，很可能会造成数据错误，除非在C程序中自己重新按照BIG＿ENDIAN的格式组装int或者long.
这样我们需要在写文件的时候就按照平台的字节顺来写，而ByteBuffer已经考虑到了这一点。
java.nio.ByteBuffer默认是BIG＿ENDIAN(这可能和ByteBuffer主要用来做网络通讯有关)，但是这个值是可以修改的。
比较使用DataOutputStream和ByteBuffer写文件的差异:
public static void main(String[] args) throws IOException {
int _int = 12345678;
ByteBuffer _nbuffer = ByteBuffer.allocate(4);
_nbuffer.order(ByteOrder.nativeOrder()); //将新建的ByteBuffer设置为本机的字节顺
_nbuffer.putInt(_int);
_nbuffer.flip();
FileOutputStream _fou = new FileOutputStream("test_dout.data");
FileOutputStream _nfou = new FileOutputStream("test_nbuf.data");
DataOutputStream _dou = new DataOutputStream(_fou);
_dou.writeInt(_int);
_dou.close();
_nfou.write(_nbuffer.array());
_nfou.close();
System.out.println(ByteOrder.nativeOrder());
}
执行上面的代码生成两个文件：
test_dout.data － 使用DataOutputStream生成的BIG_ENDIAN文件，
test_nbuf.data － 使用ByteBuffer生成的主机字节顺的文件（此处的主机字节顺为LITTLE_ENDIAN）
使用下面的C程序分别读取这两个文件:
#include <stdio.h>
int read_file(char* file);
main()
{
char* dout = "test_dout.data";
char* nbuf = "test_nbuf.data";
printf("data in %s:%d\n",dout,read_file(dout));
printf("data in %s:%d\n",nbuf,read_file(nbuf));
}
int read_file(char* file)
{
FILE *fp;
int dat[1];
fp=fopen(file, "rb");/*打开一个二进制文件只读*/
fread(dat, sizeof(int), 1, fp);
fclose(fp);
return dat[0];
}
编译并执行:
gcc a.c
./a.out
data in test_dout.data:1315027968
data in test_nbuf.data:12345678
上面的C程序从test_dout.data取得的int数值是错误的，而从test_nbuf.data是正确的。
ByteBuffer不方便的地方在于它的大小不能自动扩展，但是也是可以解决的，比如MINA自己的ByteBuffer就支持自成扩展。
Java的生成二进制数据文件，应该要考虑一下字节顺的问题，以适应一些特殊的需求，比如多语言平台编程的情况。
‘陆’ java以二进制传输字符集填啥
用UTF-8.
java读写文件的有很多种方式，基本都是采用java.io的inputStream和各种基于inputstream的封装实现对文件的读写，最原始的接口提供的便是基于byte的读写，而String可以看做是char[]，一个char是8个byte。在最原始的ASCII编码中，我们采用一个字节 也就时8位来表示一个字符（图形字符或者控制字符），而后来1个字节不足以表示现实中的所有字符，于是出现了各种各样的编码格式，常见的比如UTF-8，GBK，UNICODE等。java中的string也是遵循jre中定义的默认字符集(基本为UTF-8），而在byte[]转化成String的过程中可能会由于编码字符集问题导致String逆向回来的byte[]与原来的数组不一致。
‘柒’ Java怎么解析用C写入的.bin类型二进制文件
Java怎么解析用C写入的.bin类型二进制文件
\\假设文件的地址为a.txt
FileInputStream in=new FileInputStream(new File("a.txt"));
byte[] buffer=new byte[4096];
int offset=0;
while((offset=in.read(buffer)>-1){
//这已经把文件读入到buffer中了，范围为0到offset，你可以做任何处理了
}
in.close();
‘捌’ 如何用Java向文件中写入二进制代码
FileOutputStream，这个类似乎是用来输出图像文件格式的，应该也可以操作二进制文件……
‘玖’ java把01字符串当二进制写入文件
outputstream的write方法要求传入的时byte[]数组，如果你的01字串是String类型的的话，需要将其转换成byte[],具体办法可以看下面的例子：
publicstaticvoidmain(String[]args)
{
System.out.println("HelloWorld!");
Stringtext="10101010010001100111001";
Filef=newFile("/Users/hujia/Documents/test.txt");
OutputStreamos=null;
try{
os=newFileOutputStream(f);
os.write(text.getBytes());
}catch(FileNotFoundExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}finally{
try{
os.close();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}
}