君子博学而日参省乎己 则知明而行无过矣

博客园 首页 新随笔 联系 订阅 管理
Java IO 基础

Java IO之File类

Java IO中所有的操作类跟接口都放在 java.io 包中，主要的类和接口有 File 、 InputStream 、 OutputStream 、 Reader 、 Writer 、 Serialzable 接口。

 

1、 File类

File类在整个 IO 中是独立的类，此类的主要功能是与平台无关的文件操作，如创建文件、删除文件等，在 File 类中提供了 public File(String pathname) ，在使用的时候需要指定一个具体的文件路径。

 

2、创建文件

Java代码  收藏代码
  1. package com.chenzehe.test.io;  
  2.   
  3. import java.io.File;  
  4.   
  5. import java.io.IOException;  
  6.   
  7. public class CreateFileDemo {  
  8.   
  9.     public static void main(String[] args) {  
  10.   
  11.         File file = new File("D://demo.txt");  
  12.   
  13.         try {  
  14.   
  15.             file.createNewFile();  
  16.   
  17.         } catch (IOException e) {  
  18.   
  19.             e.printStackTrace();  
  20.   
  21.         }  
  22.   
  23.     }  
  24.   
  25. }  
 

上面程序只是创建文件，如果需要使用具体的内容输出，则需要依靠IO 操作流。

 

 

3、删除文件

删除文件则使用File 对象的 delete() 方法，如：

Java代码  收藏代码
  1. package com.chenzehe.test.io;  
  2.   
  3. import java.io.File;  
  4.   
  5. public class DeleteFileDemo {  
  6.   
  7.     public static void main(String[] args) {  
  8.   
  9.         File file = new File("D://demo.txt");  
  10.   
  11.         //删除前先判断下文件是否存在  
  12.   
  13.         if (file.exists()) {  
  14.   
  15.             file.delete();  
  16.   
  17.         }  
  18.   
  19.     }  
  20.   
  21. }  
 

以上方法虽然完成了文件的操作，可是代码的兼容性有问题，在各个操作系统中文件的分隔符是不一样的，Windows 中的为 \ ， Linux 中的为 / ，在 File 类中提供提供了下面几种常量：

路径分隔符：public static final String pathSeparator ： ";"

分隔符：public static final separator ： "/" 或者 "\"

正常的Java 常量是以大写命名的，这里使用小写是由于历史的原因，以后的程序都采用 File.separator 常量进行分隔。 

 

 

4、判断路径是文件还是文件夹

在文件中可以使用以下方法判断是否是文件夹：public boolean isDirectory() ；

判断是否是文件：public boolean isFile() ；

 

 

5、列出目录中的内容

在File 类中提供了下面两个方法列出目录列表：

public String[] list()

public File[] listFiles()

 

 

6、创建目录

使用File 类的 mkdir() 方法，如：

 

Java代码  收藏代码
  1. package com.chenzehe.test.io;  
  2.   
  3. import java.io.File;  
  4.   
  5. public class MkdirDemo {  
  6.   
  7.     public static void main(String[] args) {  
  8.   
  9.         File file = new File("D:" + File.separator + "demo.txt");  
  10.   
  11.         file.mkdir();  
  12.   
  13.     }  
  14.   
  15. }  
 
 
Java IO之RandomAccessFile

    RandomAccessFile 类的主要功能是完成文件的随机读取操作，可以随机读取文件中指定位置的数据。如果要实现随机读取，则数据在文件中保存的长度必须要一致，否则无法实现该功能。

 

    RandomAccessFile实现了 DataOutput、 DataInput 、 Closeable 接口。

    RandomAccessFile的构造方法：

    public RandomAccessFile(File file,String mode) throes FileNotFoundException

 

    该构造方法需要接收一个File 的实例，和一个操作模式：

    只读模式：r

    只写模式：w

    读写模式：rw ，此模式如果文件不存在，则自动创建文件

 

 

1、 使用RandomAccessFile 进行写入操作

写入操作方法主要为从DataOutput 接口中实现的一系列 writeXxx() 方法，如：

 

