java的IO详解

1）操作文件的类File

在整个IO包中，File是唯一与文件本身有关的类。

使用File类进行文件的创建和删除等操作。

在编写路径时使用符合本地操作系统的分隔符，要实现这样的功能，

需要使用File中的两个常量：pathSeparator和separator。

在程序开发中，往往会使用Windows开发环境，因为Windows操作系统中

支持的开发工具较多，而在程序发布时往往直接在Linux或其他操作系统上部署，

所以若不使用File.separator，就会出现问题。

public class FileDemo01 {
    public static void main(String[] args) {
        //File f = new File("D:\test.txt");//创建一个新的File实例
        File f = new File("D:"+File.separator+"test.txt");
        try{
            f.createNewFile();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}

File还可实现：删除文件、判断文件是否存在、创建文件夹、

列出指定目录的全部文件、判断一个给定的路径是否是目录。

2）RandomAccessFile类

File类只是针对文件本身进行操作，而如果要对文件内容进行操作，则可以使用RandomAccessFile类。

随机读写流可以实现对文件内容的操作，但是一般情况下操作文件内容会使用字节或字符流。

3）字节流和字符流

在程序中所有与数据都是以流的方式进行传输和保存的，程序需要数据时要使用输入流读取数据；

而当程序需要将一些数据保存起来时，就要使用输出流。

在字节流中输出数据主要使用OutputStream类完成，输入使用InputStream完成。

在字符流中输出主要使用Wrier类完成，输入主要使用Reader类完成。

IO操作步骤：使用File类打开一个文件；通过字节流或字符流的子类指定输出位置；

进行读/写操作；关闭输入/输出。

字节流

1）字节的概念

位（bit）：一个二进制数

Hello World!!!中有十四个字节。

字节（byte）：8个二进制构成一个字节

public class GetByteDemo {
    public static void main(String[] args) {
        String s = "3,He";
        //byte b1 = '!';
        byte b[] = s.getBytes();
        //System.out.println(b1);
        //System.out.println(b.length);
        //System.out.println(new String(b));
        for(int i=0;i<b.length;i++){
            System.out.println(b[i]);        //输出：51 44 72 101
            //System.out.println(((char)b[i]));   //输出：3 , H e    
        }
    }
}

2）OutputStream是整个IO包中字节输出流的最大父类。

OutputStream类是一个抽象类，如果要使用此类，首先必须通过子类实例化对象。

FileOutputStream是Outputstream的子类，通过向上转型后，可以为Outputstream实例化。

顺序：OutputStream(抽象类)

FileOutputStream（非抽象类）

public class OutputStreamDemo {
    public static void main(String[] args) throws Exception {
        
        //使用File类找到一个文件；若文件不存在，则会自动创建
        File f = new File("D:"+File.separator+"test.txt");
        
        //通过子类实例化父类对象
        OutputStream out = new FileOutputStream(f);
        
        //进行写操作
        String str = "Hello";
        byte b[] = str.getBytes();
        out.write(b);
        
        //关闭输出流
        out.close();
    }
}

通过FileOutputStream向文件中追加内容。

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

public class FileOutputStreamDemo {

    public static void main(String[] args) throws IOException {
        File f = new File("d:" + File.separator + "test.txt");
        OutputStream out = new FileOutputStream(f, true);
        String str = "
 Hello World!!!";    //换行符
        byte b[] = str.getBytes();
        for(int i=0;i<b.length;i++){
            out.write(b[i]);
        }
        out.close();
    }
}

3）字节输入流InputStream

过程类似与字节输出流，但是注意使用；length方法去掉字符串结尾的空格。

顺序：InputStream(抽象类)

FileInputStream（非抽象类）

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

public class InputStreamDemo01 {

    public static void main(String[] args) throws IOException {
        File f  =new File("d:" + File.separator + "test.txt");
        InputStream input = null;
        input = new FileInputStream(f);
        byte b[] = new byte[1024];
        int len = input.read(b);    //去掉空格
        input.close();
        System.out.print(new String(b,0,len));
    }
}

如果根据文件的大小开辟空间，则是：

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

public class InputStreamDemo01 {

    public static void main(String[] args) throws IOException {
        File f  =new File("d:" + File.separator + "test.txt");
        InputStream input = null;
        input = new FileInputStream(f);
        byte b[] = new byte[(int)f.length()];
        input.read(b);    //去掉空格
        input.close();
        System.out.print(new String(b));
    }
}

如果不知道输入的内容有多大，则只能通过判断是否读到文件末尾的方式来读取文件：

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

public class InputStreamDemo01 {

    public static void main(String[] args) throws IOException {
        File f  =new File("d:" + File.separator + "test.txt");
        InputStream input = null;
        input = new FileInputStream(f);
        
        int len = 0;
        byte b[] = new byte[1024];
        int temp = 0;
        while((temp = input.read()) != -1){
            //如果temp值不是-1，则说明没有读完
            b[len] = (byte) temp;
            len++;
        }

        input.close();
        System.out.print(new String(b,0,len));
    }
}

字符流

1）字符输出流Writer

Write类也是一个抽象类，如果要使用此类，则肯定要使用其子类。

如果向文件中写入内容，应该使用子类FileWriter。

可以直接输出字符串，不用将字符串变为byte数组之后再输出。

可以使用FileWriter追加文件内容。

顺序：Writer(抽象类)

FileWriter(非抽象类)

向文件中写入数据

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) throws IOException {
        File f = new File("d:" + File.separator + "test.txt");
        Writer out = new FileWriter(f);
        String str = "Hello World!!!";
        out.write(str);
        out.close();
    }
}

