Java中的I/O操作

最新推荐文章于 2022-05-15 19:38:22 发布

羊之草叶

最新推荐文章于 2022-05-15 19:38:22 发布

阅读量608

点赞数

分类专栏： Java

Java 专栏收录该内容

13 篇文章

订阅专栏

1. 操作文件的类--File

File是主要是进行文件的创建、删除等，但是不对文件的内容进行操作。

File类的主要方法和常量：

public static final String pathSeparator : 路径间的分隔符

public static final String separator:路径名称的分隔符

public File(String pathName) : 创建File对象

public boolean createNewFile throwsIOException : 创建新文件

public boolea delete(): 删除文件

public boolean exists(): 判断文件是否存在

public boolean isDirectory():判断给定的文件是否是一个目录

public long length():返回文件的大小

public String[] list():列出指定目录文件的全部内容，只是名称

public File[] listFiles():列出指定目录文件的全部内容，会列出全部路径

public boolean mkdir():创建一个目录

public boolean renameTo(File dest):为已有的文件重新命名

示例：

import java.io.File;
import java.io.IOException;

public class FileDemos {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
        String path = "d:" + File.separator + "fileDemos.txt";
        File f = new File(path);
        try {
	        f.createNewFile(); //当且仅当不存在具有此抽象路径名指定的名称的文件时，原子性的创建一个新的文件。
        } catch (IOException e) {
	        // TODO Auto-generated catch block
	        e.printStackTrace();
        }
        
        if(f.exists()) {
        	f.delete();//删除文件
        }
        
        File dir = new File("d:" + File.separator + "fileDemos_dir");
        f.mkdir();//创建由抽象路径指定的目录
        
        File f2 = new File("d:" + File.separator + "JavaSmp");
        if(f.exists() && f2.isDirectory()) {
        	String[] lists = f2.list();
        	for(int i = 0; i < lists.length;i++){
        	    System.out.println(lists[i]);
        	}
        	System.out.println("-----------------------");
        	File[] listFiles = f2.listFiles();
        	for(int i = 0; i < listFiles.length;i++)
        	System.out.println(listFiles[i]);
        }
	}
}

2. 字节流与字符流

OutputStream与InputStream

输入流：用于为程序输入数据，从文件（外部存储）中读取；

输出流：用于输出程序中的数据，保存到文件（外部存储）中。

程序中所有的数据都是以流的方式进行传输或保存的，程序中需要数据时要使用输入流从文件中读取数据，而当程序需要将一些数据保存起来时，则使用输出流将数据保存到文件中。java.io中流的操作主要有字节流、字符流两大类，两类都有输入输出操作，字节流是OutputStream/InputStream系列，主要操作byte类型的数据；字符流是Writer/Reader系列。

outputStream/InputStream

package com.yxf.outputstream;

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

public class OutputStreamDemos {
	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
       File f = new File("d:" + File.separator + "output_stream.txt");
       //OutputStream out = new FileOutputStream(f); 
       OutputStream out = new FileOutputStream(f, true);//表示在文件尾追加内容
       String str = "\r\nHello"; //加上\r\n表示换行
       byte[] b = str.getBytes(); //将字符串变为byte[]数组
       out.write(b); //主意文件不存在时会自动创建
       out.close();
	}
}

package com.yxf.inputstream;

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

public class InputStreamDemos {

	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		File f = new File("d:" + File.separator + "output_stream.txt");
	    InputStream input = new FileInputStream(f);
	    /**方法一
	     ****************************
	    byte[] b = new byte[(int)f.length()];
	    input.read(b);//这里b数组中是文件f的全部内容
	    *****************************
	    */
	    
	    /**方法二
	     **************************
	     */
	    int len = 0;
	    byte[] b = new byte[1024];
	    int temp = -1;
	    while((temp = input.read()) != -1){//根据接收到的内容是否是-1来判断是否已经到文件尾
	    	b[len] = (byte)temp;
	    	len++;
	    }
	    input.read(b);
	    //end
	    input.close();
	    System.out.println("Result:");
	    System.out.println(new String(b));
	}
}

Writer/Reader

字符流可以直接对字符进行操作，而无需转换为byte类型。

字符流使用了缓冲区，而字节流没有使用。

package com.yxf.filewriter;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class FileWriterDemos {

	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		File f = new File("d:" + File.separator + "file_writer.txt");
		Writer out = null;
		out = new FileWriter(f);
		
		String str = "Hello world";
		out.write(str);
		//out.close();//关闭字符流时会强制的将缓冲区的内容输出，如果注释掉后，则缓冲区中的内容是无法输出的，因此建议手动刷新
		out.flush();
	}

}

下面用一个实例来加深理解。

将一个文件拷贝到另外一个地方。

package com.yxf.copy;

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

public class CopyDemos {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
        if(args.length != 2){
        	System.out.println("Invalid argument, usage: srcPath desPath");
        	System.exit(1);
        }
        System.out.println(args[0] + ", " + args[1]);
        File srcFile = new File(args[0]);
        File desFile = new File(args[1]);
        if(!srcFile.exists()){
        	System.out.println("Src doesn't exist.");
        	System.exit(1);
        }
        
        InputStream input = null;
        OutputStream output = null;
        try {
	        input = new FileInputStream(srcFile);
        } catch (FileNotFoundException e) {
	        // TODO Auto-generated catch block
	        e.printStackTrace();
        }
        
        try {
	        output = new FileOutputStream(desFile);
        } catch (FileNotFoundException e) {
	        // TODO Auto-generated catch block
	        e.printStackTrace();
        }
        
