Java学习笔记八

IO流:就是input/output输入/输出流。

一、字节流操作文件的便捷类:FileWriter和FileReader

import java.io.FileWriter;
import java.io.IOException;

public class FileWriterDemo {
    private static final String LINE_SEPARATOR=System.getProperty("line.separator");
    public static void main(String[] args) throws IOException{
        /*FileWriter类是Writer类的一个实现,用于向文件中写入字符
         * io操作可能会触发IOException.
         */
        demo();
    }

    //1、io操作应该处理IOException
    public static void demo() throws IOException {
        /*2、FileWriter类有多个构造函数,但是必须指定一个预期写入的目标文件,
         * 下面是字符串指定的文件,如果文件不存在则创建并写入内容;如果存在则先删除在创建并写入
         */
        FileWriter fw=new FileWriter("demo.txt");
        //3、write()是将内容写入到缓冲区中,而非硬盘中
        fw.write("asd"+LINE_SEPARATOR+"fgh"+LINE_SEPARATOR);
        //4、flush()是将缓冲区内容刷新到硬盘中
        fw.flush();
        //5、close()是两步操作:先刷新,在关闭
        fw.close();
        //如果想要在其后追加内容而非覆盖,则可以使用第二个boolean参数的构造方法
        FileWriter fw2=new FileWriter("demo.txt",true);
        fw2.write("这是追加的内容,使用了第二个boolean参数,没有将前面内容覆盖");
        fw2.close();
    }
}

import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo {

    public static void main(String[] args){
        readDemo();
        readDemo2();
    }

    public static void readDemo(){
        /*FileReader类是读取文件内容的Reader类的实现,特点
         * 1、继承了read(),但是每次只能读取一个字符,！！！范围在 0 到 65535 之间 (0x00-0xffff)
         * 2、读到结尾处,返回-1
         * 3、独处的数据是int类型而非char类型,可以进行强转
         */
        FileReader fr = null;
        try {
            fr = new FileReader("demo.txt");
            while (fr.read() != -1) {
                System.out.println((char)(fr.read()));
            }
        } catch (IOException e) {
            System.out.println(e.toString());
        }finally{
            if(fr!=null){
                try {
                    fr.close();
                } catch (IOException e2) {
                    throw new RuntimeException("关闭失败");
                }
            }
        }
    }

    public static void readDemo2() {
        /*第二种方式是先创建一个数组,然后将读取的字符存入其中,然后可以将字符数组转为字符串然后读取
         * 优点是一次可以读取多个,减少循环的次数
         * ！！！注意:每次都会读取数组长度的字符,并从0位开始存储,如果最后一次读取的字符<数组长度,
         * ！！！则只会覆盖前面的位置,之后的还是上一次读取的字符
         * 数组长度最好是1024的整数倍
         */
        FileReader fr = null;
        char[] buff=new char[1024];
        int len=0;
        try {
            fr = new FileReader("demo.txt");
            while ((len=fr.read(buff)) != -1) {
                System.out.println(new String(buff,0,len));
            }
        } catch (IOException e) {
            System.out.println(e.toString());
        }finally{
            if(fr!=null){
                try {
                    fr.close();
                } catch (Exception e2) {
                    throw new RuntimeException("关闭失败");
                }
            }
        }
    }
}

import java.io.FileWriter;
import java.io.IOException;

public class IOExceptionDemo {
    private static final String LINE_SEPARATOR=System.getProperty("line.separator");
    
    public static void main(String[] args){
        demo();
    }

    public static void demo() {
        /*流类异常的处理:指的是那些需要打开/关闭资源的类,如IO流和数据库操作,
         * 1、就算出现异常,也要关闭资源,所以需要使用finally语句将关闭操作包含
         * 2、由于{}是一个单独的作用域,而这个资源需要在try和finally中分别操作,
         *         ！！！所以需要将资源定义在try结构之前
         * 3、关闭操作在finally中也可能出错,所以也需要单独进行try操作
         * ！！！4、在关闭资源之前应该先判断是否打开该资源,因为可能打开时就失败了
         */
        FileWriter fw =null;
        try {
            fw = new FileWriter("demo.txt");

            fw.write("asd" + LINE_SEPARATOR + "fgh" + LINE_SEPARATOR);
        } catch (IOException e) {
            System.out.println(e.toString());
        }finally{
            if(fw!=null){
                try {
                    fw.close();
                } catch (Exception e2) {
                    throw new RuntimeException("关闭失败");
                }
            }
        }
    }
}

缓冲区BufferedWriter/BufferedReader是用来提高流操作的效率,将要读写的内如存放在内存中统一读取,减少IO操作次数

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class BufferDemo {
    public static void main(String[] args) throws IOException{
        //BufferedWriterDemo();
        BufferedReaderDemo();
    }

    public static void BufferedWriterDemo() throws IOException {
        //缓冲区必须封装一个字符流对象,其实内部就是用数组将字符流读取的内容先保存之后统一输出
        FileWriter fw=new FileWriter("bufferdemo.txt");
        BufferedWriter bw=new BufferedWriter(fw);
        bw.write("asdsf");
        bw.newLine();
        bw.write("这是新一行,使用缓冲区对象的方法换行");
        //这里使用缓冲区对象的close()其实就是使用字符流对象的该方法
        bw.close();
    }

    public static void BufferedReaderDemo() throws IOException {
        FileReader fr=new FileReader("bufferdemo.txt");
        //缓冲区内部其实就是一个数组,在这里体现的更明显
        BufferedReader br=new BufferedReader(fr);
        String line="";
        //BufferedReader类有一个特殊方法:就是读取一行内容,！！！读到最后返回null不是-1
        while((line=br.readLine())!=null){
            System.out.println(line);
        }
        br.close();
    }
}

