java的IO详解

Posted 2020-09-29

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类

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

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