IO 流

IO 流: 存储和读取数据的解决方案.

程序示例:

import java.io.FileOutputStream;
import java.io.IOException;
 
public class ByteStreamDemo1 {
    public static void main(String[] args) throws IOException {
        /*
         * 演示：字节输出流FileOutputStream
         * 实现需求：写出一段文字到本地文件中。（暂时不写中文）
         *
         * 实现步骤：
         *       创建对象
         *       写出数据
         *       释放资源
         * */
 
        // 1.创建对象
        // 写出 输出流 OutputStream
        // 本地文件    File
        FileOutputStream fos = new FileOutputStream("myio\\a.txt");
        // 2.写出数据
        fos.write(97);
        // 3.释放资源
        fos.close();
    }
}

程序示例:

import java.io.FileOutputStream;
import java.io.IOException;
 
public class ByteStreamDemo2 {
    public static void main(String[] args) throws IOException {
    /*
          字节输出流的细节：
              1.创建字节输出流对象
                    细节1：参数是字符串表示的路径或者是File对象都是可以的
                    细节2：如果文件不存在会创建一个新的文件，但是要保证父级路径是存在的。
                    细节3：如果文件已经存在，则会清空文件
              2.写数据
                    细节：write方法的参数是整数，但是实际上写到本地文件中的是整数在ASCII上对应的字符
                    ‘9’
                    ‘7’
              3.释放资源
                    每次使用完流之后都要释放资源
 
    */
        // 1.创建对象
        FileOutputStream fos = new FileOutputStream("myio\\a.txt");
        // 2.写出数据
        fos.write(57);
        fos.write(55);
        // 3.释放资源
        fos.close();
 
        while (true) {
        }
    }
}

FileOutputStream 写数据的 3 种方式:

程序示例:

import java.io.FileOutputStream;
import java.io.IOException;
 
public class ByteStreamDemo3 {
    public static void main(String[] args) throws IOException {
        /*
           void write(int b)                       一次写一个字节数据
           void write(byte[] b)                    一次写一个字节数组数据
           void write(byte[] b, int off, int len)  一次写一个字节数组的部分数据
           参数一：
                数组
           参数二：
                起始索引  0
           参数三：
                个数      3
        */
 
        // 1.创建对象
        FileOutputStream fos = new FileOutputStream("myio\\a.txt");
        // 2.写出数据
        // fos.write(97); // a
        // fos.write(98); // b
        byte[] bytes = {97, 98, 99, 100, 101};
        /* fos.write(bytes);*/
 
        fos.write(bytes, 1, 2);// b c
        // 3.释放资源
        fos.close();
    }
}

程序示例:

import java.io.FileOutputStream;
import java.io.IOException;
 
public class ByteStreamDemo4 {
    public static void main(String[] args) throws IOException {
        /*
            换行写：
                再次写出一个换行符就可以了
                windows： \r\n
                Linux:    \n
                Mac:      \r
            细节：
                在windows操作系统当中，java对回车换行进行了优化。
                虽然完整的是\r\n，但是我们写其中一个\r或者\n，
                java也可以实现换行，因为java在底层会补全。
            建议：
                不要省略，还是写全了。
 
            续写：
                如果想要续写，打开续写开关即可
                开关位置：创建对象的第二个参数
                默认false：表示关闭续写，此时创建对象会清空文件
                手动传递true：表示打开续写，此时创建对象不会清空文件
        */
 
        // 1.创建对象
        FileOutputStream fos = new FileOutputStream("myio\\a.txt", true);
        // 2.写出数据
        String str = "kankelaoyezuishuai";
        byte[] bytes1 = str.getBytes();
        fos.write(bytes1);
 
        // 再次写出一个换行符就可以了
        String wrap = "\r\n";
        byte[] bytes2 = wrap.getBytes();
        fos.write(bytes2);
 
        String str2 = "666";
        byte[] bytes3 = str2.getBytes();
        fos.write(bytes3);
 
        // 3.释放资源
        fos.close();
    }
}

FileInputStream:

程序示例:

import java.io.FileInputStream;
import java.io.IOException;
 
public class ByteStreamDemo1 {
    public static void main(String[] args) throws IOException {
        /*
         * 演示：字节输入流FileInputStream
         * 实现需求：读取文件中的数据。（暂时不写中文）
         *
         * 实现步骤：
         *       创建对象
         *       读取数据
         *       释放资源
         * */
 
        // 1.创建对象
        FileInputStream fis = new FileInputStream("myio\\a.txt");
        // 2.读取数据
        int b1 = fis.read();
        System.out.println((char) b1);
        int b2 = fis.read();
        System.out.println((char) b2);
        int b3 = fis.read();
        System.out.println((char) b3);
        int b4 = fis.read();
        System.out.println((char) b4);
        int b5 = fis.read();
        System.out.println((char) b5);
        int b6 = fis.read();
        System.out.println(b6);//-1
        // 3.释放资源
        fis.close();
    }
}

程序示例:

import java.io.FileInputStream;
import java.io.IOException;
 
