java之IO流（字节流）

小灰灰 2021-09-30 04:36 405阅读 0赞

**一.字节输出流OutputStream**

OutputStream此抽象类，是表示输出字节流的所有类的超类。操作的数据都是字节，定义了输出字节流的基本共性功能方法。

输出流中定义都是写write方法：

**close():**关闭此输出流并释放与此流有关的所有系统资源

**flush():**刷新此输出流并强制写出所有缓冲的输出字节

**write(byte\[\] b):**将b.length个字节从指定的byte数组写入此输出流

**write(byte\[\] b,int off,int len):**将指定byte数组中从偏移量off开始的len个字节写入此输出流。

**write(int b):**将指定的字节写入此输出流。

**1.FileOutputStream类**

OutputStream有很多子类，其中子类FileOutputStream可用来写入数据到文件。FileOutputStream类，即文件输出流，是用于将数据写入 File的输出流。

**FileOutputStream（File file）：**创建一个向指定File对象表示的文件中写入数据的文件输出流

**FileOutputStream（String name）：**创建一个向具有指定名称的文件中写入数据的输出文件流

**2.FileOutputStream类写入数据到文件中**

public class FileOutputStreamDemo {
        public static void main(String[] args) throws IOException {
            //需求：将数据写入到文件中。
            //创建存储数据的文件。
            File file = new File("c:\\file.txt");
            //创建一个用于操作文件的字节输出流对象。一创建就必须明确数据存储目的地。
            //输出流目的是文件，会自动创建。如果文件存在，则覆盖。
            FileOutputStream fos = new FileOutputStream(file);
            //调用父类中的write方法。
            byte[] data = "abcde".getBytes();
            fos.write(data);
            //关闭流资源。
            fos.close();
        }
    }

**3.给文件中续写和换行**

FileOutputStream（File file,boolean append）：创建一个向指定File对象表示的文件中写入数据的文件输出流。

FileOutputStream（String name,boolean append）：创建一个向指定File对象表示的文件中写入数据的文件输出流。

public class FileOutputStreamDemo2 {
        public static void main(String[] args) throws Exception {
            File file = new File("c:\\file.txt");
            FileOutputStream fos = new FileOutputStream(file, true);
            String str = "\r\n"+"aaa";
            fos.write(str.getBytes());
            fos.close();
        }
    }

**4.IO异常的处理**

public class FileOutputStreamDemo3 {
        public static void main(String[] args) {
            File file = new File("c:\\file.txt");
            //定义FileOutputStream的引用
            FileOutputStream fos = null;
            try {
                //创建FileOutputStream对象
                fos = new FileOutputStream(file);
                //写出数据
                fos.write("abcde".getBytes());
            } catch (IOException e) {
                System.out.println(e.toString() + "----");
    throw new RuntimeException("文件写入失败，重试");
    
            } finally {
                //判断fos是否为null，不为null时，关闭资源
                if (fos != null) {
                    try {
                        fos.close();
                    } catch (IOException e) {
                        throw new RuntimeException("关闭资源失败");
                    }
                }
            }
        }
    }

**二.字节输入流InputStream**

通过InputStream可以实现把内存中的数据读到内存中

**read（）：**从输入流中读取数据的下一个字节

**read（byte\[\] b）：**从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中

**1. FileInputStream类**

** FileInputStream（File file）：**通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的File对象file指定

** FileInputStream（String name）：**通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名name指定

**2.****FileInputStream类读取数据read方法**

**read（）：**从输入流中读取数据的下一个字节

public class FileInputStreamDemo {
        public static void main(String[] args) throws IOException {
            File file = new File("c:\\file.txt");
            //创建一个字节输入流对象,必须明确数据源，其实就是创建字节读取流和数据源相关联。
            FileInputStream fis = new FileInputStream(file);
            //读取数据。使用 read();一次读一个字节。
            int ch = 0;
            while((ch=fis.read())!=-1){
                System.out.println("ch="+(char)ch);
            }
            // 关闭资源。
            fis.close();
        }
    }

**3.读取数据read(byte\[\])方法**

**read（byte\[\] b）：**从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中。

public class FileInputStreamDemo2 {
        public static void main(String[] args) throws IOException {
            /*
             * 演示第二个读取方法， read(byte[]);
             */
            File file = new File("c:\\file.txt");
            // 创建一个字节输入流对象,必须明确数据源，其实就是创建字节读取流和数据源相关联。
            FileInputStream fis = new FileInputStream(file);        
            //创建一个字节数组。
            byte[] buf = new byte[1024];//长度可以定义成1024的整数倍。        
            int len = 0;
            while((len=fis.read(buf))!=-1){
                System.out.println(new String(buf,0,len));
            }
            fis.close();
        }
    }

**三.复制文件**

**1.复制文件**

public class CopyFileTest {
        public static void main(String[] args) throws IOException {
            //1,明确源和目的。
            File srcFile = new File("c:\\YesDir\test.JPG");
            File destFile = new File("copyTest.JPG");
            
            //2,明确字节流 输入流和源相关联，输出流和目的关联。
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(destFile);
            
            //3, 使用输入流的读取方法读取字节，并将字节写入到目的中。
            int ch = 0;
            while((ch=fis.read())!=-1){
                fos.write(ch);
            }
            //4,关闭资源。
            fos.close();
            fis.close();
        }
    }

**2.缓冲数组复制文件**

public class CopyFileByBufferTest {
        public static void main(String[] args) throws IOException {
            File srcFile = new File("c:\\YesDir\test.JPG");
            File destFile = new File("copyTest.JPG");
            // 明确字节流 输入流和源相关联，输出流和目的关联。
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(destFile);
            //定义一个缓冲区。
            byte[] buf = new byte[1024];
            int len = 0;
            while ((len = fis.read(buf)) != -1) {
                fos.write(buf, 0, len);// 将数组中的指定长度的数据写入到输出流中。
            }
            // 关闭资源。
            fos.close();
            fis.close();
        }
    }

转载于:https://www.cnblogs.com/akiyama/p/10218991.html