        if(input != null && output != null){
        	int temp = 0;
        	try {
	            while((temp = input.read()) != -1){
	            	output.write(temp);
	            }
	            System.out.println("Copy success");
            } catch (IOException e) {
	            // TODO Auto-generated catch block
	            e.printStackTrace();
            }
        	
        	try {
	            input.close();
	            output.close();
            } catch (IOException e) {
	            // TODO Auto-generated catch block
	            e.printStackTrace();
            }
        	
        }
	}

}

3. 转换流--outputStreamWriter与InputStreamReader

outputStreamWriter：继承自Writer，将输出的字符类变为字节流，即将一个字符流的输出对象转化为字节流输出对象；

构造方法：

public OutputStreamWriter(OutputStreamout);

InputStreamReader：继承自Reader，将输入的字节流变为字符流，即将一个字节流的输入对象变为字符流的输入对象。

package com.yxf.outputStreamWriterdemos;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.Writer;

public class OutputStreamWriterDemos {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
        File f = new File("d:" + File.separator + "outputSteamWriter.txt");
        
        Writer out = null;
        try {
	        out = new OutputStreamWriter(new FileOutputStream(f));
	        try {
	            out.write("Hello world");
	            out.close();
            } catch (IOException e) {
	            // TODO Auto-generated catch block
	            e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
	        // TODO Auto-generated catch block
	        e.printStackTrace();
        }
	}
}

package com.yxf.inputstreamreaderdemos;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;

import javax.imageio.stream.FileImageInputStream;

public class InputStreamReaderDemos {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
	     File f = new File("d:" + File.separator + "outputSteamWriter.txt");
	     Reader reader = null;
	     try {
	        reader = new InputStreamReader(new FileInputStream(f));
	        char[] c = new char[1024];
	        int len = reader.read(c);
	        reader.close();
	        System.out.println(new String(c,0,len));
        } catch (FileNotFoundException e) {
	        // TODO Auto-generated catch block
	        e.printStackTrace();
        } catch (IOException e) {
	        // TODO Auto-generated catch block
	        e.printStackTrace();
        }
	}

}

4. BufferReader类

BufferReader用于从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。

为什么要使用BufferReader?

Reader 所作的每个读取请求都会导致对基础字符或字节流进行相应的读取请求，如果没有缓冲，则每次调用 read() 或 readLine() 都会导致从文件中读取字节，并将其转换为字符后返回，而这是极其低效的。因此，建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和 InputStreamReader）。例如，

BufferedReader in1 = new BufferedReader(newFileReader("foo.in"));

BufferedReaderin2= new BufferedReader(new InputStreamReader(new FileInputStream(“foo.in”)));

常用方法：

public BufferReader(Reader in);

public String readLine() throws IOException

5. DataOutputStream与DataInputStream

DataOutputStream(OutputStream out): 创建一个新的数据输出流，允许应用程序以适当方式将基本 Java 数据类型写入输出流中。

public void write(int b) throws IOException

将指定字节（参数 b 的八个低位）写入基础输出流。如果没有抛出异常，则计数器 written 增加 1。

public void write(byte[] b, //数据

int off, //数据中的起始偏移量

int len)//要写入的字节数

throws IOException

将指定字节数组中从偏移量 off 开始的 len 个字节写入基础输出流。如果没有抛出异常，则计数器 written 增加 len。

public void flush() throws IOException

清空此数据输出流。这迫使所有缓冲的输出字节被写出到流中。

public final void writeBoolean(boolean v)throws IOException

将一个 boolean 值以 1-byte 值形式写入基础输出流。值 true 以值 (byte)1 的形式被写出；值 false 以值 (byte)0 的形式被写出。如果没有抛出异常，则计数器 written 增加 1。

public final void writeByte(int v) throwsIOException

将一个 byte 值以 1-byte 值形式写出到基础输出流中。如果没有抛出异常，则计数器 written 增加 1。

public final void writeInt(int v) throwsIOException

将一个 int 值以 4-byte 值形式写入基础输出流中，先写入高字节。如果没有抛出异常，则计数器 written 增加 4。

package com.yxf.dataoutputstreamdemos;

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

public class DataOutputStreamDemos {

	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		File file = new File("d:" + File.separator + "order.txt");
        DataOutputStream out = null;
        
        out = new DataOutputStream(new FileOutputStream(file));
        
        String[] names = {"衬衣","裤子","皮鞋"};
        int[] nums = {1,2,3};
        float[] prices = {(float) 98.3,(float) 30.3,(float) 50.5};
        
        for(int i = 0; i < names.length;i++){
        	out.writeChars(names[i]);
        	out.writeChar('\t');
        	out.writeInt(nums[i]);
        	out.writeChar('\t');
        	out.writeFloat(prices[i]);
        	out.writeChar('\n');
        }
        out.close();
	}
}

package com.yxf.datainputstream;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class DataInputStreamDemos {

	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		File file = new File("d:" + File.separator + "order.txt");
        DataInputStream in = null;
        
        in = new DataInputStream(new FileInputStream(file));
        String name = null;
        float price = 0.0f;
        int num = 0;
        char[] temp = null;
        char c = 0;
        int len = 0;
        
        try{
        	while(true){
        		temp = new char[200];
        		len = 0;
        		
        		while((c = in.readChar()) != '\t'){
        			temp[len] = c;
        			len++;
        		}
        		name = new String(temp,0,len);
        		num = in.readInt();
        		in.readChar();
        		price = in.readFloat();
        		in.readChar();
        		System.out.println("name: " + name + "num: " + num + ", price = " + price);
        	}
        }catch(Exception e){
        }
        
        in.close();
	}

}

输出结果：

name: 衬衣num: 1, price = 98.3
name: 裤子num: 2, price = 30.3
name: 皮鞋num: 3, price = 50.5