java写入内存_JAVA 将相应值所占内存写入到文件中

将数据以二进制方式写到文件中遇到一个坑

int 类型的值java本来占4个字节，写到文件中本以为是 00000000 00000000 00000000 00000000,可写进去发现只有一个字节00000000.

@Test

public void writeInt() throws IOException {

FileOutputStream fileOutputStream = new FileOutputStream("int.dat");

//1: 0b00000000 00000000 00000000 00000001

//结果 0b 00000001 0x01

fileOutputStream.write(1);

//65535: 0b00000000 00000000 11111111 11111111

//结果 0b 11111111 0xff

fileOutputStream.write(65535);

//2147483647: 0b01111111 11111111 11111111 11111111

//结果 0b 11111111 0xff

fileOutputStream.write(2147483647);

fileOutputStream.flush();

}

//看源码可知，参数虽然是一个int但是注释写的很明白,只写一个字节

/**

* Writes the specified byte to this file output stream. Implements

* the write method of OutputStream.

*

* @param b the byte to be written.

* @exception IOException if an I/O error occurs.

*/

public void write(int b) throws IOException {

write(b, append);

}

//那具体写的int的哪个字节呢

@Test

public void writeInt() throws IOException {

FileOutputStream fileOutputStream = new FileOutputStream("int.dat");

//65534: 0b 00000000 00000000 11111111 11111110

//结果 0b 11111110 0xfe

fileOutputStream.write(65534);

//65532: 0b 00000000 00000000 11111111 11111100

//结果 0b 11111100 0xfc

fileOutputStream.write(65532);

//65528: 0b 00000000 00000000 11111111 11111000

//结果 0b 11111000 0xf8

fileOutputStream.write(65528);

//65520: 0b 00000000 00000000 11111111 11110000

//结果 0b 11110000 0xf0

fileOutputStream.write(65520);

//65504: 0b 00000000 00000000 11111111 11100000

//结果 0b 11100000 0xe0

fileOutputStream.write(65504);

//65472: 0b 00000000 00000000 11111111 11000000

//结果 0b 11000000 0xc0

fileOutputStream.write(65472);

//65408: 0b 00000000 00000000 11111111 10000000

//结果 0b 10000000 0x80

fileOutputStream.write(65408);

//65280: 0b 00000000 00000000 11111111 00000000

//结果 0b 00000000 0x00

fileOutputStream.write(65280);

//65024: 0b 00000000 00000000 11111110 00000000

//结果 0b 00000000 0x00

fileOutputStream.write(65024);

//2147483392: 0b 01111111 11111111 11111111 00000000

//结果 0b 00000000 0x00

fileOutputStream.write(2147483392);

fileOutputStream.flush();

}

2 还有一个值得注意的是， toBinaryString()及toHexString() 高位的0不输出

//1

System.out.println(Integer.toBinaryString(1));

//1111 1111

System.out.println(Integer.toBinaryString(255));

// 1111 1111 1111 1111

System.out.println(Integer.toBinaryString(65535));

// 111 1111 1111 1111 1111 1111 1111 1111

System.out.println(Integer.toBinaryString(2147483647));

System.out.println(Integer.toHexString(1)); // 1

System.out.println(Integer.toHexString(255)); // ff

System.out.println(Integer.toHexString(65535)); // ffff

System.out.println(Integer.toHexString(2147483647)); // 7fff ffff

3 那如何将int的4个字节写入到文件中

未理解原理时

//获得int值原始内存byte[]

private byte[] getBytes(int hexInt, int byteNum) {

String s = Integer.toHexString(hexInt);

String stringByByteCount = getStringByByteCount(s, byteNum);

byte[] bytes = getBytes(stringByByteCount);

return bytes;

}

//获取对应字节长度的16进制字符串，不够前补0

private String getStringByByteCount(String hexString, int bytesCount) {

StringBuilder builder = new StringBuilder();

int zeroAddCount = bytesCount * 2 - hexString.length();

for (int i = 0; i < zeroAddCount; i++) {

builder.append("0");

}

return builder.append(hexString).toString();

}

//将16进制的字符串遍历返回相应byte[]

private byte[] getBytes(String hexContent) {

byte[] bytes = new byte[hexContent.length() / 2];

for (int i = 0; i < hexContent.length(); i += 2) {

String substring = hexContent.substring(i, i + 2);

int i1 = Integer.parseInt(substring, 16);

bytes[i / 2] = (byte) i1;

}

return bytes;

}

理解了原理

int a = 1;

byte[] bytes = new byte[4];

//每次右移8位，只取最后一个字节，放入对应索引下

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

bytes[bytes.length - i - 1] = (byte) (a >> i * 8);

}

查看资料，找到更简便的方式

byte[] bytes = ByteBuffer.allocate(4).putInt(2).array();

ByteBuffer使用(allocate, wrap, order, put, get, rewind, flip, compact, array)

https://blog.csdn.net/mrliuzhao/article/details/89453082

字节序(endian) 大端字节序(big endian) 小端字节序(little endian)

https://www.cnblogs.com/gremount/p/8830707.html