Java学习与复习笔记--字节输入流&字符输入流

字节输入流_InputStream类和FileInputStream：

/*
* java.io.InputStream：字节输入流
* 这个抽象类是表示输入字节流的所有类的超类。
* 定义了所有子类共性的方法：
* int read() ：从输入流读取数据的下一个字节。
* int read(byte[] b) ：从输入流读取一些字节数，并将它们存储到缓冲区 b 。
* void close() ：关闭此输入流并释放与流相关联的任何系统资源
* java.io.FileInputStream extends InputStream
* FileInputStream：文件字节输入流
* 作用：把硬盘文件中的数据读取到内存中使用
* 构造方法：
* FileInputStream(String name)
* FileInputStream(File file)
* 参数：读取文件的数据源
* String name：文件的路径
* File file：文件
* 构造方法的作用：
* 1.会创建一个FileInputStream对象
* 2.会把FileInputStream对象指定构造方法中要读取的文件
*
* 读取数据的原理（硬盘-》内存）：
*   java程序--》JVM--》OS--》OS读取数据的方法--》读取文件
* 字节输入流的使用步骤（重点）：
*   1.创建FileInputStream对象，构造方法中绑定要读取的数据源
*   2.使用FileInputStream对象中的read，读取文件
*   3.流使用完释放资源。
*
 */
public class Demo04InputStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream("FileAndIO\\a.txt");
        //读取文件中的一个字节并返回，读取到文件末尾会返回-1
        /*int len = fis.read();
        System.out.println(len);//97 a
        len = fis.read();
        System.out.println(len);//98 b
        len = fis.read();
        System.out.println(len);//99 c
        len = fis.read();
        System.out.println(len);//-1，末尾了*/
        /*
        * 以上读取文件是一个重复的过程，所以可以使用循环优化
        * 不知道文件中有多少字节，使用while循环
        * while循环结束条件，读取到-1的时候结束
        * 布尔表达式(len=fis.read())!=-1
        * 1.fis.read():读取一个字节
        * 2.len=fis.read():把读取到的字节赋值给变量len
        * 3.(len=fis.read())!=-1：判断变量len是否不等于-1
        * */
        int len=0;
        while((len=fis.read())!=-1){
            System.out.print((char)len);//abc
        }
        fis.close();
    }
}

字节输入流一次读取多个字节的方法：

/*
* 字节流一次读取多个字节的方法：
* int read(byte[] b) ：从输入流读取一些字节数，并将它们存储到缓冲区 b 。
* String类的构造方法：
* String(byte[] bytes)：把字节数组转换为字符串
* String(byte[] bytes, int offset, int length)：把字节数组的一部分转换为字符串,offset:数组开始的索引，length：转换的字节个数
* 数组：缓冲作用，存储每次读取到的多个字节，数组的长度一般定义为1024（1kb）或者1024的整数倍
* 方法返回值：int：每次读取的有效字节个数
* new byte[5]:一次读取五个字节
 * */
public class Demo05InputStream {
    public static void main(String[] args) throws IOException {
        //1.创建FileInputStream对象，构造方法中绑定要读取的数据源
        FileInputStream fis=new FileInputStream("FileAndIO\\b.txt");
        /*byte[] bytes=new byte[2];
        int len = fis.read(bytes);//len：读取的有效字节个数
        System.out.println(len);//2
        System.out.println(Arrays.toString(bytes));//[65, 66]
        System.out.println(new String(bytes));//AB
        len = fis.read(bytes);
        System.out.println(len);//2
        System.out.println(Arrays.toString(bytes));//[67, 68]
        System.out.println(new String(bytes));//CD
        len = fis.read(bytes);
        System.out.println(len);//2
        System.out.println(Arrays.toString(bytes));
        System.out.println(new String(bytes));//EB*/
        //以上读取时一个重复的过程，可以使用循环优化
        //不知道文件中有多少字节，所以使用while循环
        //while循环结束的条件，读取到-1结束
        byte[] bytes=new byte[1024];//存储读取到的多个字节
        int len=0;
        while((len=fis.read(bytes))!=-1){
            //String(byte[] bytes, int offset, int length)：把字节数组的一部分转换为字符串,offset:数组开始的索引，length：转换的字节个数
            System.out.println(new String(bytes,0,13));
        }
        fis.close();
    }
}

