Java IO流

Posted 2021-12-20 ixinfu

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java IO流相关的知识，希望对你有一定的参考价值。

写数据

FileOutputStream fos = new FileOutputStream("项目名\\\\fos.txt");
//写入方法
fos.write(97);

        做了三件事情：
            A:调用系统功能创建了文件
            B:创建了字节输出流对象
            C:让字节输出流对象指向创建好的文件

写数据的三种方式：

  public static void main(String[] args) throws IOException 
        //FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("myByteStream\\\\fos.txt"); 
        
        //void write(int b)：将指定的字节写入此文件输出流
//        fos.write(97);
//        fos.write(98);
//        fos.write(99);
//        fos.write(100);
//        fos.write(101);

//        void write(byte[] b)：将 b.length字节从指定的字节数组写入此文件输出流
//        byte[] bys = 97, 98, 99, 100, 101;
        //byte[] getBytes()：返回字符串对应的字节数组
        byte[] bys = "abcde".getBytes();
//        fos.write(bys);

        //void write(byte[] b, int off, int len)：将 len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流
//        fos.write(bys,0,bys.length);
        fos.write(bys,1,3);

        //释放资源
        fos.close();

字节流写数据的两个小问题

1:字节流写数据如何实现换行呢？
window:\\r\\n
inux:\\n
mac:\\r

2:字节流写数据如何实现追加写入呢？
public FileOutputStream(String name,boolean append)
创建文件输出流以指定的名称写入文件。
如果第二个参数为true ，则字节将写入文件的末尾而不是开头

 public static void main(String[] args) throws IOException 
        //创建字节输出流对象
//        FileOutputStream fos = new FileOutputStream("myByteStream\\\\fos.txt");

        FileOutputStream fos = new FileOutputStream("myByteStream\\\\fos.txt",true);//追加写入

        //写数据
        for (int i = 0; i < 10; i++) 
            fos.write("hello".getBytes());
            fos.write("\\r\\n".getBytes());
        

        //释放资源
        fos.close();

字节流写数据加入异常处理

  public static void main(String[] args) 
        //加入finally来实现释放资源
        FileOutputStream fos = null;
        try 
            fos = new FileOutputStream("项目名\\\\fos.txt");
            fos.write("hello".getBytes());
         catch (IOException e) 
            e.printStackTrace();
         finally 
            if(fos != null) 
                try 
                    fos.close();
                 catch (IOException e) 
                    e.printStackTrace();

读数据

import java.io.FileInputStream;
import java.io.IOException;

/*
    需求：
        把文件fos.txt中的内容读取出来在控制台输出

    FileInputStream：从文件系统中的文件获取输入字节
        FileInputStream(String name)：通过打开与实际文件的连接来创建一个FileInputStream,该文件由文件系统中的路径名name命名

    使用字节输入流读数据的步骤：
        1:创建字节输入流对象
        2:调用字节输入流对象的读数据方法
        3:释放资源
 */
public class FileInputStreamDemo01 
    public static void main(String[] args) throws IOException 
        //创建字节输入流对象
        //FileInputStream(String name)
        FileInputStream fis = new FileInputStream("myByteStream\\\\fos.txt");

        //调用字节输入流对象的读数据方法
        //int read()：从该输入流读取一个字节的数据

        /*
        //第一次读取数据
        int by = fis.read();
        System.out.println(by);
        System.out.println((char)by);

        //第二次读取数据
        by = fis.read();
        System.out.println(by);
        System.out.println((char)by);

        //再多读取两次
        by = fis.read();
        System.out.println(by);
        by = fis.read();
        System.out.println(by);

        //如果达到文件的末尾， -1
        */

        /*
        int by = fis.read();
        while (by != -1) 
            System.out.print((char)by);
            by = fis.read();
        
        */

        //优化上面的程序
        int by;
        /*
            fis.read()：读数据
            by=fis.read()：把读取到的数据赋值给by
            by != -1：判断读取到的数据是否是-1
         */
        while ((by=fis.read())!=-1) 
            System.out.print((char)by);
        


        //释放资源
        fis.close();

字节流复制文件

  //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("E:\\\\itcast\\\\窗里窗外.txt");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("myByteStream\\\\窗里窗外.txt");

        //读写数据，复制文本文件(一次读取一个字节，一次写入一个字节)
        int by;
        while ((by=fis.read())!=-1) 
            fos.write(by);
        

        //释放资源
        fos.close();
        fis.close();

一次读一个字节数组的数据

 public static void main(String[] args) throws IOException 
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("myByteStream\\\\fos.txt");

        //调用字节输入流对象的读数据方法
        //int read(byte[] b)：从该输入流读取最多 b.length个字节的数据到一个字节数组
        /*
        byte[] bys = new byte[5];

        //第一次读取数据
        int len = fis.read(bys);
        System.out.println(len);
        //String(byte[] bytes)
//        System.out.println(new String(bys));
        System.out.println(new String(bys,0,len));

        //第二次读取数据
        len = fis.read(bys);
        System.out.println(len);
//        System.out.println(new String(bys));
        System.out.println(new String(bys,0,len));

        //第三次读取数据
        len = fis.read(bys);
        System.out.println(len);
        //String(byte[] bytes, int offset, int length)
        System.out.println(new String(bys,0,len));

        //再多读取两次
        len = fis.read(bys);
        System.out.println(len);
        len = fis.read(bys);
        System.out.println(len);
        */

        /*
            hello\\r\\n
            world\\r\\n

            第一次：hello
            第二次：\\r\\nwor
            第三次：ld\\r\\nr

         */

        byte[] bys = new byte[1024]; //1024及其整数倍
        int len;
        while ((len=fis.read(bys))!=-1) 
            System.out.print(new String(bys,0,len));
        

        //释放资源
        fis.close();