Java代码  收藏代码
  1. package com.chenzehe.test.io;  
  2.   
  3. import java.io.File;  
  4.   
  5. import java.io.RandomAccessFile;  
  6.   
  7. public class RandomAccessFileDemo {  
  8.   
  9.     public static void main(String[] args) throws Exception {  
  10.   
  11.         File file = new File("D:" + File.separator + "demo.txt");  
  12.   
  13.         RandomAccessFile radomAccessFile = new RandomAccessFile(file, "rw");  
  14.   
  15.         // 写入第一条数据  
  16.   
  17.         String name = "first     ";  
  18.   
  19.         int age = 30;  
  20.   
  21.         radomAccessFile.writeBytes(name);  
  22.   
  23.         radomAccessFile.writeInt(age);  
  24.   
  25.         // 写入第二条数据  
  26.   
  27.         name = "second    ";  
  28.   
  29.         age = 31;  
  30.   
  31.         radomAccessFile.writeBytes(name);  
  32.   
  33.         radomAccessFile.writeInt(age);  
  34.   
  35.         // 写入第三条数据  
  36.   
  37.         name = "third     ";  
  38.   
  39.         age = 32;  
  40.   
  41.         radomAccessFile.writeBytes(name);  
  42.   
  43.         radomAccessFile.writeInt(age);  
  44.   
  45.         radomAccessFile.close();//关闭文件  
  46.   
  47.     }  
  48.   
  49. }  
 

2、 RandomAccessFile读操作

RandomAccessFile读操作是从实现 DataInput 接口方法而来，有一系列的 readXxx() 方法，可以读取各种类型的数据，有下面两种方法控制读取位置：

回到读取点：public void seek(long pos) throws IOException

跳过n 个字节数： public void skipBytes(int n) throws IOException

如：


Java代码  收藏代码
  1. package com.chenzehe.test.io;  
  2.   
  3. import java.io.File;  
  4.   
  5. import java.io.RandomAccessFile;  
  6.   
  7. public class RandomAccessFileDemo {  
  8.   
  9.     public static void main(String[] args) throws Exception {  
  10.   
  11.         File file = new File("D:" + File.separator + "demo.txt");  
  12.   
  13.         RandomAccessFile radomAccessFile = new RandomAccessFile(file, "rw");  
  14.   
  15.         byte[] b = new byte[10];  
  16.   
  17.         String name = null;  
  18.   
  19.         int age = 0;  
  20.   
  21.         radomAccessFile.skipBytes(14);// 跳过第一个人的信息  
  22.   
  23.         System.out.println("第二个人的信息为：");  
  24.   
  25.         for (int i = 0; i < 10; i++) {  
  26.   
  27.             b[i] = radomAccessFile.readByte();  
  28.   
  29.        }  
  30.   
  31.         age = radomAccessFile.readInt();// 读取数字  
  32.   
  33.         System.out.println("姓名：" + new String(b));  
  34.   
  35.         System.out.println("年龄：" + age);  
  36.   
  37.         radomAccessFile.seek(0);// 回到第一个人信息开始处  
  38.   
  39.         System.out.println("第一个人的信息为：");  
  40.   
  41.         for (int i = 0; i < 10; i++) {  
  42.   
  43.             b[i] = radomAccessFile.readByte();  
  44.   
  45.         }  
  46.   
  47.         age = radomAccessFile.readInt();// 读取数字  
  48.   
  49.         System.out.println("姓名：" + new String(b));  
  50.   
  51.         System.out.println("年龄：" + age);  
  52.   
  53.         radomAccessFile.skipBytes(14);// 此时文件读取指针在第一个人信息末，跳过第二个人信息  
  54.   
  55.         System.out.println("第三个人的信息为：");  
  56.   
  57.         for (int i = 0; i < 10; i++) {  
  58.   
  59.             b[i] = radomAccessFile.readByte();  
  60.   
  61.         }  
  62.   
  63.         age = radomAccessFile.readInt();// 读取数字  
  64.   
  65.         System.out.println("姓名：" + new String(b));  
  66.   
  67.         System.out.println("年龄：" + age);  
  68.   
  69.         radomAccessFile.close();// 关闭文件  
  70.   
  71.     }  
  72.   
  73. }  
 
 
