1）操作文件的类File
在整个IO包中，File是唯一与文件本身有关的类。
使用File类进行文件的创建和删除等操作。
在编写路径时使用符合本地操作系统的分隔符，要实现这样的功能，
需要使用File中的两个常量：pathSeparator和separator。
在程序开发中，往往会使用Windows开发环境，因为Windows操作系统中
支持的开发工具较多，而在程序发布时往往直接在Linux或其他操作系统上部署，
所以若不使用File.separator，就会出现问题。
1 public class FileDemo01 {
2 public static void main(String[] args) {
3 //File f = new File("D:\\test.txt");//创建一个新的File实例
4 File f = new File("D:"+File.separator+"test.txt");
5 try{
6 f.createNewFile();
7 }catch(IOException e){
8 e.printStackTrace();
9 }
10 }
11 }
File还可实现：删除文件、判断文件是否存在、创建文件夹、
列出指定目录的全部文件、判断一个给定的路径是否是目录。
2）RandomAccessFile类
File类只是针对文件本身进行操作，而如果要对文件内容进行操作，则可以使用RandomAccessFile类。
随机读写流可以实现对文件内容的操作，但是一般情况下操作文件内容会使用字节或字符流。
3）字节流和字符流
在程序中所有与数据都是以流的方式进行传输和保存的，程序需要数据时要使用输入流读取数据；
而当程序需要将一些数据保存起来时，就要使用输出流。
在字节流中输出数据主要使用OutputStream类完成，输入使用InputStream完成。
在字符流中输出主要使用Wrier类完成，输入主要使用Reader类完成。
IO操作步骤：使用File类打开一个文件；通过字节流或字符流的子类指定输出位置；
进行读/写操作；关闭输入/输出。
字节流
1）字节的概念
位（bit）：一个二进制数
Hello World!!!中有十四个字节。
字节（byte）：8个二进制构成一个字节
1 public class GetByteDemo {
2 public static void main(String[] args) {
3 String s = "3,He";
4 //byte b1 = ‘!‘;
5 byte b[] = s.getBytes();
6 //System.out.println(b1);
7 //System.out.println(b.length);
8 //System.out.println(new String(b));
9 for(int i=0;i<b.length;i++){
10 System.out.println(b[i]); //输出：51 44 72 101
11 //System.out.println(((char)b[i])); //输出：3 , H e
12 }
13 }
14 }
2）OutputStream是整个IO包中字节输出流的最大父类。
OutputStream类是一个抽象类，如果要使用此类，首先必须通过子类实例化对象。
FileOutputStream是Outputstream的子类，通过向上转型后，可以为Outputstream实例化。
顺序：OutputStream(抽象类)
FileOutputStream（非抽象类）
1 public class OutputStreamDemo {
2 public static void main(String[] args) throws Exception {
3
4 //使用File类找到一个文件；若文件不存在，则会自动创建
5 File f = new File("D:"+File.separator+"test.txt");
6
7 //通过子类实例化父类对象
8 OutputStream out = new FileOutputStream(f);
9
10 //进行写操作
11 String str = "Hello";
12 byte b[] = str.getBytes();
13 out.write(b);
14
15 //关闭输出流
16 out.close();
17 }
18 }
通过FileOutputStream向文件中追加内容。
1 import java.io.File;
2 import java.io.FileNotFoundException;
3 import java.io.FileOutputStream;
4 import java.io.IOException;
5 import java.io.OutputStream;
6
7 public class FileOutputStreamDemo {
8
9 public static void main(String[] args) throws IOException {
10 File f = new File("d:" + File.separator + "test.txt");
11 OutputStream out = new FileOutputStream(f, true);
12 String str = "\r\n Hello World!!!"; //换行符
13 byte b[] = str.getBytes();
14 for(int i=0;i<b.length;i++){
15 out.write(b[i]);
16 }
17 out.close();
18 }
19 }
3）字节输入流InputStream
过程类似与字节输出流，但是注意使用；length方法去掉字符串结尾的空格。
顺序：InputStream(抽象类)
FileInputStream（非抽象类）
1 import java.io.File;
2 import java.io.FileInputStream;
3 import java.io.FileNotFoundException;
4 import java.io.IOException;
5 import java.io.InputStream;
6
7 public class InputStreamDemo01 {
8
9 public static void main(String[] args) throws IOException {
10 File f =new File("d:" + File.separator + "test.txt");
11 InputStream input = null;
12 input = new FileInputStream(f);
13 byte b[] = new byte[1024];
14 int len = input.read(b); //去掉空格
15 input.close();
16 System.out.print(new String(b,0,len));
17 }
18 }
如果根据文件的大小开辟空间，则是：
1 import java.io.File;
2 import java.io.FileInputStream;
3 import java.io.FileNotFoundException;
4 import java.io.IOException;
5 import java.io.InputStream;
6
7 public class InputStreamDemo01 {
8
9 public static void main(String[] args) throws IOException {
10 File f =new File("d:" + File.separator + "test.txt");
11 InputStream input = null;
12 input = new FileInputStream(f);
13 byte b[] = new byte[(int)f.length()];
14 input.read(b); //去掉空格
15 input.close();
16 System.out.print(new String(b));
17 }
18 }
如果不知道输入的内容有多大，则只能通过判断是否读到文件末尾的方式来读取文件：
1 import java.io.File;
2 import java.io.FileInputStream;
3 import java.io.FileNotFoundException;
4 import java.io.IOException;
5 import java.io.InputStream;
6
7 public class InputStreamDemo01 {
8
9 public static void main(String[] args) throws IOException {
10 File f =new File("d:" + File.separator + "test.txt");
11 InputStream input = null;
12 input = new FileInputStream(f);
13
14 int len = 0;
15 byte b[] = new byte[1024];
16 int temp = 0;
17 while((temp = input.read()) != -1){
18 //如果temp值不是-1，则说明没有读完
19 b[len] = (byte) temp;
20 len++;
21 }
22
23 input.close();
24 System.out.print(new String(b,0,len));
25 }
26 }
字符流
1）字符输出流Writer
Write类也是一个抽象类，如果要使用此类，则肯定要使用其子类。
如果向文件中写入内容，应该使用子类FileWriter。
可以直接输出字符串，不用将字符串变为byte数组之后再输出。
可以使用FileWriter追加文件内容。
顺序：Writer(抽象类)
FileWriter(非抽象类)
向文件中写入数据
1 import java.io.File;
2 import java.io.FileWriter;
3 import java.io.IOException;
4 import java.io.Writer;
5
6 public class WriterDemo {
7
8 public static void main(String[] args) throws IOException {
9 File f = new File("d:" + File.separator + "test.txt");
10 Writer out = new FileWriter(f);
11 String str = "Hello World!!!";
12 out.write(str);
13 out.close();
14 }
15 }
整个程序与Outputstream的操作流程基本没区别，唯一不同的是，可以直接输出字符串，而不用将字符串为byte数组之后再输出。
1 import java.io.File;
2 import java.io.FileWriter;
3 import java.io.IOException;
4 import java.io.Writer;
5
6 public class WriterDemo {
7
8 public static void main(String[] args) throws IOException {
9 File f = new File("d:" + File.separator + "test.txt");
10 Writer out = new FileWriter(f);
11 String str = "Hello World!!!";
12 out.write(str);
13 out.close();
14 }
15 }
使用FileWriter追加文件的内容
1 package cn.itcast.writer.demo;
2
3 import java.io.File;
4 import java.io.FileWriter;
5 import java.io.IOException;
6 import java.io.Writer;
7
8 public class WriterDemo {
9
10 public static void main(String[] args) throws IOException {
11 File f = new File("d:" + File.separator + "test.txt");
12 Writer out = new FileWriter(f, true); //true表示追加
13 String str = "Hello World!!!";
14 out.write(str);
15 out.close();
16 }
17 }
2）字符输入流Reader
Reader类也是抽象了，可以直接使用FileReader子类从文件中读取内容。
1 import java.io.File;
2 import java.io.FileNotFoundException;
3 import java.io.FileReader;
4 import java.io.IOException;
5 import java.io.Reader;
6
7 public class ReaderDemo {
8
9 public static void main(String[] args) throws IOException {
10 File f = new File("d:" + File.separator + "test.txt");
11 Reader reader = new FileReader(f);
12 int len = 0;
13 char c[] =new char[1024];
14 int temp = 0;
15 while((temp = reader.read()) !=-1){
16 c[len] = (char) temp;
17 len++;
18 }
19 reader.close();
20 System.out.print(new String(c,0,len));
21 }
22
23 }
字节流和字符流的区别：
字节流在操作时本身不会到缓冲区（内存）。是文件本身直接操作的，而字符流在操作时
使用了内存，通过缓冲区在操作文件。
操作字节流时，即使不关闭输出流，输出内容也会写入文件，
但在操作字符流时，只有关闭字符流之后，输出内容才会写入文件。
使用缓冲区，可以提高系统频繁操作某一内容情况下的性能。
所有的文件在硬盘或在传输时都是以字节的方式进行的，包括图片等都是按字节进行存储的，
而自负是只有在内存中才会形成，所以在开发中，字节流使用较为广泛。
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）键盘输入的标准格式
1 public class BufferedReaderDemo01 {
2 public static void main(String[] args) {
3 BufferedReader buf = null;
4 buf = new BufferedReader(new InputStreamReader(System.in));
5 String str = null;
6 System.out.println("请输入内容：");
7 try{
8 str = buf.readLine();
9 }catch(IOException e){
10 e.printStackTrace();
11 }
12 System.out.println("输入内容为："+str);
13 }
14 }
Scanner类
专门的输入数据类，此类不知可以完成输入数据的操作，也可以对输入的数据进行验证。
可以实现：基本的数据输入、日期格式的数据输入、从文件中得到数据。