练习_文件复制：

/*
* 文件复制练习：一读一写
* 明确：我们要复制的数据源
*       数据的目的地
* 文件复制的步骤：
* 1.创建字节输入流对象，构造方法中绑定要读取的数据源
* 2.创建一个字节输出流对象，构造方法中绑定要写入的目的地
* 3.使用字节输入流对象中的方法read读取文件
* 4.使用字节输出流中的方法write，把读取到的文件写入到目的地文件夹中
* 5.释放资源
* */
public class Demo06FileCopy {
    public static void main(String[] args) throws IOException {
        long s=System.currentTimeMillis();
        FileInputStream fis=new FileInputStream("FileAndIO\\b.txt");
        FileOutputStream fos=new FileOutputStream("d:\\c.txt");
        /*//一次读取一个字节写入一个字节的方式
        int len=0;
        while((len=fis.read())!=-1){
            fos.write(len);
        }*/
        //使用数组缓冲读取多个字节写入多个字节的方式
        byte[] bytes=new byte[1024];
        int len=0;//每次读取的有效字节个数
        while((len=fis.read(bytes))!=-1){
            fos.write(bytes,0,len);
        }
        //释放资源，先关闭写的，后关闭读的；如果写完了，肯定读完了
        fos.close();
        fis.close();
        long e=System.currentTimeMillis();
        System.out.println("复制文件共耗时："+(e-s)+"毫秒");
    }
}

使用字节流读取中文的问题：

/*
* 使用字节流读取中文文件
* 1个中文：
*   GBK：占用2个字节
*   UTF-8：占用3个字节
*   */

字符输入流_Reader类&FileRead：

/*
* java.io.Reader:字符输入流，是字符输入流的最顶层的父类，定义了一些共性的成员方法，是一个抽象类
* 共性的成员方法：
* int read() 读取单个字符并返回。
* int read(char[] cbuf) ：一次读取多个字符，将字符读入数组
* void close() ：释放资源
* java.io.FileReader extends InputStreamReader extends Reader
* FileReader：文件字符输入流
* 作用：把硬盘文件中的数据以字符的方式读取到内存中
* 构造方法：
* FileReader(String fileName)
* FileReader(File file)
* 参数：读取文件的数据源
* String name：文件的路径
* File file：文件
* FileReader构造方法的作用：
* 1.创建FileReader对象
* 2.会把FileReader对象指向所要读取的对象
* 字符输入流的使用步骤(重点)：
* 1.创建FileReader对象，构造方法中绑定要读取的数据源
* 2.使用FileReader对象中的方法read读取文件
* 3.释放资源*/
public class Demo01Reader {
    public static void main(String[] args) throws IOException {
        //1.创建FileReader对象，构造方法中绑定要读取的数据源
        FileReader fr=new FileReader("FileAndIO\\c.txt");
        //2.使用FileReader对象中的方法read读取文件
        /*int len=0;
        while((len=fr.read())!=-1){
            System.out.print((char)len);//你好abc123***&&&
            }*/
        //int read(char[] cbuf) ：一次读取多个字符，将字符读入数组
        char[] cs=new char[1024];//存储读取到的多个字符
        int len=0;//记录的是每次读取的有效字符个数
        while((len=fr.read(cs))!=-1){
            /*
            * String类的构造方法：
            * String(char[] value)：把字符数组转换为字符串
            * String(char[] value, int offset, int count)：把字符数组的一部分转换为字符串 offset数组的开始索引，count转换的个数
             * */
            System.out.println(new String(cs,0,len));
        }
        fr.close();
    }
}