Java IO之字节流和字符流

在整个 Java的 IO 中，流的操作分两种：

字节流：字节输出流OutputStream 和字节输入流 InputStream

字符流：一个字符等于两个字节，分为字符输出流Writer 和字符输入流 Reader

 

Java IO操作的基本步骤为：

一：使用File 找到一个文件

二：使用字节流或字符流的子类为OutputStream 、 IntputStream 、 Writer 、 Reader 进行实例化操作

三：进行读或写的操作

四：关闭资源：close() ；在所有流操作中，最终必须要关闭。

 

 

1、 字节输出流OutputStream

在java.io 包中 OutputStream 是字节输出流最大的父类：

public abstract class OutputStream extends Object implements Closeable,Flushable

 

此类是一个抽象类，依靠其子类进行文件操作，实现该接口的子类有：

ByteArrayOutputStream、 FileOutputStream 、 FilterOutputStream 、 ObjectOutputStream 、 OutputStream 、 PipedOutputStream 。

 

OutputStream提供了以下写入数据的方法：

写入全部字节数组：public void write(byte[] b) throws IOException

写入部分字节数组：public void write(byte[] b,int off,int len) throws IOException

写入一个数据：public abstract void write(int b) throws IOException

 

如果要完成文件的输出操作，则使用FileOutputStream 进行实例化工作：

Java代码  收藏代码
  1. package com.chenzehe.test.io;  
  2.   
  3. import java.io.File;  
  4.   
  5. import java.io.FileOutputStream;  
  6.   
  7. import java.io.OutputStream;  
  8.   
  9. public class FileOutputStreamDemo {  
  10.   
  11.     public static void main(String[] args) throws Exception {  
  12.   
  13.         File file = new File("D:" + File.separator + "demo.txt");  
  14.   
  15.         OutputStream outputStream = new FileOutputStream(file);  
  16.   
  17.         String str = "hello world";  
  18.   
  19.         byte[] b = str.getBytes();  
  20.   
  21.         outputStream.write(b);  
  22.   
  23.         outputStream.close();  
  24.   
  25.     }  
  26.   
  27. }  
  28.   
  29. 或：  
  30.   
  31. package com.chenzehe.test.io;  
  32.   
  33. import java.io.File;  
  34.   
  35. import java.io.FileOutputStream;  
  36.   
  37. import java.io.OutputStream;  
  38.   
  39. public class FileOutputStreamDemo {  
  40.   
  41.     public static void main(String[] args) throws Exception {  
  42.   
  43.         File file = new File("D:" + File.separator + "demo.txt");  
  44.   
  45.         OutputStream outputStream = new FileOutputStream(file);  
  46.   
  47.         String str = "hello world";  
  48.   
  49.         byte[] b = str.getBytes();  
  50.   
  51.         for (int i = 0; i < b.length; i++) {  
  52.   
  53.             outputStream.write(b[i]);  
  54.    
  55.         }  
  56.   
  57.         outputStream.close();  
  58.   
  59.      }  
  60.   
  61. }  
 

 

以上方式实现发现每次执行后都把上一次的内容替换掉，如果期望追加内容，则使用FileOutputStream 的下面构造方法：

public FileOutputStream(File file,boolean append) throws FileNotFoundException，如果将 append 设置为 true ，则表示追加内容。

 

 

2、 字节输入流InputStream

public abstract class InputStream extends Object implements Closeable

此类属于抽象类，需要使用其子类来实现文件的操作，实现它的子类有：

AudioInputStream、 ByteArrayInputStream 、 FileInputStream 、 FilterInputStream 、 InputStream 、 ObjectInputStream 、 PipedInputStream 、 SequenceInputStream 、 StringBufferInputStream ，如果是要实现对文件的操作，则使用 FileInputStream 类，该类有如下方法可读取数据：

将内容读取到字节数组之中：public int read(byte[] b) throws IOException 

每次只读一个数据：public abstract int read() throws IOException