下图是缓冲区实现的原理图

缓冲区对象还有一个子类LineNumberReader可以读取行号,原理类似

二、字节流操作文件的便捷类:FileOutputStream和FileInputStream,和字符流对象类似

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

public class ByteStreamDemo {

    public static void main(String[] args) {
        /*字节流演示:直接操作底层2进制,不管编码。和字符流的区别是
         * 1、使用的是字节数组,每次读取1个字节,如果字符超出1字节会被剪切
         * 2、不用刷新flush(),因为会直接输出,但是需要close()
         */
        FileOutputStreamDemo();
        FileInputStreamDemo();
    }

    public static void FileOutputStreamDemo() {
        FileOutputStream fos=null;
        try {
            fos = new FileOutputStream("ByteStream.txt");
            fos.write("abcdefg".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    throw new RuntimeException("关闭失败");
                }
            }
        }
    }

    public static void FileInputStreamDemo() {
        FileInputStream fis=null;
        try {
            fis = new FileInputStream("Bytestream.txt");
            /*FileInputStream对象available()可以直接访问文件的字节长度,所以比较简便的读取
             * ！！！注意:如果文件内容过程,例如一部电影,就不能使用这种方法,因为创建的数组过长
             * 但是该方法可以用在对文件的分段读取上
             */
            byte[] b=new byte[fis.available()];
            fis.read(b);
            System.out.println(new String(b));
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                
                fis.close();
            } catch (IOException e) {
                throw new RuntimeException("关闭失败");
            }
        }
    }

}

字节流对象也有对应的缓冲区对象:BufferedOutputStream和BufferedInputStream

三、标准输入:即通过键盘录入数据

import java.io.IOException;
import java.io.InputStream;

public class ReadKey {

    public static void main(String[] args) throws IOException {
        readkeydemo();
        readkeytest();
    }

    public static void readkeydemo() throws IOException {
        //1、通过System.in获取标准输入流对象
        InputStream in=System.in;
        /*2、通过read()来读取标准输入设备的输入数据,特点:
         *     1、！！！注意在读取完之前/抛出异常之前总是阻塞
         *     2、内容输入完使用Enter回车键结束,即使输入多个字符,该方法一次只能读取一个
         * ！！！注意:实际的输入内容包括回车符
(13),换行符
(10)
         */
        int context=in.read();
        System.out.println(context);
        context=in.read();
        System.out.println(context);
        context=in.read();
        System.out.println(context);
        context=in.read();
        System.out.println(context);
        //3、！！！标准的输入/出对象在关闭之后就不能再打开了,所以不要手动关闭,会在程序结束时自动关闭
        //in.close();
    }

    public static void readkeytest() throws IOException {
        /*读取用户输入信息,以over结束而不是以回车符结束
         * 1、既然不使用回车符结束就要将其避免,
         *         当读到
时跳过,下一个若是
,表示一行的结束
         * 2、在一行结束时应该先判断是否是over,如果是则跳出循环,
         */
        InputStream in=System.in;
        StringBuffer sb=new StringBuffer();
        int ch=0;
        /*下面循环中的操作就是多次读取一行信息,和字符流BufferedReader中的readLine()相似,
         * 只是需要将字节流转换为字符流才能操作,见InputStreamReaderDemo.java
         */
        while((ch=in.read())!=-1){
            if(ch=='
'){
                continue;
            }
            if(ch=='
'){
                String str=sb.toString();
                if(str.equals("over")){
                    break;
                }
                System.out.println(str);
                sb.delete(0, sb.length());
            }else{
                sb.append((char)(ch));
            }
        }
    }
}

四、字节流到字符流的转换InputStreamReader和OutputStreamWriter

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class StreamtoReaderWriter {
    public static void main(String[] args) throws IOException{
        /*字符流=字节流+编码,在Java中有对象可以实现字节流和字符流之间的转换
         * 1、字节流--》字符流：解码,使用InputStreamReader
         * 2、字符流--》字节流：编码,使用OutputStreamWriter
         */
        //readKeyTest();
        OutputStreamWriterDemo();
    }

    public static void readKeyTest() throws IOException {
        InputStream in=System.in;
        InputStreamReader isr=new InputStreamReader(in);
        BufferedReader br=new BufferedReader(isr);
        String str=null;
        while((str=br.readLine())!=null){
            if(str.equals("over")){
                break;
            }
            System.out.println(str);
        }
    }

    public static void OutputStreamWriterDemo() throws IOException {
        /*这个函数是将System.out用流的方式实现了,其实其本身就是一种流
         * 并且可以将一个输入流内容输出到指定位置,扩展了System.out只能输出到控制台的功能
         */
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw=new BufferedWriter(new FileWriter("a.txt"));
        String str=null;
        while((str=br.readLine())!=null){
            if(str.equals("over")){
                bw.close();
                break;
            }
            //System.out.println(str);
            bw.write(str);
            bw.newLine();
            bw.flush();
        }
    }
}

！！！注意:System.out对象就是PrintStream的一个实例,用于方便的输出各种类型的数据;而System.in就是InputStream的一个实例

！！！PrintStream对象的println()会在写入byte[]之后自动添加换行符(意味着结束此行),并自动刷新,例如out对象的println()

五、流对象该如何选择

文件系统操作:IO流操作是对数据的操作,但是不能操作文件本身,Java中将对文件/文件夹的操作封装为File对象