整个程序与Outputstream的操作流程基本没区别，唯一不同的是，可以直接输出字符串，而不用将字符串为byte数组之后再输出。

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) throws IOException {
        File f = new File("d:" + File.separator + "test.txt");
        Writer out = new FileWriter(f);
        String str = "Hello World!!!";
        out.write(str);
        out.close();
    }
}

使用FileWriter追加文件的内容

package cn.itcast.writer.demo;

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) throws IOException {
        File f = new File("d:" + File.separator + "test.txt");
        Writer out = new FileWriter(f, true);    //true表示追加
        String str = "Hello World!!!";
        out.write(str);
        out.close();
    }
}

2）字符输入流Reader

Reader类也是抽象了，可以直接使用FileReader子类从文件中读取内容。

import java.io.File;
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) throws IOException {
        File f = new File("d:" + File.separator + "test.txt");
        Reader reader = new FileReader(f);
        int len = 0;
        char c[] =new char[1024];
        int temp = 0;
        while((temp = reader.read()) !=-1){
            c[len] = (char) temp;
            len++;
        }
        reader.close();
        System.out.print(new String(c,0,len));
    }

}

字节流和字符流的区别：

字节流在操作时本身不会到缓冲区（内存）。是文件本身直接操作的，而字符流在操作时

使用了内存，通过缓冲区在操作文件。

操作字节流时，即使不关闭输出流，输出内容也会写入文件，

但在操作字符流时，只有关闭字符流之后，输出内容才会写入文件。

   

使用缓冲区，可以提高系统频繁操作某一内容情况下的性能。

所有的文件在硬盘或在传输时都是以字节的方式进行的，包括图片等都是按字节进行存储的，

而自负是只有在内存中才会形成，所以在开发中，字节流使用较为广泛。

System类对IO的支持

1）System.out

System.out是PrintStream的对象，在PrintStream中定义了一系列的print()和println()方法.

而PrintStream又是OutputStream的子类，所以可以直接利用此对象向屏幕上输出信息。

2）System.err

表示错误信息的输出。

3）System.in

是一个键盘的输入流，是InputStream类型的对象。

但是，在使用System.in的时候，指定大小会出现空间限制，不指定大小则输入中文时会产生乱码。

如果可以一次性的从内存中读出数据，这样所有数据只读了一次，就不会产生乱码，而且也不受长度的限制，

而这些操作可以通过BufferedReader类实现。

4）输入输出重定向

通过System类可以改变System.in的输入流来源以及System.out和System.err两个输出流的输出位置。

例如，可以把错误信息直接保存到文件中。

5）BufferedReader类

通过此类可以一次性从 缓冲区中将内容全部读取出来。

6）键盘输入的标准格式

public class BufferedReaderDemo01 {
    public static void main(String[] args) {
        BufferedReader buf = null;
        buf = new BufferedReader(new InputStreamReader(System.in));
        String str = null;
        System.out.println("请输入内容：");
        try{
            str = buf.readLine();
        }catch(IOException e){
            e.printStackTrace();
        }
        System.out.println("输入内容为："+str);
    }
}

Scanner类

专门的输入数据类，此类不知可以完成输入数据的操作，也可以对输入的数据进行验证。

可以实现：基本的数据输入、日期格式的数据输入、从文件中得到数据。