Java代码  收藏代码
  1. package com.chenzehe.test.io;  
  2.   
  3. import java.io.File;  
  4.   
  5. import java.io.InputStream;  
  6.   
  7. import java.io.FileInputStream;  
  8.   
  9. public class FileInputStreamDemo {  
  10.   
  11.     public static void main(String[] args) throws Exception {  
  12.   
  13.         File file = new File("D:" + File.separator + "demo.txt");  
  14.   
  15.         InputStream inputStream = new FileInputStream(file);  
  16.   
  17.         byte[] b = new byte[1024];  
  18.   
  19.         inputStream.read(b);  
  20.   
  21.         System.out.println(new String(b));  
  22.   
  23.         inputStream.close();  
  24.   
  25.     }  
  26.   
  27. }  
 

 

以上是一种比较常见的读取形式，上面给b 开辟了 1024 个字节码的空间，但是实际字符并达不到 1024 长度，所以在输出后面输出很多空格，以上的代码有一个缺点，会受到开辟空间的限制，如果想动态的开辟数组空间，则可以根据文件的大小来决定，采用 read() 方法一个个数据的读取。

 

Java代码  收藏代码
  1. package com.chenzehe.test.io;  
  2.   
  3. import java.io.File;  
  4.   
  5. import java.io.FileInputStream;  
  6.   
  7. import java.io.InputStream;  
  8.   
  9. public class FileInputStreamDemo {  
  10.   
  11.     public static void main(String[] args) throws Exception {  
  12.   
  13.         File file = new File("D:" + File.separator + "demo.txt");  
  14.   
  15.         InputStream inputStream = new FileInputStream(file);  
  16.   
  17.         byte[] b = new byte[(int) file.length()];  
  18.   
  19.         inputStream.read(b);  
  20.   
  21.         System.out.println(new String(b));  
  22.   
  23.         inputStream.close();  
  24.   
  25.     }  
  26.   
  27. }  
 

 

3、 字符输出流Writer

Writer类是在 IO 包中操作字符的最大父类，主要功能是完成字符流的输出， Writer 类的定义如下：

public abstract class Writer extends Object implements Appendable,Closeable,Flushable

与OutputStream 一样， Writer 类也发球抽象类，如果要进行文件操作，则使用 FileWriter,

写入操作为：public void writer(String str) throws IOException ，

可追加的写入操作：public void writer(String str,boolean append) throws IOException

如：

 

 

Java代码  收藏代码
  1. package com.chenzehe.test.io;  
  2. import java.io.File;  
  3. import java.io.FileWriter;  
  4. import java.io.Writer;  
  5. public class FileWriterDemo {  
  6.     public static void main(String[] args) throws Exception {  
  7.         File file = new File("D:" + File.separator + "demo.txt");  
  8.         Writer writer = new FileWriter(file);  
  9.         String str = "hello world";  
  10.         writer.write(str);  
  11.         writer.close();  
  12.     }  
  13. }  
 

 

4、 字符输入流Reader

字符输入流与字节输入流不同的地方是使用的是char 数组， Reader 的定义为：

public abstract class Reader extends Object implements Readable,Closeable， Reader 是一个抽象类，可以使用 FileReader 类进行文件操作，读取方法有：

读取一组字符：public int read(char[] cbuf) throws IOException

读取一个字符：public int read() throws IOException

如：

Java代码  收藏代码
  1. package com.chenzehe.test.io;  
  2. import java.io.File;  
  3. import java.io.FileReader;  
  4. import java.io.Reader;  
  5. public class FileReaderDemo {  
  6.     public static void main(String[] args) throws Exception {  
  7.         File file = new File("D:" + File.separator + "demo.txt");  
  8.         Reader reader = new FileReader(file);  
  9.         char[] c = new char[(int)file.length()];  
  10.         reader.read(c);  
  11.         System.out.println(new String(c));  
  12.         reader.close();  
  13.     }  
  14. }  
 

使用字符流也可以一个个的输出：

 