public class ByteStreamDemo2 {
    public static void main(String[] args) throws IOException {
          /*
          字节输入流的细节：
              1.创建字节输入流对象
                    细节1：如果文件不存在，就直接报错。
                    Java为什么会这么设计呢？
                    输出流：不存在，创建
                        把数据写到文件当中
 
                    输入流：不存在，而是报错呢？
                        因为创建出来的文件是没有数据的，没有任何意义。
                        所以Java就没有设计这种无意义的逻辑，文件不存在直接报错。
 
                    程序中最重要的是：数据。
 
              2.写数据
                    细节1：一次读一个字节，读出来的是数据在ASCII上对应的数字
                    细节2：读到文件末尾了，read方法返回-1。
 
              3.释放资源
                    细节：每次使用完流之后都要释放资源
 
    */
        // 1.创建对象
        FileInputStream fis = new FileInputStream("myio\\b.txt");
        // 2.读取数据
        int b1 = fis.read();
        System.out.println((char) b1);
        // 3.释放资源
        fis.close();
    }
}

程序示例:

import java.io.FileInputStream;
import java.io.IOException;
 
public class ByteStreamDemo3 {
    public static void main(String[] args) throws IOException {
         /*
             字节输入流循环读取
         */
 
        // 1.创建对象
        FileInputStream fis = new FileInputStream("myio\\a.txt");
        // 2.循环读取
        int b;
        while ((b = fis.read()) != -1) {
            System.out.println((char) b);
        }
        // 3.释放资源
        fis.close();
        
        /* *//*
         *
         * read :表示读取数据，而且是读取一个数据就移动一次指针
         *
         * *//*
        FileInputStream fis = new FileInputStream("myio\\a.txt");
        //2.循环读取
        while ((fis.read()) != -1) {
            System.out.println(fis.read());//98  100  -1
        }
        //3.释放资源
        fis.close();*/
    }
}

程序示例:

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
 
public class ByteStreamDemo4 {
    public static void main(String[] args) throws IOException {
        /*
         *   练习：
         *       文件拷贝
         *       把D:\itheima\movie.mp4拷贝到当前模块下。
         *
         *   注意：
         *       选择一个比较小的文件，不要太大。大文件拷贝我们下一个视频会说。
         *
         *   课堂练习：
         *       要求统计一下拷贝时间，单位毫秒
         * */
 
        long start = System.currentTimeMillis();
 
        // 1.创建对象
        FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4");
        FileOutputStream fos = new FileOutputStream("myio\\copy.mp4");
        // 2.拷贝
        // 核心思想：边读边写
        int b;
        while ((b = fis.read()) != -1) {
            fos.write(b);
        }
        // 3.释放资源
        // 规则：先开的最后关闭
        fos.close();
        fis.close();
 
        long end = System.currentTimeMillis();
 
        System.out.println(end - start);
    }
}

按字节读取, 一次读取一个字节, 文件有多少个字节, 就要循环多少次.

FileInputStream 一次读取多个字节:

注意: 一次读一个字节数组的数据, 每次读取会尽可能把数组装满.

数组本身也是要占用存储空间的, 一般建议数组的长度为 1024 的整数倍, 例如 1024×1024×5.

程序示例:

import java.io.FileInputStream;
import java.io.IOException;
 
public class ByteStreamDemo5 {
    public static void main(String[] args) throws IOException {
      /*
          public int read(byte[] buffer)      一次读一个字节数组数据
      */
 
        // 1.创建对象
        FileInputStream fis = new FileInputStream("myio\\a.txt");
        // 2.读取数据
        byte[] bytes = new byte[2];
        // 一次读取多个字节数据，具体读多少，跟数组的长度有关
        // 返回值：本次读取到了多少个字节数据
        int len1 = fis.read(bytes);
        System.out.println(len1);// 2
        String str1 = new String(bytes, 0, len1);
        System.out.println(str1);
 
 
        int len2 = fis.read(bytes);
        System.out.println(len2);// 2
        String str2 = new String(bytes, 0, len2);
        System.out.println(str2);
 
        int len3 = fis.read(bytes);
        System.out.println(len3);// 1
        String str3 = new String(bytes, 0, len3);
        System.out.println(str3);// ed
 
        // 3.释放资源
        fis.close();
    }
}

程序示例:

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
 
public class ByteStreamDemo6 {
    public static void main(String[] args) throws IOException {
        /*
         *   练习：
         *       文件拷贝
         *       把D:\itheima\movie.mp4 (16.8 MB) 拷贝到当前模块下。
         *
         * */
 
        long start = System.currentTimeMillis();
 
        // 1.创建对象
        FileInputStream fis = new FileInputStream("D:\\itheima\\movie.mp4");
        FileOutputStream fos = new FileOutputStream("myio\\copy.mp4");
        // 2.拷贝
        int len;
        byte[] bytes = new byte[1024 * 1024 * 5];
        while ((len = fis.read(bytes)) != -1) {
            fos.write(bytes, 0, len);
        }
        // 3.释放资源
        fos.close();
        fis.close();
 
        long end = System.currentTimeMillis();
 
        System.out.println(end - start);
    }
}