字节流复制图片

 public static void main(String[] args) throws IOException 
        FileInputStream fis = new FileInputStream("C:\\\\itheima\\\\a.jpg");
        FileOutputStream fos = new FileOutputStream("myByteStream\\\\gs.jpg");

        byte[] bs = new byte[1024];
        int len;
        while ((len = fis.read(bs)) != -1)
            fos.write(bs,0,len);
        

        fis.close();
        fos.close();

字节缓冲流

import java.io.*;

/*
    字节缓冲流：
        BufferOutputStream
        BufferedInputStream

    构造方法：
        字节缓冲输出流：BufferedOutputStream(OutputStream out)
        字节缓冲输入流：BufferedInputStream(InputStream in)
 */
public class BufferStreamDemo 
    public static void main(String[] args) throws IOException 
        //字节缓冲输出流：BufferedOutputStream(OutputStream out)
//        FileOutputStream fos = new FileOutputStream("myByteStream\\\\bos.txt");
//        BufferedOutputStream bos = new BufferedOutputStream(fos);
        /*
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\\\bos.txt"));
        //写数据
        bos.write("hello\\r\\n".getBytes());
        bos.write("world\\r\\n".getBytes());
        //释放资源
        bos.close();
        */

        //字节缓冲输入流：BufferedInputStream(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("myByteStream\\\\bos.txt"));

        //一次读取一个字节数据
//        int by;
//        while ((by=bis.read())!=-1) 
//            System.out.print((char)by);
//        

        //一次读取一个字节数组数据
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1) 
            System.out.print(new String(bys,0,len));
        

        //释放资源
        bis.close();

字节流复制视频

import java.io.*;

/*
    需求：
        把E:\\\\itcast\\\\字节流复制图片.avi 复制到模块目录下的 字节流复制图片.avi

    思路：
        1:根据数据源创建字节输入流对象
        2:根据目的地创建字节输出流对象
        3:读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)
        4:释放资源

    四种方式实现复制视频，并记录每种方式复制视频的时间
        1:基本字节流一次读写一个字节             共耗时：64565毫秒
        2:基本字节流一次读写一个字节数组          共耗时：107毫秒
        3:字节缓冲流一次读写一个字节             共耗时：405毫秒
        4:字节缓冲流一次读写一个字节数组          共耗时：60毫秒
 */
public class CopyAviDemo 
    public static void main(String[] args) throws IOException 
        //记录开始时间
        long startTime = System.currentTimeMillis();

        //复制视频
//        method1();
//        method2();
//        method3();
        method4();

        //记录结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时：" + (endTime - startTime) + "毫秒");
    

    //字节缓冲流一次读写一个字节数组
    public static void method4() throws IOException 
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\\\itcast\\\\字节流复制图片.avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\\\字节流复制图片.avi"));

        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1) 
            bos.write(bys,0,len);
        

        bos.close();
        bis.close();
    

    //字节缓冲流一次读写一个字节
    public static void method3() throws IOException 
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\\\itcast\\\\字节流复制图片.avi"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\\\字节流复制图片.avi"));

        int by;
        while ((by=bis.read())!=-1) 
            bos.write(by);
        

        bos.close();
        bis.close();
    


    //基本字节流一次读写一个字节数组
    public static void method2() throws IOException 
        //E:\\\\itcast\\\\字节流复制图片.avi
        //模块目录下的 字节流复制图片.avi
        FileInputStream fis = new FileInputStream("E:\\\\itcast\\\\字节流复制图片.avi");
        FileOutputStream fos = new FileOutputStream("myByteStream\\\\字节流复制图片.avi");

        byte[] bys = new byte[1024];
        int len;
        while ((len=fis.read(bys))!=-1) 
            fos.write(bys,0,len);
        

        fos.close();
        fis.close();
    

    //基本字节流一次读写一个字节
    public static void method1() throws IOException 
        //E:\\\\itcast\\\\字节流复制图片.avi
        //模块目录下的 字节流复制图片.avi
        FileInputStream fis = new FileInputStream("E:\\\\itcast\\\\字节流复制图片.avi");
        FileOutputStream fos = new FileOutputStream("myByteStream\\\\字节流复制图片.avi");

        int by;
        while ((by=fis.read())!=-1) 
            fos.write(by);
        

        fos.close();
        fis.close();

以上是关于Java IO流的主要内容，如果未能解决你的问题，请参考以下文章

Java-IO处理流

JAVA IO流相关代码（打印流和文件拼接）

JAVA字节缓冲流代码实现所有类型文件的复制