Java代码  收藏代码
  1. package com.chenzehe.test.io;  
  2. import java.io.File;  
  3. import java.io.FileReader;  
  4. import java.io.Reader;  
  5. public class FileReaderDemo {  
  6.     public static void main(String[] args) throws Exception {  
  7.         File file = new File("D:" + File.separator + "demo.txt");  
  8.         Reader reader = new FileReader(file);  
  9.         char[] c = new char[(int) file.length()];  
  10.         for (int i = 0; i < c.length; i++) {  
  11.             c[i] = (char) reader.read();  
  12.         }  
  13.         System.out.println(new String(c));  
  14.         reader.close();  
  15.     }  
  16. }  
 

5、 字节流和字符流的区别

下面字节流操作文件代码没有关闭操作，内容照常被写到文件中：

Java代码  收藏代码
  1. package com.chenzehe.test.io;  
  2. import java.io.File;  
  3. import java.io.FileOutputStream;  
  4. import java.io.OutputStream;  
  5. public class FileOutputStreamDemo {  
  6.     public static void main(String[] args) throws Exception {  
  7.         File file = new File("D:" + File.separator + "demo.txt");  
  8.         OutputStream outputStream = new FileOutputStream(file);  
  9.         String str = "hello world";  
  10.         byte[] b = str.getBytes();  
  11.         outputStream.write(b);  
  12.         //outputStream.close();  
  13.     }  
  14. }  
 

 

下面字符流操作文件代码没有关闭操作，但是内容并没有写到文件中：

Java代码  收藏代码
  1. package com.chenzehe.test.io;  
  2. import java.io.File;  
  3. import java.io.FileWriter;  
  4. import java.io.Writer;  
  5. public class FileWriterDemo {  
  6.     public static void main(String[] args) throws Exception {  
  7.         File file = new File("D:" + File.separator + "demo.txt");  
  8.         Writer writer = new FileWriter(file);  
  9.         String str = "hello world";  
  10.         writer.write(str);  
  11.         //writer.close();  
  12.     }  
  13. }  
 

但是使用了flush() 方法后，即使没有关闭操作，内容就被写到文件中了：

Java代码  收藏代码
  1. package com.chenzehe.test.io;  
  2. import java.io.File;  
  3. import java.io.FileWriter;  
  4. import java.io.Writer;  
  5. public class FileWriterDemo {  
  6.     public static void main(String[] args) throws Exception {  
  7.         File file = new File("D:" + File.separator + "demo.txt");  
  8.         Writer writer = new FileWriter(file);  
  9.         String str = "hello world";  
  10.         writer.write(str);  
  11.         // writer.close();  
  12.         writer.flush();// 刷新缓冲区  
  13.     }  
  14. }  
 

之前代码只有close() 方法而没有 flush() 方法也能写进文件是因为 close() 方法会强制刷新缓冲区，可以得出下面结论：

字节操作流直接操作文件，不使用缓冲区

字符操作流是操作缓冲区，然后再通过缓冲区操作文件

综合来说，在传输或者硬盘上的数据都是以字节的形式保存的，所以字节流的操作比较多，但是在操作中文的时候，字符流用的比较多。

 

Java IO之内存流

    FileInputStream和 FileOutputStream 操作的目标是文件，假设有一些临时的信息需要通过 IO 操作，如果将这些临时信息保存到文件中不太合理，因为操作的最后还需要把文件给删除掉，所以 IO 操作中就提供了内存操作流，它的操作目标是内存。

 

使用ByteArrayOutputStream 和 ByteArrayInputStream 来完成内存操作流：

ByteArrayOutputStream：用于内存向程序输出，其基本作用就像 OutputStream 一样，一个个的数据读取；

ByteArrayInputStream：用于从程序向内存写入，其构造方法为：

public ByteArrayInputStream(bute[] buf);

 

 

以下代码为使用内存操作流完成小写字母到大写字母的转换：

Java代码  收藏代码
  1. package com.chenzehe.test.io;  
  2. import java.io.ByteArrayInputStream;  
  3. import java.io.ByteArrayOutputStream;  
  4.   
  5. public class ByteArrayStreamDemo {  
  6.     public static void main(String[] args) {  
  7.         String helloworld = "helloworld";  
  8.         ByteArrayInputStream bis = new ByteArrayInputStream(  
  9.                 helloworld.getBytes());  
  10.         ByteArrayOutputStream bos = new ByteArrayOutputStream();  
  11.         int temp = 0;  
  12.         while ((temp = bis.read()) != -1) {  
  13.             char c = (char) temp;  
  14.             bos.write(Character.toUpperCase(c));  
  15.         }  
  16.         System.out.println(bos.toString());  
  17.     }  
  18. }  

 

