ACAC 概述IO流及FileInputStream

/**
 * IO流，什么是IO？
 *      I：input
 *      O：output
 *      通过IO可以完成硬盘文件的读和写
 *
 * IO流的分类：
 *      1、按照流的方向进行分类
 *         以内存为参照物：
 *              往内存中去，叫做输入，或者读（Read）
 *              从内存中出来，叫输出，或者写（Write）
 *
 *      2、另一种方式是按照读取数据方法不同进行分类：
 *          1、有些流按照字节的方式及读取数据，一次读取1个字节byte，等同于一次读取8个二进制位
 *             这种流是万能的，什么类型的文件都可以读取，（文本文件，图片，声音文件，视频文件等）
 *             文件file.txt,采用字节流的话：
 *                    a中国saf张大发dee
 *                    第一次读：一个字节，’a'字符（‘a’字符在Windows系统中占用一个字节）
 *                    第二次读：一个字节，‘中’字符的一半（‘中’字符在Windows系统中占用两个字节）
 *                    第三次读：一个字节，‘中’字符的另一半
 *
 *
 *          2、有的流是按照字符的方式读取数据，一次读取一个字符，这种流是为了方便读取普通文本文件
 *             而存在的，这种流不能读取：图片，声音，视频等文件，只能读取纯文本文件，Word文件都无法读取
 *             文件file.txt,采用字符流的话：
 *                  a中国saf张大发dee
 *                  第一次读：’a'字符（‘a’字符在Windows系统中占用一个字节）
 *                  第二次读：‘中’字符（‘中’字符在Windows系统中占用两个字节）
 *
 *   总结：
 *         输入流，输出流
 *         字节流，字符流
 *
 *   2、java中的IO流已经写好了，我们不需要关心，只要掌握java中提供了哪些流，每个流的特点，每个流对象上的常用方法有哪些？
 *      java中的流都在java.io.*包下
 *
 *   3、java IO中的四大家族：
 *      java.IO.InputStream;  字节输入流
 *      java.IO.OutputStream;  字节输出流
 *
 *      java.IO.Reader; 字符输入流
 *      java.IO.Writer; 字符输出流
 *
 *      四大家族的首领都是接口（abstract class)
 *      public abstract class InputStream
 *      extends Object
 *      implements Closeable
 *
 *      所有的流都实现了：
 *          java.io.Closeable接口，都是可关闭的，都有close（）方法
 *          流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭
 *          不然会耗费（占用）很多资源，养成习惯，用完流要关闭。
 *
 *       所有的输出流都实现了：
 *          java.io.Flushable接口，都是可刷新的，都有flush()方法
 *          养成习惯，输出流在最终输出之后，一定要记得flush（），刷新一下，这个
 *          刷新表示将管道/通道当中剩余未输出的数据，强行输出完（清空管道）
 *
 *      注意：在java中只要以“stream”结尾的都是字节流，以“Reader/Writer”结尾的都是字符流
 *
 *
 *   4、java.io包下的需要掌握的流有16个：
 *
 *      //文件专属
 *      java.io.FileInputStream
 *      java.io.FileOutputStream
 *      java.io.FileReader
 *      java.io.FileWriter
 *
 *      转换流（将字节流转换为字符流）
 *      java.io.InputStreamReader
 *      java.io.OutputStreamWriter
 *
 *      缓冲流专属：
 *      java.io.BufferedInputStream
 *      java.io.BufferedOutputStream
 *      java.io.BufferReader
 *      java.io.BufferWriter
 *
 *      数据流专属：
 *      java.io.DataInputStream
 *      java.io.DataOutputStream
 *
 *      对象专属流：
 *      java.io.ObjectInputStream
 *      java.io.ObjectOutputStream
 *
 *      标准输出流：
 *      java.io.PrintWriter
 *      java.io.PrintStream
 *
 */
public class Note01 {
}

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

/**
 *java.io.FileInputStream
 *      1.文件字节输入流，万能的，任何类型的文件都可以采用这个流读取
 *      2.字节的方式，完成输入的操作，完成读的操作（硬盘--》内存）
 *
 *分析程序的缺点：
 *      一次读取一个字节Byte，这样内存和硬盘交互太频繁，时间/资源大都耗费在
 *      交互上面了，能不能一次读取多个字节呢？
 *          可以
 */


