在我们的Java语言当中，通常会有对文件进行读写，因此我们引入java的IO类来进行文件的读写。
一.字节流
下面是一个字节流的实例：
1 import java.io.*;
2 public class IO {
3 public static void main(String[] args) {
4 System.out.println("现在利用Java的一个类读取一个数据已经定义好的数据");
5 FileInputStream fis=null;//利用这个函数写进来的是字节型读入而非字符型
6 FileOutputStream fos=null;//这个类是我们引入的IO包当中的类了，首先进行对象和引用变量的创建，后面使用了抛出异常的操作是为了让机器避免发生出错。
7 try
8 {
9 fis=new FileInputStream("F:/我自己编写的代码库/JAVA/src/from.txt");//后面引入参数，说明读取的文件的绝对路径,绝对路径里面有中文都居然成功了。
10 fos =new FileOutputStream("F:/我自己编写的代码库/JAVA/src/fromto.txt");
11 byte buffer[]=new byte[100];//这里定义比特二进制的数组，证明了我们使用的是字节型流，而不是字符型，字符型利用了其它的定义
12 int temp=fis.read(buffer,0,100);//第一：输入进来的必须是比特数组流。第二：开始进行输入的比特序列号，如第一个，第二个。第三：输入流的比特长度
13 for (int i=0;i<=99;i++)
14 {
15 System.out.println(buffer[i]);
16 }
17 fos.write(buffer,0,temp);//temp变量reveal了读入数据所接收到的字节的长度，这个正好是read函数的返回值
18 }
19 catch (Exception e)
20 {
21 System.out.println(e);//在改变了我们的读取数组长度之后，读取成功了,之前在for循环的地方越界了
22 }
23 }
24
25 }
如果想读入一篇具有多个文字的文件的话，可以使用以下代码：
1 import java.io.*;
2
3 public class IO2 {
4 public static void main(String[] args) {
5 System.out.println("现在进行大型文件的读写");
6 FileInputStream fis1=null;
7 FileOutputStream fos1=null;
8 try
9 {
10 fis1=new FileInputStream("F:/我自己编写的代码库/JAVA/src/from1.txt");
11 fos1=new FileOutputStream("F:/我自己编写的代码库/JAVA/src/fromto1.txt");
12 byte buffer[]=new byte[1024];
13 while(true)
14 {
15 int temp=fis1.read(buffer,0,buffer.length);//read方法返回的是每次读取文件的字节数（比如a的asc码等）
16 if(temp==-1)//假设读到1024字节了，或者在1024字节之前就没有字节可读了，就会返回-1这个数值，然后跳出该循环，进行下一个循环
17 {
18 break;//这个程序在进行下一个循环的进入点在哪里呢？并没有提到，按道理来说是不会从刚刚已经读过的数据开始读，应该里面有一种自动读取的机制
19 }
20 fos1.write(buffer,0,buffer.length);
21 }
22 }
23 catch (Exception e)
24 {
25 System.out.println(e);
26 }
27 finally {
28 try{
29 fis1.close();
30 fos1.close();//在这里进行IO流的关闭，有开就有关，不然的话就会造成资源的浪费
31 System.out.println("读写完毕");
32 }
33 catch (Exception e)
34 {
35 System.out.println(e);
36 }
37 }
38 }}
注意前面创建对象的时候，我们创建的数组具有1024个字节，这是因为我们常常通过1024个字节进行读取，1024个字节正好等于了1个K,这样才可以对大文件当中的文字进行读写。最后我们在finally处，关闭了这个流，如果不关闭这个流的话，文件写入进去之后，是不会被保存下来的。
二.字符流
示例代码如下：
1 mport java.io.*;
2 public class IO3 {
3 public static void main(String[] args) {
4 System.out.println("现在开始字符流型程序的编写");
5 FileReader fis2=null;
6 FileWriter fos2=null;
7 try {
8 fis2=new FileReader("F:/我自己编写的代码库/JAVA/src/from2.txt");
9 fos2=new FileWriter("F:/我自己编写的代码库/JAVA/src/fromto2.txt");
10 char buffer[]=new char[100];//字符流和字节流的区别就是这里，引入的对象buffer是字符型定义的是字符而不是二进制了。以及前面创建的两个对象分别是： FileReader和FileWriter。这就是两个不同的区别，其它的完全相同。
11 int temp=fis2.read(buffer,0,buffer.length);
12 for(int i=0;i<=99;i++)
13 {
14 System.out.println(buffer[i]);
15 }
16 fos2.write(buffer,0,buffer.length);
17 System.out.println("完成输入以及输出");
18 }
19 catch (Exception e)
20 {
21 System.out.println(e);
22 }
23 finally {
24 try{
25 fis2.close();
26 fos2.close();//只有关闭了输入输出流之后，输入进去的字节才会保存，不关闭的话，就仅仅会停留在内存当中不会保存的。这就是需要关闭的原因了。
27 }
28 catch (Exception e)
29 {
30 System.out.println(e);
31 }
32 }
33 }
34 }
读取大型文件的代码只需要根据和字节流进行相似的处理就可以进行读取大型文件了。
三.处理流
实例代码如下：
1 import java.io.*;
2 public class IO4 {
3 public static void main(String[] args) {
4 System.out.println("现在开始处理流程序的书写\n");
5 FileReader a=null;
6 BufferedReader b=null;
7 try
8 {
9 String line=null;
10 a=new FileReader("F:/我自己编写的代码库/JAVA/src/from2.txt");
11 b=new BufferedReader(a);
12 while(true)
13 {
14 line=b.readLine();
15 if(line==null)
16 {
17 break;
18 }
19 System.out.println(line);//这里打印出了我们读取文件的内容，至于里面的内容为什么会像像这样打印，明天再来讲解。
20 }
21 }
22 catch (Exception e)
23 {
24 System.out.println(e);
25 }
26 }
27 }
上述代码还是比较容易理解的。