Java IO之管道流

    管理流是两个线程间通信使用的，由 PipedOutputStream和 PipedInputStream 两个类来完成，这两个类在使用的时候基本上和 OutputStream 和 InputStream 一样，唯一的区别就是在于连接管道的操作上： public void connect(PipedInputStream snk)  throws IOException

   下面代码进行管道流的操作：

 

Java代码  收藏代码
  1. package com.chenzehe.test.io;  
  2. import java.io.PipedInputStream;  
  3. import java.io.PipedOutputStream;  
  4.   
  5. // 发送数据的类  
  6. class Send implements Runnable {  
  7.     private PipedOutputStream output = null;  
  8.     public Send() {  
  9.         this.output = new PipedOutputStream();  
  10.     }  
  11.     public void run() {  
  12.         String helloworld = "hello world!";  
  13.         try {  
  14.             this.output.write(helloworld.getBytes());  
  15.             this.output.close();  
  16.         } catch (Exception e) {  
  17.   
  18.         }  
  19.     }  
  20.     public PipedOutputStream getOutput() {  
  21.         return output;  
  22.     }  
  23.     public void setOutput(PipedOutputStream output) {  
  24.         this.output = output;  
  25.     }  
  26. }  
  27.   
  28. // 接收数据的类  
  29. class Receive implements Runnable {  
  30.     private PipedInputStream input = null;  
  31.     public Receive() {  
  32.         this.input = new PipedInputStream();  
  33.     }  
  34.     public void run() {  
  35.         byte[] b = new byte[1024];  
  36.         int len = 0;  
  37.         try {  
  38.             len = this.input.read(b);  
  39.             this.input.close();  
  40.         } catch (Exception e) {  
  41.   
  42.         }  
  43.         System.out.println(new String(b, 0, len));  
  44.     }  
  45.     public PipedInputStream getInput() {  
  46.         return input;  
  47.     }  
  48.     public void setInput(PipedInputStream input) {  
  49.         this.input = input;  
  50.     }  
  51. }  
  52.   
  53. public class PipedStreamDemo {  
  54.     public static void main(String[] args) throws Exception {  
  55.         Send send = new Send();  
  56.         Receive receive = new Receive();  
  57.         send.getOutput().connect(receive.getInput());// 进行管道连接  
  58.         new Thread(send).start();  
  59.         new Thread(receive).start();  
  60.     }  
  61. }  

 

Java IO之打印流

    使用 OutputStream可以完成数据的输出功能，但是如果输出一个 float 类型的数据并不好输出，它的输出功能并不强大，要想使用更强大的输出功能，则可以使用打印流。打印流有两种：一种是 PrintStream ，一种是 PrintWriter 。

 

PrintStream的定义：

public class PrintStream extends FilterOutputStream implements Appendable,Closeable{

}

 

PrintStream是 OutputStream 的子类

 

PrintStream的构造方法：

public PrintStream(OutputStream out){

}

 

实际上PrintStream 属于装饰，也就是说根据实例化 PrintStream 类的对象不同，输出的功能也不同。

下面代码为使用PrintStream 向文件输出：

 

Java代码  收藏代码
  1. package com.chenzehe.test.io;  
  2. import java.io.File;  
  3. import java.io.FileOutputStream;  
  4. import java.io.PrintStream;  
  5.   
  6. public class PrintStreamDemo {  
  7.     public static void main(String[] args) throws Exception {  
  8.         File file = new File("D:" + File.separator + "demo.txt");  
  9.         PrintStream out = new PrintStream(new FileOutputStream(file));  
  10.         out.print("hello ");  
  11.         out.println("world!");  
  12.         out.println(100);  
  13.     }  
  14. }  
posted on 2013-07-23 01:54  刺猬的温驯  阅读(217)  评论(0)  编辑  收藏  举报