public class FileInputStreamTest01 {
    
    
    public static void main(String[] args) {
    
    

        /**
         * 创建文件字节流输入对象
         * 文件路径：H:\.temp.txt，（IDEA会自动把\转成\\，\代表转义字符）
         * 写成/也是可以的
         */
        FileInputStream fis = null;
        try {
    
    
            fis = new FileInputStream("H:\\temp.txt");
            int readData = 0;

           /* while( readData != -1) {
                System.out.println("读取文件的字符，字节流的方式，输出的应该是字节：" + readData);
                readData = fis.read();
            }*/

            while( (readData = fis.read())!= -1){
    
    
                System.out.println("读取文件的字符，字节流的方式，输出的应该是字节：" + readData);
            }
            System.out.println("读取到最后，再读取的话，返回值为 ：" + readData);

        } catch (FileNotFoundException e) {
    
    
            e.printStackTrace();
        } catch (IOException e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            /**
             * 在finally语句中确保流一定关闭，如果是空的null的话，没必要关闭
             * 把fis放到外边，如果放到try里的话，可能不会执行,因为可能不会执行，所以这里还要加个判断
             *  close方法也要抛出异常，
             */

            if (fis != null) {
    
    
                try {
    
    
                    fis.close();
                } catch (IOException e) {
    
    
                    e.printStackTrace();
                }
            }
        }


    }
}

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

/**
 *  int read(byte[] b) 读到 b.length从输入流到字节数组数据字节
 *  一次最多读取b.length个字节
 *  减少硬盘和内存的交互，提高程序的执行效率
 *
 *
 */
public class FileInputStreamTest02 {
    
    
    public FileInputStreamTest02() {
    
    
    }

    public static void main(String[] args) {
    
    

        FileInputStream ss = null;
        //IDEA默认的路径是当前工程的根下，不是模块下，也不是src下
        //若在src或者Test模块下，则要从模块开始找

        try {
    
    
            ss = new FileInputStream("temp.txt");
           // ss = new FileInputStream("Test\\src\\temp02");

            //这个方法的返回值是读取到的字节数量，不是字节本身
            byte[]  bytes = new byte[4];
            int shu = ss.read(bytes);//第一次读到了4个字节
            System.out.println(shu);
            System.out.println(new String(bytes));//将字符全部转换为字符串

            shu = ss.read(bytes); //第二次只能读取到2个字节(这里的文件有六个字符，相当于六个字节）
            System.out.println(shu);
            System.out.println(new String(bytes));//这里应该是efcd，ef没有被替换掉
            System.out.println(new String(bytes,0,shu));//不应该全部转换，读多少转多少

            shu = ss.read(bytes);
            System.out.println(shu);//返回值为-1


        } catch (FileNotFoundException e) {
    
    
            e.printStackTrace();
        } catch (IOException e) {
    
    
            e.printStackTrace();
        } finally {
    
    

            if (ss != null) {
    
    
                try {
    
    
                    ss.close();
                } catch (IOException e) {
    
    
                    e.printStackTrace();
                }
            }
        }



    }

}

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

/*
* 改造程序
* */
public class FileInputStreamTest03 {
    
    
    public static void main(String[] args) {
    
    
        FileInputStream aaa = null;
        try {
    
    
            aaa = new FileInputStream("temp.txt");
            byte[] i = new byte[4];
            int b;
            while( (b =  aaa.read(i)) != -1){
    
    
                System.out.print( new String(i,0,b));
            }
        } catch (FileNotFoundException e) {
    
    
            e.printStackTrace();
        } catch (IOException e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            if (aaa != null) {
    
    
                try {
    
    
                    aaa.close();
                } catch (IOException e) {
    
    
                    e.printStackTrace();
                }
            }
        }
    }
}

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

/**
 * int available()  返回没有读取的字节个数
 * long skip(long n)  跳过n个字节，或者说是从第n个字节(下标）开始读取
 */
public class FileInputStreamTest04 {
    
    
    public static void main(String[] args) {
    
    
        FileInputStream it = null;
        try {
    
    
            it = new FileInputStream("temp.txt");
            System.out.println("没有读取的字节个数：" + it.available());
            byte[] bytes = new byte[it.available()];
            System.out.println("  byte[] bytes = new byte[it.available()];");
            System.out.println("这种方式不太适合太大的文件，因为byte[]数组不能太大，大概六千多万吧，60M左右");
            int i ;
            it.skip(2);
            while((i = it.read() )!= -1){
    
    
                System.out.print(i + " ");
                /*
                  97 98 99 100 101 102 13 10 117 98 108 105 99
                  abcdef
                  ublic
                  一共13个元素，其中10是换行，13是回车
                */
            }
        } catch (FileNotFoundException e) {
    
    
            e.printStackTrace();
        } catch (IOException e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            if (it != null) {
    
    
                try {
    
    
                    it.close();
                } catch (IOException e) {
    
    
                    e.printStackTrace();
                }
            }
        }
    }
}