Java基础--IO流

IO流理解

硬盘->内存 读（Reader),输入（Input),输入流（InputStream).
内存->硬盘 写（Writer),输出（Output),输出流（OutputStream).
这种分类是以内存为参照物得到的，往内存中去就是输入，从内存中出来就是输出。
还有一种流的分类是以读取数据方式进行分类。
a:按字节的方式读取数据 字节流 Stream(万能的，什么类型的数据都能够处理）
b:按照字符的方式读取数据。 字符流 Rader/Writer(只能够读取普通文本，能够使用记事本编辑的都是普通文本文件）。
以Stream结尾的都是字节流， 以Rader.Writer结尾的都是字符流。IO流里四个基本类，java.io.InputStream,java,io.OutputStream,java.io.Rader,java.io.Writer都是抽象类。

使用IO流的注意事项

所有的流都实现了java.io.Closeable接口的close()方法，都是可关闭的，用完流之后一定要记得关闭。如果没有关闭，可能会耗费内存。

所有的输出流都实现了java.io.Flushable接口的flush()方法，输出流在最终输出以后一定要flush(),刷新的作用就是清空IO流管道，如果没有flush(),可能会导致丢失数据。

FileInputStream

创建输入流并将硬盘中的文件内容输入到控制台上

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

public class FileInputStringTest01 {
    public static void main(String[] args) {
        FileInputStream fis=null;
        try {
            fis=new FileInputStream("E:\\test");
            int i;
            while(( i=fis.read())!=-1){

            System.out.println(i);}
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}

FileOutputStream

创建输出流并将内容输出到指定的文件处

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

public class FileOutputStreamTest01 {
    public static void main(String[] args) {
        FileOutputStream fos=null;
        try {
            fos=new FileOutputStream("test");
            byte[] b= {56,23,89,12,13,5,59,69,84};
            fos.write(97);
            fos.write(b);
            fos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

使用FileRader和FileWriter完成文件的拷贝

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileCopyTest {
    public static void main(String[] args) {
        FileReader in=null;
        FileWriter out=null;
        try {
            in=new FileReader("C:\\test\\test.txt");
            out=new FileWriter("E:\\test.txt",true);
            char[] c=new char[100];
            int readcount=0;
            while((readcount=in.read(c))!=-1){
                //System.out.println(new String(c,0,a));
                out.write(c,0,readcount);
            }
            out.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (out!= null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

BufferedRader

带有缓冲区的字符输入流，使用这个流的时候，不需要自定义char数组，自带缓冲。

当一个流的构造方法中需要传入一个流的时候，这个被传进来的流叫做：节点流，外部负责包装的这个流叫做：包装流/处理流。
对于包装流来说，只需要关闭最外层流就可以，里面的节点流会自动关闭。

import java.io.*;

public class BufferedResderTest01 {
    public static void main(String[] args) throws Exception {
        FileInputStream in= new FileInputStream("copy");

        InputStreamReader reader=new InputStreamReader(in);
        BufferedReader br=new BufferedReader(reader);
        String line=null;
        while((line=br.readLine())!=null){
            System.out.println(line);
        }

        br.close();

    }
}

DataOutputStream

可以将数据连同数据类型一并写入文件中（这个文件不是普通文本文件，打开之后是乱码的，只能够通过DataInputStream读取数据，并且还需要知道数据写入的顺序）

import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class DataOutputStreamTest {
    public static void main(String[] args) throws Exception {
        DataOutputStream data=new DataOutputStream(new FileOutputStream("C:\\Users\\Administrator\\Desktop\\data.txt"));
        byte b=12;
        int i=59;
        char c='k';
        data.write(b);
        data.write(i);
        data.writeChar(c);
        data.flush();
        data.close();

    }
}

PrintStream

标准输出流，可以使用在日志文件中
工具类

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;

public class LogUtil {
    public static void log(String str){
        try {
            PrintStream out=new PrintStream(new FileOutputStream("C:\\Users\\Administrator\\Desktop\\日志文件.txt",true));
            System.setOut(out);
            Date nowTime= new Date();
            SimpleDateFormat sb=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
            String startTime=sb.format(nowTime);
            System.out.println(startTime+":"+"发生了什么"+str);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

    }

}

测试类

public class LogTest {
    public static void main(String[] args) {
        LogUtil.log("明天，你好");
        LogUtil.log("更好的未来");
        LogUtil.log("未来与你一起度过");
    }
}

File类

File类不能完成文件的读和写。File对象代表：文件和目录路径名的抽象表达式。比如：C:/Drives, C:/home/readem/hello.txt都是File对象。
一个File对象有可能对应的是目录，也可能是文件。File只是一个路径名的抽象表达式。