精华内容
下载资源
问答
  • 这是一段将byte数组写入文件JAVA代码,适用于手机移动开发,可以用来测试从服务器接收的输出流到本地是否正确
  • 下面是一个如何适当地执行从文件中读取字节数组的反向操作(抱歉,这只是我已经准备好的代码,我不希望asker实际粘贴并使用此代码):public static byte[] toByteArray(File file) throws IOException {...

    一位评论者问:“为什么要使用第三方库?”答案是,你自己做这件事太痛苦了。下面是一个如何

    适当地

    执行从文件中读取字节数组的反向操作(抱歉,这只是我已经准备好的代码,我不希望asker实际粘贴并使用此代码):

    public static byte[] toByteArray(File file) throws IOException {

    ByteArrayOutputStream out = new ByteArrayOutputStream();

    boolean threw = true;

    InputStream in = new FileInputStream(file);

    try {

    byte[] buf = new byte[BUF_SIZE];

    long total = 0;

    while (true) {

    int r = in.read(buf);

    if (r == -1) {

    break;

    }

    out.write(buf, 0, r);

    }

    threw = false;

    } finally {

    try {

    in.close();

    } catch (IOException e) {

    if (threw) {

    log.warn("IOException thrown while closing", e);

    } else {

    throw e;

    }

    }

    }

    return out.toByteArray();

    }

    每个人都应该对这是多么的痛苦感到震惊。

    展开全文
  • java byte数组文件读写 分类: java 2012-04-12 22:03 ...一个文件内的所有内容读取到byte数组,也可以把一个byte[]的内容写入文件中。可以作为复制文件的方法 [java] view plaincopy impor

    java byte数组与文件读写

    分类: java 9327人阅读 评论(2) 收藏 举报

    将一个文件内的所有内容读取到byte数组,也可以把一个byte[]的内容写入到文件中。可以作为复制文件的方法

    1. import java.io.ByteArrayOutputStream;  
    2. import java.io.File;  
    3. import java.io.FileInputStream;  
    4. import java.io.FileOutputStream;  
    5. import java.io.IOException;  
    6.   
    7. public class FileHelper {  
    8. <span style="white-space:pre">  </span>//第一种获取文件内容方式  
    9.     public byte[] getContent(String filePath) throws IOException {  
    10.         File file = new File(filePath);  
    11.   
    12.         long fileSize = file.length();  
    13.         if (fileSize > Integer.MAX_VALUE) {  
    14.             System.out.println("file too big...");  
    15.             return null;  
    16.         }  
    17.   
    18.         FileInputStream fi = new FileInputStream(file);  
    19.   
    20.         byte[] buffer = new byte[(int) fileSize];  
    21.   
    22.         int offset = 0;  
    23.   
    24.         int numRead = 0;  
    25.   
    26.         while (offset < buffer.length  
    27.   
    28.         && (numRead = fi.read(buffer, offset, buffer.length - offset)) >= 0) {  
    29.   
    30.             offset += numRead;  
    31.   
    32.         }  
    33.   
    34.         // 确保所有数据均被读取  
    35.   
    36.         if (offset != buffer.length) {  
    37.   
    38.             throw new IOException("Could not completely read file "  
    39.                     + file.getName());  
    40.   
    41.         }  
    42.   
    43.         fi.close();  
    44.   
    45.         return buffer;  
    46.     }  
    47.       
    48.     //第二种获取文件内容方式  
    49.     public byte[] getContent2(String filePath) throws IOException  
    50.     {  
    51.         FileInputStream in=new FileInputStream(filePath);  
    52.           
    53.         ByteArrayOutputStream out=new ByteArrayOutputStream(1024);  
    54.           
    55.         System.out.println("bytes available:"+in.available());  
    56.           
    57.         byte[] temp=new byte[1024];  
    58.           
    59.         int size=0;  
    60.           
    61.         while((size=in.read(temp))!=-1)  
    62.         {  
    63.             out.write(temp,0,size);  
    64.         }  
    65.           
    66.         in.close();  
    67.           
    68.         byte[] bytes=out.toByteArray();  
    69.         System.out.println("bytes size got is:"+bytes.length);  
    70.           
    71.         return bytes;  
    72.     }  
    73.         //将byte数组写入文件  
    74.     public void createFile(String path, byte[] content) throws IOException {  
    75.   
    76.         FileOutputStream fos = new FileOutputStream(path);  
    77.   
    78.         fos.write(content);  
    79.         fos.close();  
    80.     }  
    81.   

    展开全文
  • java实现字节数组写入到新建文件中 1.具体代码如下所示: public class FileUtil { /** * 方法功能:字节数组写入到新建文件中。 * @param String fname * @param byte[] msg * @return boolean * */...

    java实现将字节数组写入到新建文件中

    1.具体代码如下所示:

    public class FileUtil {
    	/**
    	   * 方法功能:将字节数组写入到新建文件中。
    	   * @param String fname
    	   * @param byte[] msg
    	   * @return boolean
    	   * */
    	  public static boolean save2File(String fname, byte[] msg){
    	    OutputStream fos = null;
    	    try{
    	      File file = new File(fname);
    	      File parent = file.getParentFile();
    	      boolean bool;
    	      if ((!parent.exists()) && 
    	        (!parent.mkdirs())) {
    	        return false;
    	      }
    	      fos = new FileOutputStream(file);
    	      fos.write(msg);
    	      fos.flush();
    	      return true;
    	    }catch (FileNotFoundException e){
    	      return false;
    	    }catch (IOException e){
    	      File parent;
    	      return false;
    	    }
    	    finally{
    	      if (fos != null) {
    	        try{
    	          fos.close();
    	        }catch (IOException e) {}
    	      }
    	    }
    	  }
    	public static void main(String[] args)  {
    		String msgStr = "aaaaa中国加油!!!!战胜新冠状病毒!!!";
    		String filename = "E:\\test\\system\\test.txt";//注意修改为自己的文件名
    		byte[] bytes = msgStr.getBytes();
            FileUtil fileUtil = new FileUtil();
    		boolean flag = fileUtil.save2File(filename, bytes);
        }
    }
    
    展开全文
  • 目录一、转换流二、字节缓冲流三、字符缓冲流四、序列化流与反序列化流五、打印流六、标准输入、输出流七、IO...是字符通向字节的桥梁, 字符流 转成 字节流write():字符,字符数组,字符串(2) 构造方法OutputSt...

    目录

    一、转换流
    二、字节缓冲流
    三、字符缓冲流
    四、序列化流与反序列化流
    五、打印流
    六、标准输入、输出流
    七、IO流总结

    一、转换流

    1. OutputStreamWriter 类

    (1) 概述

    • java.io.OutputStreamWriter继承 Writer类;就是一个字符输出流,写文本文件;
    • 是字符通向字节的桥梁,将 字符流 转成 字节流
    • write():字符,字符数组,字符串

    (2) 构造方法

    • OutputStreamWriter(OuputStream out):接收所有的字节输出流

    字节输出流目前只有: FileOutputStream

    • OutputStreamWriter(OutputStream out, String charsetName)

    String charsetName:传递 编码表名字:GBK、UTF-8

    public class OutputStreamWriterDemo {    public static void main(String[] args) throws IOException {        writeUTF();    }   //转换流对象OutputStreamWriter写文本,采用UTF-8编码表写入    public static void writeUTF()throws IOException{        //创建字节输出流,绑定文件        FileOutputStream fos = new FileOutputStream("c:utf.txt");        //创建转换流对象,构造方法保证字节输出流,并指定编码表是UTF-8        OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8"); //GBK可以不写        osw.write("你好");        osw.close(); //使用close()连刷新带关闭    }}123456789101112131415

    2. InputStreamReader 类

    (1) 概述

    • java.io.InputStreamReader继承 Reader;是 字符输入流,读取文本文件
    • 字节流向字符的桥梁,将 字节流 转为 字符流
    • 读取的方法:read() 读取1个字符,读取字符数组

    (2) 构造方法

    • InputStreamReader(InputStream in):接收所有的 字节输入流

    可以传递的字节输入流: FileInputStream

    • InputStreamReader(InputStream in,String charsetName): 传递编码表的名字
    public class InputStreamReaderDemo {    public static void main(String[] args) throws IOException {        readUTF();    }    //转换流,InputSteamReader读取文本,采用UTF-8编码表,读取文件utf    public static void readUTF()throws IOException{        //创建字节输入流,传递文本文件        FileInputStream fis = new FileInputStream("c:utf.txt");        //创建转换流对象,构造方法中,包装字节输入流,同时写编码表名        InputStreamReader isr = new InputStreamReader(fis,"UTF-8");        char[] ch = new char[1024];        int len = isr.read(ch);        System.out.println(new String(ch,0,len));        isr.close();    }}1234567891011121314151617

    ###3. 转换流子类父类的区别

    • 继承关系OutputStreamWriter 的子类: FileWriterInputStreamReader 的子类:FileReader
    • 区别
    • OutputStreamWriterInputStreamReader 是字符和字节的桥梁:也可以称之为字符转换流。字符转换流原理:字节流 + 编码表
    • FileWriterFileReader:作为子类,仅作为操作字符文件的便捷类存在。当操作的字符文件,使用的是默认编码表时可以不用父类,而直接用子类就完成操作了,简化了代码。
    • 以下三句话功能相同

    InputStreamReader isr = new InputStreamReader(new FileInputStream(“a.txt”));//默认字符集。
    InputStreamReader isr = new InputStreamReader(new FileInputStream(“a.txt”),“GBK”);//指定GBK字符集。
    FileReader fr = new FileReader(“a.txt”);

    注意:一旦要指定其他编码时,绝对不能用子类,必须使用字符转换流。什么时候用子类呢?
    条件:1、操作的是文件。2、使用默认编码。

    二、字节缓冲流

    1. 概述

    • 可提高IO流的读写速度
    • 分为字节缓冲流与字符缓冲流

    2. 字节输出缓冲流 BufferedOutputStream

    • java.io.BufferedOuputStream作用: 提高原有输出流的写入效率
    • BufferedOuputStream 继承 OutputStream
    • 方法:写入 write 字节,字节数组
    • 构造方法BufferedOuputStream(OuputStream out):可以传递任意的字节输出流,传递的是哪个字节流,就对哪个字节流提高效率
    public class BufferedOutputStreamDemo {    public static void main(String[] args)throws IOException {        //创建字节输出流,绑定文件        //FileOutputStream fos = new FileOutputStream("c:buffer.txt");        //创建字节输出流缓冲流的对象,构造方法中,传递字节输出流        BufferedOutputStream bos = new                BufferedOutputStream(new FileOutputStream("c:buffer.txt"));        bos.write(55);        byte[] bytes = "HelloWorld".getBytes();        bos.write(bytes);        bos.write(bytes, 3, 2);        bos.close();    }}1234567891011121314151617

    3. 字节输入缓冲流 BufferedInputStream

    • BufferedInputStream,继承 InputStream ,标准的字节输入流
    • 读取方法: read() ,单个字节,字节数组
    • 构造方法: BufferedInputStream(InputStream in):可以传递任意的字节输入流,传递是谁,就提高谁的效率
    • 可以传递的字节输入流 FileInputStream
    public class BufferedInputStreamDemo {    public static void main(String[] args) throws IOException{        //创建字节输入流的缓冲流对象,构造方法中包装字节输入流,包装文件        BufferedInputStream bis = new                BufferedInputStream(new FileInputStream("c:buffer.txt"));        byte[] bytes = new byte[1024];        int len = 0 ;        while((len = bis.read(bytes))!=-1){            System.out.print(new String(bytes,0,len));        }        bis.close();    }}12345678910111213

    4. 四种文件复制方式的效率比较

    • 结论:
    • 字节流读写单个字节 :125250 毫秒
    • 字节流读写字节数组 :193 毫秒
    • 字节流缓冲区流读写单个字节:1210 毫秒
    • 字节流缓冲区流读写字节数组 :73 毫秒
    • 代码
    public class Copy {    public static void main(String[] args)throws IOException {        long s = System.currentTimeMillis();        copy_4(new File("c:q.exe"), new File("d:q.exe"));        long e = System.currentTimeMillis();        System.out.println(e-s);    }    /*     * 方法,实现文件复制     *  4. 字节流缓冲区流读写字节数组     */    public static void copy_4(File src,File desc)throws IOException{        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));        int len = 0 ;        byte[] bytes = new byte[1024];        while((len = bis.read(bytes))!=-1){            bos.write(bytes,0,len);        }        bos.close();        bis.close();    }    /*     * 方法,实现文件复制     *  3. 字节流缓冲区流读写单个字节     */    public static void copy_3(File src,File desc)throws IOException{        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desc));        int len = 0 ;        while((len = bis.read())!=-1){            bos.write(len);        }        bos.close();        bis.close();    }    /*     * 方法,实现文件复制     *  2. 字节流读写字节数组     */    public static void copy_2(File src,File desc)throws IOException{        FileInputStream fis = new FileInputStream(src);        FileOutputStream fos = new FileOutputStream(desc);        int len = 0 ;        byte[] bytes = new byte[1024];        while((len = fis.read(bytes))!=-1){            fos.write(bytes,0,len);        }        fos.close();        fis.close();    }    /*     * 方法,实现文件复制     *  1. 字节流读写单个字节     */    public static void copy_1(File src,File desc)throws IOException{        FileInputStream fis = new FileInputStream(src);        FileOutputStream fos = new FileOutputStream(desc);        int len = 0 ;        while((len = fis.read())!=-1){            fos.write(len);        }        fos.close();        fis.close();    }}1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768

    三、字符缓冲流

    1. 字符输出缓冲流 BufferedWriter

    • java.io.BufferedWriter继承 Writer
    • 写入方法: write () ,单个字符,字符数组,字符串
    • 构造方法:BufferedWriter(Writer w):传递任意字符输出流,传递谁,就高效谁
    • 能传递的字符输出流: FileWriter, OutputStreamWriter
    public class BufferedWrierDemo {    public static void main(String[] args) throws IOException{        //创建字符输出流,封装文件        FileWriter fw = new FileWriter("c:buffer.txt");        BufferedWriter bfw = new BufferedWriter(fw);        bfw.write(100);        bfw.flush();        bfw.write("你好".toCharArray());        bfw.flush();        bfw.write("你好");        bfw.flush();        bfw.write("我好好");        bfw.flush();        bfw.write("大家都好");        bfw.flush();        bfw.close();    }}1234567891011121314151617181920212223

    2. 字符输出缓冲流 BufferedWriter—特有方法 newLine

    • void newLine(): 写换行
    • newLine():文本中换行, 也是文本换行
    • 方法具有平台无关性

    windows ; Linux

    • newLine()运行结果和操作系统是相互关联的
    • JVM: 安装的是 Windows 版本,newLine()写的就是 ;安装的是 Linux 版本,newLine() 写的就是****

    3.字符输入流缓冲流 BufferedReader

    (1)概述

    • java.io.BufferedReader继承 Reader,从字符输入流中读取文本,缓冲各个字符,从而实现字符、数组和行的高效读取
      读取功能: read(), 单个字符,字符数组
      构造方法:BufferedReader(Reader r):可以任意的字符输入流,有:FileReaderInputStreamReader

    (2)BufferedReader 自己的功能

    • String readLine(): 读取文本行 ,读取一个文本行,包含该行内容的字符串,不包含任何行终止符,如果已到达流末尾,则返回 null

    获取内容的方法一般都有返回值
    int:没有返回的都是 负数
    引用类型: 找不到返回 null
    boolean: 找不到返回 false

    public class BufferedReaderDemo {    public static void main(String[] args) throws IOException {        int lineNumber = 0;        //创建字符输入流缓冲流对象,构造方法传递字符输入流,包装数据源文件        BufferedReader bfr = new BufferedReader(new FileReader("c:a.txt"));        //调用缓冲流的方法 readLine()读取文本行        //循环读取文本行, 结束条件 readLine()返回null        String line = null;        while((line = bfr.readLine())!=null){            lineNumber++;            System.out.println(lineNumber+"  "+line);        }        bfr.close();    }}123456789101112131415

    4. 字符流缓冲区流复制文本文件

    /* *  使用缓冲区流对象,复制文本文件 *  数据源  BufferedReader+FileReader 读取 *  数据目的 BufferedWriter+FileWriter 写入 *  读取文本行, 读一行,写一行,写换行 */public class Copy_1 {    public static void main(String[] args) throws IOException{        BufferedReader bfr = new BufferedReader(new FileReader("c:w.log"));           BufferedWriter bfw = new BufferedWriter(new FileWriter("d:w.log"));        //读取文本行, 读一行,写一行,写换行        String line = null;        while((line = bfr.readLine())!=null){            bfw.write(line);            bfw.newLine();            bfw.flush();        }        bfw.close();        bfr.close();    }}123456789101112131415161718192021

    四、序列化流与反序列化流

    1. 概述

    • 对象的序列化:对象中的数据,以流的形式,写入到文件中保存过程称为写出对象,ObjectOutputStream将对象写道文件中,实现序列化
    • 对象的反序列化:在文件中,以流的形式,将对象读出来,读取对象,ObjectInputStream将文件对象读取出来

    2. 实现

    • ObjectOutputStream: 写对象,实现序列化构造方法:ObjectOutputStream(OutputSteam out):传递任意的 字节输出流void writeObject(Object obj):写出对象
    • ObjectInputStream:读取对象,实现反序列化构造方法ObjectInputStream(InputStream in):传递任意的 字节输入流,输入流封装文件,必须是序列化的文件
    • Object readObject()读取对象
    //定义类public class Person implements Serializable{   //省略    }               } public class ObjectStreamDemo {    public static void main(String[] args)throws IOException, ClassNotFoundException {        writeObject();        readObject();    }    //ObjectOutputStream    public static void writeObject() throws IOException{        //创建字节输出流,封装文件        FileOutputStream fos = new FileOutputStream("c:person.txt");        //创建写出对象的序列化流的对象,构造方法传递字节输出流        ObjectOutputStream oos = new ObjectOutputStream(fos);        Person p = new Person("lisi",25);        //调用序列化流的方法writeObject,写出对象        oos.writeObject(p);        oos.close();    //ObjectInputStream    public static void readObject() throws IOException, ClassNotFoundException{        FileInputStream fis = new FileInputStream("c:person.txt");        //创建反序列化流,构造方法中,传递字节输入流        ObjectInputStream ois = new ObjectInputStream(fis);        //调用反序列化流的方法 readObject()读取对象        Object obj =ois.readObject();        System.out.println(obj);        ois.close();    }}12345678910111213141516171819202122232425262728293031323334

    3. 细节

    (1)transient 瞬态关键字

    • 作用: 被 transient修饰的属性不会被序列化
    • transient关键字只能修饰成员变量

    (2)静态不能序列化

    • 原因:序列化是把对象数据进行持久化存储;静态的东西不属于对象,而属于类

    (3)Serializable 接口

    • 作用:给需要序列化的类上加标记。该标记中没有任何抽象方法;只有实现了 Serializable接口的类的对象才能被序列化

    4. 序列化中的序列号冲突问题

    • 问题产生: 当一个类实现Serializable接口后,创建对象并将对象写入文件,之后更改了源代码 (比如:将成员变量的修饰符由private改成public),再次从文件中读取对象时会报异常
    • 原因:一旦修改了源码,重新编译产生class文件,会根据类的成员重新计算序列号,这样新编译的class文件中的序列号,与原来文件中的序列号就不同了
    • 解决:需要做一个终身不变的序列号! 需要在序列化中自定义序列号
    private static final long serialVersionUID = 1478652478456L;// 这样每次编译类时生成的 serialVersionUID 值都是固定的//类自定义了序列号,编译器就不会计算序列号123

    五、打印流

    1. 概述

    • 打印流添加输出数据的功能,使它们能够方便地打印各种数据值表示形式.

    2. 打印流根据流的分类

    • 字节打印流 PrintStream
    • 字符打印流 PrintWriter

    3. 方法

    • void print(String str): 输出任意类型的数据,
    • void println(String str): 输出任意类型的数据,自动写入换行操作

    4. 特点

    • 此流不负责数据源,只负责数据目的
    • 可以操作任意类型的数据。(boolean, int, long, float, double)
    • 打印流,可以开启自动刷新功能
      满足两个条件:使用特定的构造方法,打开打印流的自动刷新,输出的数据目的必须是流对象:OutputStreamWriter必须调用 println,printf,format三个方法中的一个,启用自动刷新
    • 为其他输出流,添加功能
    • 永远不会抛出 IOException,但是可能抛出别的异常

    5. 构造方法

    • 就是打印流的输出目的端
    • PrintStream构造方法接收File类型,接收字符串文件名,接收字节输出流OutputStream
    • PrintWriter构造方法接收File类型,接收字符串文件名,接收字节输出流OutputStream, 接收字符输出流Writer

    6. 打印字符数组

    • println数组,只有打印字符数组时是打印内容,其余均打印数组的地址
    • 因为api中定义了打印字符数组的方法,其底层是在遍历数组中的元素,而其他打印数组的方法,都是将数组对象编程Object,其底层再将对象编程String,调用了 String s = String.valueOf(x);方法

    7. 利用打印流,完成文本文件的复制

    /* * 打印流实现文本复制 * 读取数据源  BufferedReader+File 读取文本行 * 写入数据目的 PrintWriter+println 自动刷新 */public class PrintWriterDemo1 {    public static void main(String[] args) throws IOException{        BufferedReader bfr = new BufferedReader(new FileReader("c:a.txt"));        PrintWriter pw = new PrintWriter(new FileWriter("d:a.txt"),true);        String line = null;        while((line = bfr.readLine())!=null){            pw.println(line);        }        pw.close();        bfr.close();    }}1234567891011121314151617

    六、标准输入、输出流

    1. 概述

    • 标准输入流System.in默认指键盘输入
    • 标准输出流System.out向显示器输出

    2. 继承关系

    • PrintStream extends FilterOutputStream
    • FilterOutputStream extends OutputStream

    3. 案例

    public class StandardIO {    public static void main(String[] args) throws IOException {        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));        String s;        // 标准输入流的read方法,读取键盘数据的时候,当当前没有键盘输入数据的时候        // read会阻塞当前线程,使得不能结束,只有自定义协议,才能结束标准输入流        while((s = br.readLine()) != null) {            //自定协议,当用户输入886结束接收用户输入            if("886".equals(s)) {                break;            }            System.out.println("输出:" + s);        }        br.close();    }}12345678910111213141516

    七、IO流总结

    • 字节流字节输入流 InputStreamFileInputStream 操作文件的字节输入流BufferedInputStream高效的字节输入流ObjectInputStream 反序列化流字节输出流 OutputStramFileOutputStream 操作文件的字节输出流BufferedOutputStream 高效的字节输出流ObjectOuputStream 序列化流PrintStream 字节打印流
    • 字符流字符输入流 ReaderFileReader 操作文件的字符输入流BufferedReader 高效的字符输入流InputStreamReader 输入操作的转换流(把字节流封装成字符流)字符输出流 WriterFileWriter 操作文件的字符输出流BufferedWriter 高效的字符输出流OutputStreamWriter 输出操作的转换流(把字节流封装成字符流)PrintWriter 字符打印流
    • 方法:读数据方法:read() 一次读一个字节或字符的方法read(byte[] char[]) 一次读一个数组数据的方法readLine() 一次读一行字符串的方法(BufferedReader类特有方法)readObject() 从流中读取对象(ObjectInputStream特有方法)写数据方法:write(int) 一次写一个字节或字符到文件中write(byte[] char[]) 一次写一个数组数据到文件中write(String) 一次写一个字符串内容到文件中writeObject(Object ) 写对象到流中(ObjectOutputStream类特有方法)newLine() 写一个换行符号(BufferedWriter类特有方法)
    • 向文件中写入数据的过程
      1,创建输出流对象
      2,写数据到文件
      3,关闭输出流
    • 从文件中读数据的过程
      1, 创建输入流对象
      2, 从文件中读数据
      3, 关闭输入流
    • 文件复制的过程
      1, 创建输入流(数据源)
      2, 创建输出流(目的地)
      3, 从输入流中读数据
      4, 通过输出流,把数据写入目的地
      5, 关闭流

    File类

    • 方法
    • 获取文件名称 getName()
    • 获取文件绝对路径 getAbsolutePath()
    • 获取文件大小 length()
    • 获取当前文件夹中所有File对象 File[] listFiles()
    • 判断是否为文件 isFile()
    • 判断是否为文件夹 isDirectory()
    • 创建文件夹 mkdir() mkdirs()
    • 创建文件 createNewFile()
    • 异常try…catch…finally捕获处理异常throws 声明异常throw 抛出异常对象
    • 异常的分类编译期异常 Exception运行期异常 RuntimeException
    • 注意:编译期异常,必须处理,不然无法编译通过运行期异常,程序运行过程中,产生的异常信息
    • 实现文件内容的自动追加构造方法FileOutputStream(File file, boolean append)FileOutputStream(String fileName, boolean append)FileWriter(File, boolean append)FileWriter(String fileName, boolean append)
    • 实现文件内容的自动刷新构造方法PrintStream(OutputStream out, boolean autoFlush)PrintWriter(OutputStream out, boolean autoFlush)PrintWriter(Writer out, boolean autoFlush)
    b7508f2c8e9b47b464ba0b4e83af0516.gif
    展开全文
  • 因为字节数组,除了写入文件或者以二进制的形式写入数据库以外,无法直接转为为字符串,因为字符串结尾有\0,当然肯定还有其他原因。下面提供几种Java中使用的方案:方案一:直接利用BigInteger的方法,应该是最简单...
  • * 将byte数组写入文件 * * @param path * @param fileName * @param content * @throws IOException */ public static void writeFile(String path, String fileName, byte[] content) throws ...
  • 今天在测试直接写的文章: java byte【】数组与文件读写 时,想调用FileHelper类对字节数组以追加的方式写文件,结果无论怎样...//将byte数组写入文件 public void createFile(String path, byte[] content) thr...
  • byte数组文件流_文件字节流详解

    千次阅读 2020-12-26 15:03:57
    FileInputStream通过字节的方式读取文件,适合读取所有类型的文件(图像、视频、文本...Java也提供了FileWriter专门写入文本文件。1、将文件内容读取到程序中使用 FileInputStream 读取文件内容常用方法:1) abstrac...
  • 在这篇文章中,我向您展示如何文件转换为字节数组,然后再字节数组转换为文件。要文件转换为字节数组,请使用ByteArrayOutputStream类。此类实现输出流,在该流中,...文件输出流是用于数据写入文件或F...
  • java 合并两个byte数组

    2013-09-02 11:43:00
    Java多线程调用写文件函数,调用org.apache.commons.io.FileUtils....为了解决这个问题,写之前,一条记录的多个部分(byte数组)合并为一个byte数组,一次写入。 合并byte数组从网上找了个,很好用: ...
  • 任何人都可以告诉我一个从byte[]声音中去除白噪声的...以下是用于记录写入文件的方法(采用wav格式)。private AudioRecord.OnRecordPositionUpdateListener updateListener = new AudioRecord.OnRecordPositionUpd...
  • 我想开发一个简单的java音乐播放器,使用这个Sonic算法来加速和播放音乐github/Sonic.java. 以下是主要课程:github/Main.java. Main.java只需调用Sonic....我尝试在Main.java的do while循环中将字节写入ByteArrayOutp...
  • 前言有时我们希望把数据保存在...本文展示如何实现 Java 可变长数组。为什么不用 ArrayList?要满足文章开头的需求,为什么不使用 Java ArrayList?如果满足下面条件之一,可以使用 ArrayList:在数组中存储某种...
  • Java中:如何从byte []数组压缩文件?我的应用程序正在通过SMTP服务器接收电子邮件。 电子邮件中有一个或多个附件,电子邮件附件以byte []的形式返回(使用sun javamail api)。我正在尝试快速压缩附件文件,而不先...
  • Java文件处理类都在http://java.io包中,处理类分成:节点类、包装类(转化类、装饰类...( 分别是1,5,1个字符,1个字符可能由多个字节来存储)数据类型:3, 5.25, abcde(字符串)文件是以字节保存,因此程序变量...
  • Java的网络编程中传输的经常是byte数组,但我们实际中使用的数据类型可能是任一种数据类型,这就需要在它们之间相互转换,转换的核心在于其他类型的数据的每一位转换成byte类型的数据。下面给出相关的转换代码...
  • 昨天说到java数据类型共分为8种基本类型,一种字符类型,一种布尔类型,六种数字类型,先从最小的数字类型byte开始,我们还是以示例图为主线。我们现在E盘新建一个DataTypes文件夹来存放我们即将要做的数据类型示例...
  • 如题:想要一个byte[]数组大概是1024*8这样大小的一个数组写成一个二进制文件,但是写入的时候发现会有数据丢失,不知道因为什么啊? 下面是代码,请大牛给解答一下,谢谢啦! OutputStream os; FileOutputStream...
  • C语言中只使用一个File包处理一切文件操作,而在java中却有着60多种流类型,构成了整个流家族。看似庞大的体系结构,其实只要使用适合的方法其分门别类,就显得清晰明了了。而我准备其按照处理文件类型的不同,...
  • 创建一个指定大小的byte数组,将大文件读取到byte数组中,读满一次将byte数组写入一个新的小文件中,如此循环直到将大文件读取完毕 注意:此时最后一个小文件可能不足规定的内存大小,在从大文件读取最后一个byte...
  • Java读取文件内容到byte[]数组

    千次阅读 2012-08-15 17:54:37
    有时候,我们需要读取文件的内容到一个byte[] 数组中,然后对这个数组进行一些修改,这时,我们可以借助于 ByteArrayOutputStream 这个类来实现。 ByteArrayOutputStream,顾名思义,同样是一个OutputStream,...
  • 我试图从进程仍然使用该文件进行写入文件创建字节数组块.实际上我视频存储到文件中,我想在录制时从同一个文件创建块.以下方法应该从文件中读取字节块:private byte[] getBytesFromFile(File file) throws ...
  • 不幸的是,如果您尝试这样做,JavaSound会向您发出以下错误:java.io.IOException: stream length not specified我设法通过wav写入临时文件然后其读回来使其工作,如下所示:AudioInputStream so...
  • java输入或输出流中,总是有一个1024的字节数组大小. 如下所示: URL url = new URL(src); URLConnection connection = url.openConnection(); InputStream is = connection.getInputStream(); OutputStream os = ...
  • 上篇文章介绍了两种常用的文件输入输出流:java 字节流入门(文件流)其中向文件写入的数据都是预先定义好的字节数组 byte[] ,本文介绍另一种在内存中维护字节数组更常用的方式:内存数组输入输出流。内存数组流,...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 137
精华内容 54
关键字:

java将byte数组写入文件

java 订阅