精华内容
下载资源
问答
  • 主要给大家介绍了利用Java读取二进制文件的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者使用java具有一定的参考学习价值,需要的朋友们下面跟着小编来一起学习学习吧。
  • java读取二进制文件

    2020-03-31 14:13:13
    Java读取二进制文件,以字节为单位进行读取,还可读取图片、音乐文件、视频文件等, 在Java中,提供了四种类来对文件进行操作,分别是InputStream OutputStream Reader Writer ,前两种是对字节流的操作,后两种则是...

    Java读取二进制文件,以字节为单位进行读取,还可读取图片、音乐文件、视频文件等,
    在Java中,提供了四种类来对文件进行操作,分别是InputStream OutputStream Reader Writer ,前两种是对字节流的操作,后两种则是对字符流的操作。


    示例代码如下:

        /**
         * 读取固件文件
         */
        private void readFirmware(String fileName){
            File file = new File(Const.baseDir + fileName);
            int i=0;
            try {
                System.out.println("一次读一个");
                // 一次读一个字节
                InputStream in = new FileInputStream(file);
                int temp_byte;
                while ((temp_byte = in.read()) != -1) {
                    System.out.print(HexUtil.decToHex(temp_byte).toUpperCase() + " ");//System.out.write(temp_byte);write是源内容,print是字节码
                    if (i++ == 35){
                        System.out.println();
                        i=0;
                    }
                }
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
                return;
            }
        }

    或者(下面不对的。。。)

    思路:按照字节读取文件到缓冲,然后对文件内容进行处理。

    代码如下:

    public static void readFile() throws IOException{
        RandomAccessFile f = new RandomAccessFile("test.txt", "r");
        byte[] b = new byte[(int)f.length()];
        //将文件按照字节方式读入到字节缓存中
        f.read(b);
        //将字节转换为utf-8 格式的字符串
        String input = new String(b, "utf-8");
        //可以匹配到所有的数字
        Pattern pattern = Pattern.compile("\\d+(\\.\\d+)?");
        Matcher match = pattern.matcher(input);
        while(match.find()) {
            //match.group(0)即为你想获取的数据
            System.out.println(match.group(0));
        }
        f.close();
    }

     

    展开全文
  • Java读取二进制文件

    千次阅读 2016-02-17 16:05:13
    * 读取二进制文件并且写入数组里 * @param filePath * @return * @throws IOException * @throws FileNotFoundException */ public static byte[] getBytes4File(String filePath) t

    下面的代码是Java如何读取二进制文件

    public class FileUtil {
    
    	/**
    	 * 读取二进制文件并且写入数组里
    	 * @param filePath
    	 * @return
    	 * @throws IOException 
    	 * @throws FileNotFoundException 
    	 */
    	public static byte[] getBytes4File(String filePath) throws IOException {
    
    		InputStream in = null;
    		BufferedInputStream buffer = null;
    		DataInputStream dataIn = null;
    		ByteArrayOutputStream bos = null;
    		DataOutputStream dos = null;
    		byte[] bArray = null;
    		try {
    			in = new FileInputStream(filePath);
    			buffer = new BufferedInputStream(in);
    			dataIn = new DataInputStream(buffer);
    			bos = new ByteArrayOutputStream();
    			dos = new DataOutputStream(bos);
    			byte[] buf = new byte[1024];
    			while (true) {
    				int len = dataIn.read(buf);
    				if (len < 0)
    					break;
    				dos.write(buf, 0, len);
    			}
    			bArray = bos.toByteArray();
    
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			return null;
    
    		} finally {
    
    			if (in != null)
    				in.close();
    			if (dataIn != null)
    				dataIn.close();
    			if (buffer != null)
    				buffer.close();
    			if (bos != null)
    				bos.close();
    			if (dos != null)
    				dos.close();
    		}
    
    		return bArray;
    	}
    }


    展开全文
  • JAVA读取二进制文件

    万次阅读 2018-10-26 22:56:03
    (1)读取二进制文件;其中需要考虑二进制文件读出来的是十进制数,需要将二个字节合成一个short型,并转换为int型值。 (2)画图;根据读取到的点的信息,循环,如果状态是画,则将该点与上一点相...

    0 引言

    最近老师让写一个程序,作为学习JAVA的练习。目的在于:将一个二进制文件中的数据读取出来,其中数据包括点的位置信息和压力值及状态。将这些数据画作图像的形式展示。

    本小程序分为以下几部分:

    (1)读取二进制文件;其中需要考虑二进制文件读出来的是十进制数,需要将二个字节合成一个short型,并转换为int型值。

    (2)画图;根据读取到的点的信息,循环,如果状态是画,则将该点与上一点相连;

    1 读取二进制文件

    所有的输入流类都是抽象类InputStream或Reader的子类。本文主要使用其中的FilterInputStream子类中的DataInputStream和BufferedInputStream这两个子类。

    1.1 DataInputStream

    构造函数为:

    DataInputStream(InputStream in)
    Creates a DataInputStream that uses the specified underlying InputStream.

    使用基础类InputStream构造DataInputStream

    方法主要有,见下表

    本文使用readFully(byte[] b)方法读取所有的字节信息。

    代码示例如下:

    DataInputStream dis = null;
    
    dis = new DataInputStream(new FileInputStream ("./test.txt"));
    
    byte []b = new byte [1024];
    
    dis.read(b);

    文件的所有信息都会存储在定义的byte数组中。

    1.2 BufferedInputStream

    构造函数如下:

    BufferedInputStream(InputStream in)
    Creates a BufferedInputStream and saves its argument, the input stream in, for later use.
    BufferedInputStream(InputStream in, int size)
    Creates a BufferedInputStream with the specified buffer size, and saves its argument, the input stream in, for later use.

    方法主要有,见下表

    主要使用read(byte [], off, len)方法读取文件信息。方法available()返回文件的字节数;

    示例代码如下:

    BUfferedInputStream bis = null;
    
    bis = new BufferedInputStream(new fileInputStream("./test.txt"));
    
    int len = bis.available();
    byte []b = new byte[len];
    
    bis.read(b, 0, len);

    byte数组中将存放文件的所有信息。

    1.3 处理数据

    根据以上两种方法获取了数据,接下来将对数据转换成int型。

    由于buff数组中存放的是一个字节一个字节的,故将两个字节组合即可。

    代码如下:

    int x = (buff[0] & 0xff) | (buff[1] & 0xff) << 8;
    int y = (buff[2] & 0xff) | (buff[3] & 0xff) << 8;

    以上是小端模式(低地址中存放的是字数据的低字节,高地址存放的是字数据的高字节)的转换,大端(与小端相反)的话直接调换一下就行。

    2 画图

    采用Graphics2D进行画图,使用BufferedImage创建画,并通过方法getGraphics()返回2D图像。

     // create a BufferedImage with the size of (width, height)
            BufferedImage bufferedImage = new BufferedImage(width, height,                 
            BufferedImage.TYPE_INT_RGB);
            // to draw strokes, we need a Graphics2D - correlated with BufferedImage
            Graphics2D graphics2D = (Graphics2D) bufferedImage.getGraphics();
            // set the background to be WHITE
            graphics2D.setBackground(Color.WHITE);
            graphics2D.clearRect(0, 0, width, height);
            // set width and color for lines
            graphics2D.setPaint(Color.BLACK);
            graphics2D.setStroke(new BasicStroke(3));

    2.1 将所有点连接成线

    判断该点的状态是否是画,及下一个点是否是画,然后再连线

    int pos;
            boolean bDrawing = false;
            int xPrev=-1, yPrev=-1;
            for( pos = 4; pos + 7 <= nLength ; pos += 7)
            {
                byte status = buffer[pos];
                int x = ((buffer[pos+1]&0xff) | ((buffer[pos+2]&0xff) << 8)) / 10;
                int y = ((buffer[pos+3]&0xff) | ((buffer[pos+4]&0xff) << 8)) / 10;
                if( bDrawing ) {
                    if(status == 0x11) {
                        graphics2D.drawLine(xPrev, yPrev, x, y);
                        xPrev = x;
                        yPrev = y;
                    }
                    else {
                        bDrawing = false;
                    }
                }
                else {
                    if(status == 0x11) {
                        bDrawing = true;
                        xPrev = x;
                        yPrev = y;
                    }
                    else {
                        // floating
                    }
                }
    
            }

    3 结果

    4 总结

    任重而道远,老师还是最牛逼的!

    展开全文
  • 最近手头的活儿暂告一段落,...说到这儿,很多人大概都会说,这有什么难的,Java读取二进制的方法有一大堆,随便找一个都可以读取,的确,Java的读取方法有很多,但是似乎没有一个读取一个字节就会让当前字节位提升一位

    最近手头的活儿暂告一段落,正好有时间整理一下前面做的一个项目,在某些时候,我们需要读取一个格式明确的二进制文件,由于格式确定,我们还需要按照位数来读取相对应的内容(例如,我们需要读取第44位到第56位的这12个字节),说到这儿,很多人大概都会说,这有什么难的,Java读取二进制的方法有一大堆,随便找一个都可以读取,的确,Java的读取方法有很多,但是似乎没有一个读取一个字节就会让当前字节位提升一位的方法,如果你需要按照某个字节来读取,就会出现问题(当然,如果利用复制数组来“曲线救国”,那就另当别论)。

    由于C#里的 BinaryReader 其中包含的很多读取二进制的方法都不错,关键是都会自动提升位数,所以就仿着写了一个可以自动提升的工具类BinaryReaderJ,废话不多说,直接上代码:

    import java.io.DataInputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStream;
    /**
     * 仿C#BinaryReader的java方法
     * @author RKGG
     * @version 1.0
     * */
    public class BinaryReaderJ {
    	
    	
    	private static File file;
    	private static InputStream in;
    	private static DataInputStream dStream;
    	
    	public BinaryReaderJ(File file){
    		this.file = file;
    		try {
    			in = new FileInputStream(file);
    			dStream = new DataInputStream(in);
    		} catch (FileNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    	
    	/**
    	 * 读取一个byte
    	 * @author RKGG
    	 * @param 返回int
    	 * */
    	public static int read(){
    		int b = 0;
    		try {
    			b = dStream.read();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return b;
    	}
    	
    	/**
    	 * 一次性读取 length长度
    	 * 返回长度为length的byte[]
    	 * @author RKGG 
    	 * @param length 长度
    	 * @return 返回byte[]
    	 * */
    	public static byte[] read(int length){
    		byte[] bs = new byte[length];
    		byte[] rs = new byte[length];
    		try {
    			dStream.read(bs,0,length);
    			System.arraycopy(bs, 0, rs, 0, length);
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return rs;
    	}
    	
    	/**
    	 * 读取2byte 返回1个int
    	 * @author RKGG
    	 * @return int
    	 * */
    	public static int readInt16(){
    		byte[] bs = new byte[2];
    		int temp = 0;
    		try {
    			dStream.read(bs,0,2);
    			temp = HexUtil.byte2int(bs);
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return temp;
    	}
    	
    	/**
    	 * 读取4byte 返回1个int
    	 * @author RKGG
    	 * @return 返回int
    	 * */
    	public static int readInt32(){
    		byte[] bs = new byte[4];
    		int temp = 0;
    		try {
    			dStream.read(bs,0,4);
    			temp = HexUtil.byteArrayToInt(bs, 0);
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return temp;
    	}
    
    	/**
    	 * 将一个byte[] 按索引位置读取2byte 返回Int
    	 * @author RKGG
    	 * @param byte[]
    	 * @param 起始位置
    	 * @return int
    	 * */
    	public static int ToInt16(byte[] b,int start){
    		byte[] bs = new byte[2];
    		int temp = 0;
    		System.arraycopy(b, start, bs, 0, 2);
    		temp = HexUtil.byte2int(bs);
    		return temp;
    	}
    	
    	/**
    	 * 将一个byte[] 按索引位置读取4byte 返回Int
    	 * @author RKGG
    	 * @param byte[]
    	 * @param 起始位置
    	 * @return int
    	 * */
    	public static int ToInt32(byte[] b,int start){
    		byte[] bs = new byte[4];
    		int temp = 0;
    		System.arraycopy(b, start, bs, 0, 4);
    		temp = HexUtil.byteArrayToInt(bs, 0);
    		return temp;
    	}
    	
    	/**
    	 * 读取8byte 返回1个double
    	 * @author RKGG
    	 * @return double
    	 * */
    	public static double readDouble(){
    		byte[] bs = new byte[8];
    		double b = 0;
    		try {
    			dStream.read(bs,0,8);
    			b = HexUtil.byteArrayToDouble(bs, 0);
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return b;
    	}
    	
    	/**
    	 * 将一个byte[] 按索引位置读取8byte 返回Double
    	 * @author RKGG
    	 * @param byte[]
    	 * @param 起始位置
    	 * @return double
    	 * */
    	public static double ToDouble(byte[] b,int start){
    		byte[] bs = new byte[8];
    		System.arraycopy(b, start, bs, 0, 8);
    		double d = HexUtil.byteArrayToDouble(bs, 0);
    		return d;
    	}
    	
    	/**
    	 * 读取一个长度为 length*8 的byte[]
    	 * 返回一个长度为 length的double[]
    	 * @author RKGG
    	 * @param length 长度
    	 * @param 返回double[]
    	 * */
    	public static double[] readDoubles(int length){
    		byte[] bs = new byte[length*8];
    		double[] d = new double[length];
    		try {
    			dStream.read(bs,0,bs.length);
    			d = HexUtil.getData(bs, 0);
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return d;
    	}
    	
    	/**
    	 * 读取4byte 返回1个float
    	 * @author RKGG
    	 * @return 返回float
    	 * */
    	public static float readFloat(){
    		byte[] bs = new byte[4];
    		float f = 0;
    		try {
    			dStream.read(bs,0,4);
    			f = HexUtil.byteArrayToFloat(bs, 0, 0);
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return f;
    	}
    	
    	/**
    	 * 将一个byte[] 按索引位置读取4byte返回 1个float
    	 * @author RKGG
    	 * @param byte[]
    	 * @param 起始位置
    	 * @return 返回float
    	 * */
    	public static float ToFloat(byte[] b,int start){
    		byte[] bs = new byte[4];
    		System.arraycopy(b, start, bs, 0, 4);
    		float f = HexUtil.byteArrayToFloat(bs, 0, 0);
    		return f;
    	}
    	
    	/**
    	 * 读取一个长度为 length*4 的byte[]
    	 * 返回一个长度为 length的float[] 
    	 * @author RKGG
    	 * @param length
    	 * @return float[]
    	 * */
        public static float[] readFloats(int length){
        	byte[] bs = new byte[length*4];
        	float[] fs = new float[length];
        	try {
    			dStream.read(bs,0,bs.length);
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
            String s = new String(bs);
            String[] ssr = s.split(",");
            for (int i = 0; i < fs.length; i++) {
                fs[i] = Float.parseFloat(ssr[i]);
            }
            return fs;
        }
        
    	/**
    	 * 读取1byte转1char
    	 * @author RKGG
    	 * @return char
    	 * */
    	public static char readChar(){
    		byte[] bs = new byte[1];
    		char ch = 0;
    		try {
    			dStream.read(bs,0,1);
    			ch = HexUtil.byteArrayToChar(bs);
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return ch;	
    	}
    	
    	/**
    	 * 读取长度为length的byte[]
    	 * 返回长度为length的char[]
    	 * @author RKGG
    	 * @param length 
    	 * @return char[]
    	 * */
    	public static char[] readChars(int length){
    		byte[] bs = new byte[length];
    		char[] ch = new char[length];
    		try {
    			dStream.read(bs,0,bs.length);
    			ch = HexUtil.getChars(bs);
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return ch;
    	}
    	
    	
    	/**
    	 * 读取一定长度 l的byte[]
    	 * 返回长度为 l的String
    	 * @author RKGG
    	 * @param length
    	 * @return String
    	 * */
    	public static String readString(int length){
    		byte[] bs = new byte[length];
    		String string = "";
    		try {
    			dStream.read(bs,0,bs.length);
    			string = new String(bs);
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return string;
    	}
    	
    	
    	/**
    	 * 读取日期格式的double
    	 * 返回日期格式
    	 * @author RKGG
    	 * @param format
    	 * @return String
    	 * */
    	public static String readDate(String format){
    		byte[] bs = new byte[8];
    		String time = "";
    		double time_d = 0;
    		try {
    			dStream.read(bs,0,8);
    			time_d = HexUtil.byteArrayToDouble(bs, 0);
    			time = HexUtil.doubleToDate(time_d, format);
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return time;
    	}
    	
    	/**
    	 * 读取4byte转1boolean
    	 * @author RKGG
    	 * @param byte[]
    	 * @param start
    	 * @return boolean
    	 * */
    	public static boolean ToBoolean(byte[] b,int start){
    		byte[] bs = new byte[4];
    		System.arraycopy(b, start, bs, 0, 4);
    		boolean tmp = HexUtil.byteArrayToBoolean(bs, 0);
    		return tmp;
    	}
    	
    	/**
    	 * 关流
    	 * @author RKGG
    	 * */
    	public static void close(){
    		try {
    			dStream.close();
    			in.close();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    }
    
    HexUtil类如下:

    import java.io.UnsupportedEncodingException;
    import java.nio.ByteBuffer;
    import java.nio.CharBuffer;
    import java.nio.charset.Charset;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    import java.util.Date;
    import javax.xml.transform.Templates;
    
    public class HexUtil {
    
    	/**
    	 * 4byte 转 int
    	 * */
    	public static int byteArrayToInt(byte[] b, int start) {
    		int value = 0;
    		byte[] temp = null;
    		temp = new byte[4];
    		System.arraycopy(b, start, temp, 0, 4);
    		value = byte2int(temp);
    		return value;
    	}
    
    	public static int byteToInt(byte[] b, int offset) {
    		int value = 0;
    		for (int i = 0; i < 4; i++) {
    			int shift = (4 - 1 - i) * 8;
    			value += (b[i + offset] & 0x000000FF) << shift;
    		}
    		return value;
    	}
    
    	/**
    	 * 2byte 转int
    	 * */
    	public static int byte2int(byte[] res) {
    		int targets = (res[0] & 0xff) | ((res[1] << 8) & 0xff00);
    		return targets;
    	}
    
    	/**
    	 * byte[] 转 boolean
    	 * */
    	public static boolean byteArrayToBoolean(byte[] data, int start) {
    		if (data == null || data.length < 4) {
    			return false;
    		}
    		byte[] bytes = new byte[4];
    		System.arraycopy(data, start, bytes, 0, 4);
    		int tmp = byteArrayToInt(bytes, 0);
    		return (tmp == 0) ? false : true;
    	}
    
    	/**
    	 * get double[]
    	 * */
    	public static double[] getData(byte[] bs, int start) {
    		byte[] data;
    		double[] yData = new double[bs.length / 8];
    		int counts = 0;
    		for (int i = start; i < bs.length - 1;) {
    			data = new byte[8];
    			System.arraycopy(bs, i, data, 0, 8);
    			yData[counts] = byteArrayToDouble(data, 0);
    			i += 8;
    			counts++;
    		}
    		return yData;
    	}
    
    	public static double byteArrayToDouble(byte[] b, int start) {
    		long l;
    		byte[] bytes = new byte[8];
    		System.arraycopy(b, start, bytes, 0, 8);
    		l = bytes[0];
    		l &= 0xff;
    		l |= ((long) bytes[1] << 8);
    		l &= 0xffff;
    		l |= ((long) bytes[2] << 16);
    		l &= 0xffffff;
    		l |= ((long) bytes[3] << 24);
    		l &= 0xffffffffl;
    		l |= ((long) bytes[4] << 32);
    		l &= 0xffffffffffl;
    		l |= ((long) bytes[5] << 40);
    		l &= 0xffffffffffffl;
    		l |= ((long) bytes[6] << 48);
    		l &= 0xffffffffffffffl;
    		l |= ((long) bytes[7] << 56);
    		return Double.longBitsToDouble(l);
    	}
    
    	/**
    	 * byte[] 转string
    	 * 
    	 * */
    	public static String byteTostring(byte[] bs) {
    		String s = "";
    		try {
    			s = new String(bs,"GB2312");
    		} catch (UnsupportedEncodingException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return s;
    	}
    
    	/**
    	 * byte[] 转float
    	 * */
    	public static float byteArrayToFloat(byte[] b, int index, int start) {
    		int l;
    		byte[] data = new byte[4];
    		System.arraycopy(b, start, data, 0, 4);
    		l = data[index + 0];
    		l &= 0xff;
    		l |= ((long) data[index + 1] << 8);
    		l &= 0xffff;
    		l |= ((long) data[index + 2] << 16);
    		l &= 0xffffff;
    		l |= ((long) data[index + 3] << 24);
    		return Float.intBitsToFloat(l);
    	}
    
    	/**
    	 * byte[] 转 char
    	 * */
    	public static char[] getChar(byte[] bytes, int start) {
    		byte[] data;
    		char[] data_char = new char[bytes.length / 2];
    		int counts = 0;
    		for (int i = start; i < bytes.length - 1;) {
    			data = new byte[2];
    			System.arraycopy(bytes, i, data, 0, 2);
    			data_char[counts] = byteArrayToChar(data);
    			i += 2;
    			counts++;
    		}
    		return data_char;
    	}
    
    	public static char byteArrayToChar(byte[] b) {
    		char c = (char) (((b[0] & 0xFF) << 8) | (b[1] & 0xFF));
    		return c;
    	}
    
    	public static char[] getChars(byte[] bytes) {
    		Charset cs = Charset.forName("UTF-8");
    		ByteBuffer bb = ByteBuffer.allocate(bytes.length);
    		bb.put(bytes);
    		bb.flip();
    		CharBuffer cb = cs.decode(bb);
    
    		return cb.array();
    	}
    
    	/**
    	 * double 转 date
    	 * */
    	public static String doubleToDate(Double d,String format) {
    		String t;
    		Calendar base = Calendar.getInstance();
    		SimpleDateFormat outFormat = new SimpleDateFormat(format);
    		// Delphi的日期类型从1899-12-30开始
    		base.set(1899, 11, 30, 0, 0, 0);
    		base.add(Calendar.DATE, d.intValue());
    		base.add(Calendar.MILLISECOND, (int) ((d % 1) * 24 * 60 * 60 * 1000));
    		t = outFormat.format(base.getTime());
    		return t;
    	}
    }

    以上就是仿BinaryReader的Java代码,欢迎大家提出问题与批评指正。



    展开全文
  • 今年我由c#转到JAVA写ANDROID程序,在用JAVA读我以前用C#生成的一些二进制数据文件时,发现总是出问题。后查到这里因为JAVA和C#中int 和short数据存放时高底位顺序完全不同造成的。所以不能直接读DataInputStream....
  • 可参考,核心代码借鉴了: https://blog.csdn.net/iteye_13098/article/details/82648166 注掉的代码,是保存数据。 ---------------------------------------------------------------------------------------...
  • java读写二进制文件

    千次阅读 2016-08-16 12:48:04
    读取二进制文件,总共分三步 1。File f=new File("待读取的路径"); 2。FileInputStream fis=new FileInputStream(f); 3。DataInputStream dis=new DataInputStream(fis); 然后呢,直接调用read方法就好。 下面...
  • 用lucene写了一个抓包程序,在检索文件过程中,我通过数据包偏移量来读取指定内容并写入新文件,但是根据偏移量单次去读可以找到文件内容,但是使用循环只能读到第一次循环的内容后面的都读取不到,我根据生成的偏移...
  • 关于读取二进制文件 read() 读取指定字节数的问题 遇到的问题 ​ 今天在写组件的时候遇到的读取指定字节数的二进制文件,并且要求如果要求重复读取,则要从文件中从头开始读取。 问题分析 ​ 对于读取二进制文件,...
  • 主要介绍了java读取图片并转化为二进制字符串的实例代码,非常不错,具有一定的参考借鉴价值,需要的朋友可以参考下
  • java解析二进制文件(.dat)

    千次阅读 2020-06-03 15:43:45
    该文章讲的仅仅是通过java对于二进制文件解析操作 首先说明一下查看.dat文件的工具:C32Asm,可以通过该工具查看.dat文件,查看模式可以选择十六进制、十进制(我们最终要的是十进制)、八进制、二进制 注:开始...
  • java 读写二进制文件

    千次阅读 2012-11-12 20:32:15
    JAVA二进制文件读写代码 /** * 二进制读写文件 */ import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.DataInputStream; import java.io.DataOutputStream;
  • DataOutputStream DataInputStream 数据输入输出流 用于读取二进制/** * DataOutputStream DataInputStream * 数据输入输出流 用于读取二进制 * @author xiazhang * @date 2017-6-4 */ public class ...
  • 新建测试表drop table CMU_TMP_TEST;create table CMU_TMP_TEST ( id VARCHAR2(2...修改generatorConfig.xml增加测试表配置数据(mybatis框架的一种工具)自动生成测试表持久层代码修改DataAnalyze数据分析部分代码...
  • 代码摘自“Thinking in java 18.7.1章节”//: net/mindview/util/BinaryFile.java // Utility for reading files in binary form. package net.mindview.util;import java.io.*;public class BinaryFile { public ...
  • java二进制文件转化为字节数组

    千次阅读 2013-06-04 19:05:36
    java 中,如何把二进制文件(如图片,ssl证书 )转化为字节数组呢? 代码如下: @org.junit.Test public void test055() throws IOException { File inFile = new File("d:\\Chrysanthemum.jpg")...
  • java io 二进制方式存储对象到文件

    千次阅读 2018-01-19 14:03:06
    本文记录利用java 字节流把对象保存本地文件,然后读取到对象中。...DataOutputStream 二进制输出流,可以包装一个输出流,用于向文件写入二进制数据。 BufferedInputStream 数据缓冲流,可以包装一个输入流,优
  • 最近刚好遇到这个问题,刚开始在网上各种搜索,...页面点击某条信息---》获取id号---》传人后台进行条件查询----》获取图片二进制流----》转换成图片-----》输出到jsp页面 注: 1.入参:checkNo;//查询条件,根据
  • 1.将数据写入二进制文件[java] view plain copy public void wirteBinary() { try { DataOutputStream os = new DataOutputStream( new BufferedOutputStream(new FileOutputStrea...
  • Java 读取 C++写入的二进制数据

    千次阅读 2013-12-30 17:52:28
    C++写入二进制文件时它的字节顺序是左地右高,而java则是左高右低,因此在读取数据时需要转换下。 转换代码如下: public static int C2J_Int( int num ){ System.out.println( "num: "+Integer.toBinaryString...
  • 将做工程过程中比较好的一些内容段做个备份,下面的资料是关于 java分别通过字节流、字符流、二进制读取文件的内容,应该是对小伙伴们有些用途。 public class Start { public static void main(String args[]) ...
  • 不多说,直接上代码 #include #include #include #include #include #include using namespace std; #define L 101 #define M 102 #define N 103 void OnChange(float InParam, float &OutPar
  • 不过php提供了pack和unpack函数,用来进行二进制数据(binary data)和php内部数据的互转: Java代码   string pack ( string $format [, mixed $args [, mixed $...]] )   //Pack

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 128,750
精华内容 51,500
关键字:

java读取二进制代码

java 订阅