Java 基础 41 IO(字节流)

1.1 IO流的概述和分类

1.1.1 IO流

  IO可以拆开来理解

• I ---- Input -> 输入 -> 读取
• O ---- Output -> 输出 -> 写出

  读取和写出都是针对数据而言的, 所以, IO流就是用来处理设备之间的数据传输。

常见应用

• 文件复制
• 文件上传
• 文件下载

1.1.2 IO流的分类

• 按照类型分:
  • 字节流
  • 字符流(字符流数据通过Windows自带的记事本软件打开是可以读懂里面内容的)
• 按照流向分:
  • 输入流: 用来读取数据的:
  • 输出流 : 用来写出数据的

1.2 FileOutputStream写数据

1.2.1 字节流&字符流的抽象父类

字节流：
InputStream	字节输入流
OutputStream	字节输出流

字符流：
Reader	字符输入流
Writer	字符输出流

1.2.2 字节流写出数据

• 字节流写数据

  • OutputStream:此抽象类是表示输出字节流的所有类的超类
  • FileOutputStream:文件输出流是用于将数据写入 File

• 构造方法：

  • FileOutputStream(String name):
    • 创建一个向具有指定名称的文件中写入数据的输出文件流。

• 字节流写数据的步骤：

  • 创建字节输出流对象
  • 调用写数据的方法
  • 释放资源

1.2.3 案例代码

public class FileOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("a.txt");
        /*
         * 创建字节输出流对象做了这样的三件事情：
         * A:调用系统功能创建了文件
         * B:创建字节输出流对象
         * C:让fos这个对象指向a.txt这个文件
         */
        
        //write(int b) 
        fos.write(65);
        fos.write(66);
        
        //最后我们还要做一个事情
        //close() 关闭此文件输出流并释放与此流有关的所有系统资源。
        fos.close();
    }
}

1.3 FileOutputStream写数据的三种方式.

1.3.1 方法摘要

写出数据的三个方法:

* public void write(int b):一次写一个字节
  * public void write(byte[] b):一次写一个字节数组
  * public void write(byte[] b,int off,int len):一次写一个字节数组的一部分

String类中的方法

* byte[] getBytes()  将字符串转换为字节数组

1.3.2 案例代码

public class FileOutputStreamDemo2 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        //FileOutputStream(String name) 
        FileOutputStream fos = new FileOutputStream("b.txt");
        //new File(name)
//      FileOutputStream fos = new FileOutputStream(new File("b.txt"));
        
        //FileOutputStream(File file) 
//      File file = new File("b.txt");
//      FileOutputStream fos = new FileOutputStream(file);
//      FileOutputStream fos = new FileOutputStream(new File("b.txt"));
        
        //public void write(int b):一次写一个字节
//      fos.write(65);
        
        //public void write(byte[] b):一次写一个字节数组
//      byte[] bys = {65,66,67,68,69};
//      fos.write(bys);
        //需求：我如果是一个字符串的数据，能写吗?
        //String -- byte[]
        //String类中有一个方法：public byte[] getBytes()
//      byte[] bys = "ABCDE".getBytes();
//      fos.write(bys);
//      fos.write("ABCDE".getBytes());
        
        //public void write(byte[] b,int off,int len):一次写一个字节数组的一部分
        fos.write("ABCDE".getBytes(),0,3);
        
        //释放资源
        fos.close();
    }
}

1.4 FileOutputStream如何实现换行和追加写数据

1.4.1 如何实现数据的换行

  不同的操作系统，针对换行的符号识别是不一样的。

• windows:\r\n
• linux:\n
• mac:\r

1.4.2 如何实现数据的追加写入?

用构造方法带第二个参数是true的情况即可

1.4.3 案例代码

public class FileOutputStreamDemo3 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
        //FileOutputStream fos = new FileOutputStream("c.txt");
        //FileOutputStream(String name, boolean append) 
        //如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处
        FileOutputStream fos = new FileOutputStream("c.txt",true);
        
        //调用写数据的方法
        for(int x=0; x<10; x++) {
            fos.write("hello".getBytes());
            //加入换行符号
            fos.write("\r\n".getBytes());
        }
        
        //释放资源
        fos.close();
    }
}

1.5 FileOutputStream写数据加入异常处理

1.5.1 try..catch.finally

格式:

try{
    可能发生问题的代码
}catch(){
    处理异常代码
}finally{
    一定会被执行的代码.   // 通常用于释放资源, 做善后的动作
}

1.5.2 案例代码

public class FileOutputStreamDemo4 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try{
            //FileOutputStream fos = new FileOutputStream("d.txt");
//          fos = new FileOutputStream("z:\\d.txt");
            fos = new FileOutputStream("d.txt");
            fos.write("hello".getBytes());
        }catch(IOException e) {
            e.printStackTrace();
        }finally {
            if(fos!=null) {
                //释放资源
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

1.6 FileInputStream读数据方式1一次读取一个字节

1.6.1 字节流读取数据的三个步骤

• 字节流读数据的步骤：
  • 创建字节输入流对象
  • 调用读数据的方法
  • 释放资源

1.6.2 案例代码

public class FileInputStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("a.txt");
        int by;
        // 用by不断的记录读取到的每一个数据
        while((by=fis.read())!=-1) {
            System.out.print((char)by);
        }
        //释放资源
        fis.close();
    }
}

1.7 FileInputStream读数据方式2一次读取一个字节数组

1.7.1 方法摘要

public int read(byte[] b):

• 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中
• 返回值是读入缓冲区的字节总数，也就是实际的读取个数
• 如果因为已经到达文件末尾而没有更多的数据，则返回 -1。

1.7.2 案例代码

public class FileInputStreamDemo2 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        FileInputStream fis = new FileInputStream("b.txt");
        byte[] bys = new byte[1024]; //1024或者1024的整数倍
        int len;
        //将数据读取到数组中, 并用len记录读取到的有效字节个数
        while((len=fis.read(bys))!=-1) {
            System.out.print(new String(bys,0,len));
        }
        //释放资源
        fis.close();
    }
}

1.8 字节流练习之复制文本文件

• 需求： 拷贝文本文件
• 分析：
  • 创建输入输出流对象关联数据源和数据目的
  • 定义字节数组,为了提高效率
  • 将数据通过while循环不断读取到字节数组中
  • 将数据从字节数组中取出并写出
  • 释放资源

1.8.1 案例代码

public class CopyTxtTest {
    public static void main(String[] args) throws IOException {
        //封装数据源
        FileInputStream fis = new FileInputStream("d:\\窗里窗外.txt");
        //封装目的地
        FileOutputStream fos = new FileOutputStream("林青霞.txt");
        
        //读写数据
        //方式1:一次读取一个字节
//      int by;
//      while((by=fis.read())!=-1) {
//          fos.write(by);
//      }
        
        //方式2:一次读取一个字节数组
        byte[] bys = new byte[1024];
        int len;
        while((len=fis.read(bys))!=-1) {
            fos.write(bys, 0, len);
        }
        
        //释放资源
        fos.close();
        fis.close();
    }
}

1.9 字节流练习之复制图片

public class CopyJpgTest {
    public static void main(String[] args) throws IOException {
        // 封装数据源
        FileInputStream fis = new FileInputStream("d:\\mn.jpg");
        // 封装目的地
        FileOutputStream fos = new FileOutputStream("mn.jpg");

        // 读写数据
        // 方式1：一次读取一个字节，一次写一个字节(自己练习)
        // 方式2：一次读取一个字节数组，一次写一个字节数组的一部分
        byte[] bys = new byte[1024];
        int len;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }

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