java基础之十六->IO

一、File类

什么是文件：文件可以认为是相关记录或放在一起的数据的集合
文件一般存在哪里：硬盘、光盘等等
File提供了对当前文件系统中文件的部分操作

示例

package com.msbline.basic.io;
import java.io.File;
import java.io.IOException;
public class FileDemo {
    public static void main(String[] args) {
        File file = new File("src/abc.txt");
        try {
            file.createNewFile();
            //判断文件的属性
            file.canExecute();
            file.canRead();
            file.canWrite();
            System.out.println(file.exists());
            //获取文件的名称
            System.out.println(file.getName());
            //获取绝对路径
            System.out.println(file.getAbsolutePath());
            //获取文件的父文件名称，如果文件的路径中只包含文件名称，则显示空
            System.out.println(file.getParent());
            //返回文件绝对路径的规范
            System.out.println(file.getCanonicalPath());
            //返回操作系统的文件分隔符
            System.out.println(File.separator);
            System.out.println("-----------------------------");
            File file1 = new File("D:/");
            //无论当前文件是否存在，只要给定具体的路径，都可以返回相应的路径名称
            System.out.println(file1.getAbsolutePath());
            System.out.println(file1.isDirectory());
            System.out.println(file1.isFile());
            String[] list = file1.list();
            for(String str : list){
                System.out.println(str);
            }
            System.out.println("------------------");
            File[] files = file1.listFiles();
            for(File file2 : files){
                System.out.println(file2);
            }
            System.out.println("------------------");
            File[] files1 = File.listRoots();
            for(File file2 : files1){
                System.out.println(file2);
            }
            System.out.println("------------------");
            File file2 = new File("F:/a/b/c");
            file2.mkdir();
            file2.mkdirs();
            File file3 = new File("F:/");
            File[] files2 = file3.listFiles();
            printFileName(files2);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void printFileName(File[] files){
        if(files != null){
            for(File file : files){
                if(file.isDirectory()){
                    printFileName(file.listFiles());
                }else {
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
    }
}

二、IO流的原理及概念

流的基本概念

流表示从一个文件将数据发送到另一个文件，包含一个流向的问题，最终需要选择一个参照物，当前程序作为参照物

从一个文件中读取数据到程序中叫做输入流
从程序输出数据到另一个文件叫做输出流

三、IO流的分类

1、处理流和节点流

处理流示例

package com.msbline.basic.io;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class InputStreamReaderDemo {
    public static void main(String[] args) {
        File file = new File("src/abc.txt");
        FileInputStream inputStream = null;
        InputStreamReader inputStreamReader = null;
        try{
            inputStream = new FileInputStream(file);
            inputStreamReader = new InputStreamReader(inputStream);
            char[] chars = new char[1024];
            int length = inputStreamReader.read(chars);
            System.out.println(new String(chars,0,length));
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                inputStreamReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

package com.msbline.basic.io;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
public class OutputStreamWriterDemo {
    public static void main(String[] args) {
        File file = new File("src/abc.txt");
        OutputStreamWriter outputStreamWriter = null;
        FileOutputStream fileOutputStream = null;
        try{
            fileOutputStream = new FileOutputStream(file);
            outputStreamWriter = new OutputStreamWriter(fileOutputStream);
            outputStreamWriter.write(99);
            outputStreamWriter.write("马士兵教育");
            outputStreamWriter.write("abcdefg",0,5);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //处理流的关闭顺序，一般按照创建的顺序的逆序来关闭
 try {
                outputStreamWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2、字节流和字符流

所有文件的储存是都是字节（byte）的储存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再储存这些字节到磁盘。在读取文件（特别是文本文件）时，也是一个字节一个字节地读取以形成字节序列
字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串；
字节流提供了处理任何类型的IO操作的功能，但它不能直接处理Unicode字符，而字符流就可以
字节流是最基本的，所有的InputStrem和OutputStream的子类都是,主要用在处理二进制数据，它是按字节来处理的
但实际中很多的数据是文本，
又提出了字符流的概念，
它是按虚拟机的encode来处理，也就是要进行字符集的转化
这两个之间通过 InputStreamReader,OutputStreamWriter来关联，
实际上是通过byte[]和String来关联
在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的

示例

InputStream

package com.msbline.basic.io;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class StreamDemo1 {
    public static void main(String[] args) throws IOException {
        InputStream inputStream = null;
        try {
            //添加缓冲区的方式进行读取，每次会将数据添加到缓冲区中，
 //当缓冲区满了之后，一次读取，而不是每次读取一个字节
 inputStream = new FileInputStream("src/abc.txt");
            byte[] bytes = new byte[1024];
            int length = 0;
            while ((length = inputStream.read(bytes))!=-1){
                System.out.println(new String(bytes,0,length));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            inputStream.close();
        }
    }
}

OutputStream

package com.msbline.basic.io;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class OutputStreamDemo {
    public static void main(String[] args) throws IOException {
        File file = new File("src/aaa.txt");
        OutputStream outputStream = null;
        try{
            outputStream  = new FileOutputStream(file);
            outputStream.write(99);
            outputStream.write("rnmashibing".getBytes());
            outputStream.write(1);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            outputStream.close();
        }
    }
}

Reader

package com.msbline.basic.io;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class ReaderDemo {
    public static void main(String[] args) {
        Reader fileReader = null;
        try {
            fileReader = new FileReader("src/abc.txt");
            int read = fileReader.read();
            System.out.println((char)read);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

writer

package com.msbline.basic.io;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class WriterDemo {
    public static void main(String[] args) {
        File file = new File("src/writer.txt");
        Writer writer = null;
        try{
            writer = new FileWriter(file);
            writer.write("www.mashibing.com");
            writer.write("马士兵教育");
            writer.flush();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

四、IO流类的体系