Java对字节流和字符流的运用

字节流（FileInputStream,FileOutputStream）

/**
 * 字节流对文件的读取操作
 */
package exercise6;

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

public class fileDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//创建文件的对象（已存在的文件）
		File f=new File("D:\\aa.txt");
		
		System.out.println("文件路径"+f.getAbsolutePath());
		System.out.println("文件大小"+f.length());
		
		//创建一个新的文件
		File f1=new File("D:\\new.txt");
		if(!f1.exists()) {
			try {
				f1.createNewFile();
				System.out.println("创建文件成功！");
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		//创建文件夹
		File f2=new File("D:\\newFile2");
		if(!f2.isDirectory()) {
			f2.mkdirs();
			System.out.println("创建文件夹成功！");

	   }
		
		//读取文件信息
		File f3=new File("D:\\aa.txt");
		//File没有读写的能力，所以需要FileInpute
		FileInputStream ff=null;
		try {
			ff = new FileInputStream(f3);
			byte bytes[]=new byte[1024];
			int n=0;//中间变量，记录实际读入的字节总数
			//循环读取
			while((n=ff.read(bytes))!=-1) {
				//read方法：read(byte[] b),最多读取b.length个字节，返回值是实际读入缓冲区的字节总数，
				//当没有更多的数据时。返回-1
				
				//把字节转换成string
				String str=new String(bytes,0,n);//表示从0~读入的总字节数
				System.out.println(str);
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			//关闭文件流，必须放在这里。
			try {
				ff.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		//写入信息到文件
		File f4=new File("D:\\new.txt");
		FileOutputStream fos=null;
		
		try {
			fos=new FileOutputStream(f4);
			
			String str="Hello Word!\r\n";//末尾转义字符，代表换行
			fos.write(str.getBytes());
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			try {
				fos.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		//文件复制（先将文件读取到缓存，再写入到某个文件）
		//输入流
		FileInputStream fin=null;
		//输出流
		FileOutputStream fot=null;
		
		try {
			fin=new FileInputStream("D:\\aa.txt");
			fot=new FileOutputStream("D:\\newFile\\aa.txt");
			
			byte bytes[]=new byte[1024];//缓存
			int n=0;//中间变量，记录实际读入的字节总数
			//循环读取
			while((n=fin.read(bytes))!=-1) {
				//从缓存中写入到指定文件
				fot.write(bytes,0,n);//输出的同时，转换成String。
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			try {
				fin.close();
				fot.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	
		}
		
	}
}

其中循环读取文件时候需要用到read（）方法，读到底时返回-1.

字符流（FileReader，FileWriter）

package exercise6;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 字符流对文件的操作
 *
 */

public class fileDemo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//文件读取对象
		FileReader fr=null;
		//写入到文件
		FileWriter fw=null;
		
		try {
			fr=new FileReader("D:\\aa.txt");
			fw=new FileWriter("D:\\newFile2\\aa.txt");
			
			//缓存
			char buff[]=new char[1024];
			int n=0;//中间变量，代表实际读取的字节总数
			while((n=fr.read(buff))!=-1) {
				
				fw.write(buff,0,n);//转换成String，从0-n个
			}
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			try {
				fr.close();
				fw.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}

	}

}

字符缓存流（BufferedReader，BufferedWriter）

  字节流是一个一个字节读取，字符流是一个一个字符读取。当文件很大时，都不够效率。字符缓存流可以一次读取一行，而且可以直接对String操作，大大提高了效率，在写写法上和之前的代码有所不同。

package exercise6;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 缓冲字符流读取操作
 *
 */

public class fileDemo3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BufferedReader br=null;
		BufferedWriter bw=null;

		try {
			//先创建FileReader对象找到文件，才能再放入BufferedReader
			FileReader fr=new FileReader("D:\\aa.txt");
			br=new BufferedReader(fr);
			
			//先创建FileWriter对象，再放入BufferedReader
			FileWriter fw=new FileWriter("D:\\newFile\\buff.txt");
			bw=new BufferedWriter(fw);
			
			//循环读取文件
			String s="";//中间变量
			while((s=br.readLine())!=null) {//readLine不包括任何终止符，如果到达末尾，则返回null
				//直接操作输出
				bw.write(s+"\r\n");//转义字符添加换行
			}
				
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			try {
				br.close();
				bw.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}

	}

}

记事本

  这里结合java的事件处理、图像技术、文件处理可以做一个小的应用，笔记本支持读取和保存文件。代码如下

package Notepad;


import java.io.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;

/**
 * 记事本
 * @author 光羽住一
 *
 */

public class NotePad extends JFrame implements ActionListener{
	
	//定义需要的组件
	JTextArea jta=null;
	JMenuBar jmb=null;//菜单条（一排区域，可添加菜单项）
	JMenu jml=null;//菜单项（例如：file，edit，source...）
	JMenuItem jit1,jit2=null;//具体的选项(比如file这个菜单下的选项)
	
	public NotePad() {
		jta=new JTextArea();
		jmb=new JMenuBar();
		
		jml=new JMenu("文件");
		jml.setMnemonic('F');//设置助记符
		
		jit1=new JMenuItem("打开");
		jit2=new JMenuItem("另存为");
		//注册监听
		jit1.addActionListener(this);
		jit2.addActionListener(this);
		
		//将菜单条加入窗体
		this.setJMenuBar(jmb);
		//将菜单项加入到菜单条
		jmb.add(jml);
		//将菜单加入到菜单项
		jml.add(jit1);
		jml.add(jit2);
		
		this.add(jta);
		this.setLocation(200, 200);
		this.setSize(400, 300);
		this.setTitle("NotePad");
		this.setDefaultCloseOperation(this.EXIT_ON_CLOSE);
		this.setResizable(false);
		this.setVisible(true);
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		NotePad note=new NotePad();
	}

	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO Auto-generated method stub
		//判断用户点击了哪个按钮，并作出响应
		if(e.getSource()==jit1) {
			//System.out.println("open");
			
			//文件选择组件
			JFileChooser jch=new JFileChooser();
			jch.setDialogTitle("请选择文件...");
			jch.showOpenDialog(null);//应用打开文件界面设置的默认值。
			jch.setVisible(true);
			
			//得到用户选择文件的绝对路径
			String fileplace=jch.getSelectedFile().getAbsolutePath();
			
			//读取该文件
			FileReader fr=null;
			BufferedReader br=null;
			
			try {
				fr=new FileReader(fileplace);
				br=new BufferedReader(fr);
				
				String s="";//中间变量
				String result="";
				while((s=br.readLine())!=null) {//readLine不包括任何终止符，如果到达末尾，则返回null
					//循环读取文件信息，把内容放到变量result
					result=result+s+"\r\n";
				}
				//将result放到文本框即可
				jta.setText(result);
				
			} catch (Exception e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}finally {
				try {
					fr.close();
					br.close();
				} catch (IOException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
			}
			
		}
		else if(e.getSource()==jit2) {
			//System.out.println("save");
			
			//文件选择组件
			JFileChooser jch=new JFileChooser();
			jch.setDialogTitle("另存为..."); 
			jch.showSaveDialog(null);//应用打开文件界面设置的默认值。
			jch.setVisible(true);
			
			//得到用户选择保存的绝对地址
			String fileplace=jch.getSelectedFile().getAbsolutePath();
			
			//写入文件
			FileWriter fw=null;
			BufferedWriter bw=null;
			String s=jta.getText();
			
			try {
				fw=new FileWriter(fileplace);
				bw=new BufferedWriter(fw);
				
				bw.write(s+"\r\n");
				
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}finally {
				try {
					//先关BufferedWriter，再关FileWriter，顺序错误会抛出异常。
					bw.close();
					fw.close();
					
				} catch (IOException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
			}
		}
	}
}