Java api 文件基本的输入输出流
示例一：
import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* java.io.File
* 该类用于表示一个文件或目录
* 使用该类可以获取表示的文件或目录的属性信息。
* 但是不能访问文件的内容。
* 使用该类还可以操作文件或目录(新建，删除等)
* @author Administrator
*
*/
public class FileDemo1 {
public static void main(String[] args) {
/*
* 创建一个File用来表示项目根目录下的test.txt
* 文件
*/
File file = new File("."+File.separator+"test.txt");
/*
* 判断表示的文件是否真实存在于硬盘上
* boolean exists()
* 存在返回true
*/
if(file.exists()){
System.out.println("文件存在!");
}else{
System.out.println("文件不存在!");
}
/*
* long length()
* 查看当前文件占用的字节量
*/
long length = file.length();
System.out.println("占用:"+length+"字节");
/*
* boolean isFile()
* 判断当前File对象表示的是否是一个文件
* 是则返回true
*/
if(file.isFile()){
System.out.println("是文件");
}else{
System.out.println("不是文件");
}
/*
* boolean isDirectory()
* 判断当前File对象表示的是否为一个目录
*/
if(file.isDirectory()){
System.out.println("是目录");
}else{
System.out.println("不是目录");
}
/*
* 一下三个方法返回boolean值
* 分别表示:
* 可运行，可读，可写
*/
file.canExecute();
file.canRead();
file.canWrite();
/*
* 文件的最后修改时间
* long表示1970年元旦到这一刻的毫秒值
*
* 2015年4月9日 16:37:38
*/
long last = file.lastModified();
Date date = new Date(last);
SimpleDateFormat sdf
= new SimpleDateFormat("yyyy年M月d日 HH:mm:ss");
String str = sdf.format(date);
System.out.println(str);
/*
* String getName()
* 获取当前File对象表示的文件或目录的名字
*/
String name = file.getName();
System.out.println("名字:"+name);
}
}
import java.io.File;
import java.io.IOException;
/**
* 使用File对象新建一个文件
* @author Administrator
*
*/
public class FileDemo2 {
public static void main(String[] args) throws IOException {
/*
* 在当前项目根目录下创建文件demo.txt
*/
File file = new File("demo.txt");
//若不存在才创建
if(!file.exists()){
/*
* 创建文件
*/
file.createNewFile();
System.out.println("创建完毕!");
}
}
}import java.io.File;
/**
* 删除一个文件
* @author Administrator
*
*/
public class FileDemo3 {
public static void main(String[] args) {
/*
* 删除项目根目录下的demo.txt文件
*/
File file = new File("demo.txt");
if(file.exists()){
/*
* 删除该文件
*/
file.delete();
System.out.println("删除完毕!");
}
}
}
import java.io.File;
/**
* 查看一个目录下的所有子项
* @author Administrator
*
*/
public class FileDemo1 {
public static void main(String[] args) {
/*
* 查看当前项目根目录下的所有子项
*/
File dir = new File(".");
/*
* File[] listFiles()
* 将当前目录下的每一个子项用一个File对象去描述
* 然后将他们存入一个数组返回
*/
File[] subs = dir.listFiles();
for(File sub : subs){
if(sub.isFile()){
System.out.print("文件:");
}
if(sub.isDirectory()){
System.out.print("目录:");
}
System.out.println(sub.getName());
}
}
}
import java.io.File;
import java.io.FileFilter;
/**
* 使用文件过滤器FileFilter来获取一个目录下
* 满足条件的部分子项
* @author Administrator
*
*/
public class FileDemo2 {
public static void main(String[] args) {
/*
* 使用匿名内部类方式创建文件过滤器
* java.io.FileFilter本身是一个接口
*/
FileFilter filter = new FileFilter(){
/**
* 实现FileFilter接口后必须重写accept方法
* 该方法用于定义过滤条件。若参数file满足
* 过滤条件返回值就为true即可
*/
public boolean accept(File file) {
System.out.println("正在过滤:"+file.getName());
//过滤条件:只要文件，不要目录
return file.isFile();
}
};
File dir = new File(".");
/*
* 获取当前目录下满足过滤器要求的所有子项
*/
File[] subs = dir.listFiles(filter);
for(File sub : subs){
System.out.println(sub.getName());
}
}
}
import java.io.File;
/**
* 删除给定的File对象
* 该对象可能表示文件也可能表示目录。总之要删除
* @author Administrator
*
*/
public class FileDemo3 {
public static void main(String[] args) {
File dir = new File("a");
delete(dir);
}
/**
* 将给定的File对象表示的文件或目录删除
* @param file
*/
public static void delete(File file){
if(file.isDirectory()){
//先将所有子项删除
File[] subs = file.listFiles();
for(File sub : subs){
delete(sub);
}
}
file.delete();
}
}
/*
* 编写一段代码，完成1+2+3+4...+100
* 每加一次输出一次结果
* 不得超过20行代码
* 一行一句代码。
* 在代码中不得出现for while等关键字
*/
import java.io.File;
import java.io.FileNotFoundException;
import java.io.RandomAccessFile;
/**
* java.io.RandomAccessFile
* 该类用于读写文件数据
* @author Administrator
*
*/
public class RandomAccessFileDemo1 {
public static void main(String[] args) throws FileNotFoundException {
/*
* RandomAccessFile的两种创建模式
* 读写模式与只读模式
* 读写模式:可以读取文件数据，也可以向文件中写入数据
* 只读模式:只能读取文件数据。
* RandomAccessFile的读写操作是基于指针的，总是在
* 指针当前指向的位置进行读写操作的。
*/
/*
* 创建一个用于读写项目根目录下的test.dat文件的
* RandomAccessFile
*
* 两个常用的构造方法
* RandomAccessFile(String path,String mode)
* RandomAccessFile(File file,String mode)
*/
// File file = new File("test.dat");
// RandomAccessFile raf
// = new RandomAccessFile(file,"rw");
RandomAccessFile raf
= new RandomAccessFile("test.dat","rw");
}
}
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
* 向文件中写出数据
* @author Administrator
*
*/
public class RandomAccessFileDemo2 {
public static void main(String[] args) throws IOException {
/*
* 向文件demo.dat中写入数据
*/
RandomAccessFile raf
= new RandomAccessFile("demo.dat","rw");
/*
* void write(int d)
* 向文件中写出一个字节，写出的是给定的int值2进制中
* 的“低8位”
* vvvvvvvv
* 00000000 00000000 00000001 00000011
*/
raf.write(259);
raf.close();
}
}import java.io.IOException;
import java.io.RandomAccessFile;
/**
* 读取一个字节
* @author Administrator
*
*/
public class RandomAccessFileDemo3 {
public static void main(String[] args) throws IOException {
RandomAccessFile raf
= new RandomAccessFile("demo.dat","r");
/*
* int read()
* 从文件中读取一个字节，并以int形式返回。需要注意
* 该int值只有"低8位"有值
* 若读取到了文件末尾，则返回-1
* EOF(end of file)
*
*/
int n = raf.read();
System.out.println(n);
raf.close();
}
}
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
* 批量写出数据
* @author Administrator
*
*/
public class RandomAccessFileDemo4 {
public static void main(String[] args) throws IOException {
RandomAccessFile raf
= new RandomAccessFile("test.txt","rw");
/*
* void write(byte[] d)
* 将给定的字节数组中的所有字节一次性写出
*/
String str = "摩擦摩擦是魔鬼的步伐";
/*
* byte[] getBytes()
* 将当前字符串按照系统默认字符集转换为对应的字节
*/
byte[] data = str.getBytes();
raf.write(data);
raf.close();
}
}
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
* 批量读取数据
* @author Administrator
*
*/
public class RandomAccessFileDemo5 {
public static void main(String[] args) throws IOException {
RandomAccessFile raf
= new RandomAccessFile("test.txt","r");
/*
* int read(byte[] d)
* 一次性尝试读取给定的字节数组的length个字节，并
* 存入到给定的字节数组中。返回值为实际读取到的字节
* 量。若返回值为-1，说明读取到文件末尾了。
*/
byte[] data = new byte[100];
int n = raf.read(data);
System.out.println("实际到的字节量:"+n);
/*
* 将字节转换为对应的字符串
* 可以使用String的构造方法：
* String(byte[] d)
* 该构造方法会将给定的字节数组中的所有字节按照
* 当前系统默认的字符集转换为对应的字符串
*
* String(byte[] d,int offset,int len)
* 将当前字节数组从offset处开始的连续len个字节
* 转换为对应的字符串
*/
String str = new String(data,0,n);
System.out.println(str);
raf.close();
}
}
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
* RAF提供了方便读写基本类型数据的方法
* @author Administrator
*
*/
public class RandomAccessFileDemo6 {
public static void main(String[] args) throws IOException {
RandomAccessFile raf
= new RandomAccessFile("demo.dat","rw");
/*
* long getFilePointer()
* 该方法用于获取RAF当前指针位置
*/
System.out.println("point:"+raf.getFilePointer());
int max = Integer.MAX_VALUE;
/*
* vvvvvvvv
* 01111111 11111111 11111111 11111111
*
*/
// raf.write(max>>>24);
// raf.write(max>>>16);
// raf.write(max>>>8);
// raf.write(max);
//连续写4个字节，将给定的int值写入文件
raf.writeInt(max);
System.out.println("point:"+raf.getFilePointer());
raf.writeLong(123L);
System.out.println("point:"+raf.getFilePointer());
raf.writeDouble(123.123);
System.out.println("point:"+raf.getFilePointer());
/*
* void seek(long pos)
* 将指针移动到指定位置
*/
raf.seek(0);//移动到文件最开始
/*
* int readInt()
* 连续读取4个字节，将对应的int值返回
* 若读取到文件末尾，该方法会抛出异常EOFException
*/
int i = raf.readInt();
System.out.println("int:"+i);
System.out.println("point:"+raf.getFilePointer());
long l = raf.readLong();
System.out.println("long:"+l);
double d = raf.readDouble();
System.out.println("double:"+d);
raf.close();
}
}
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
* 复制文件
* @author Administrator
*
*/
public class CopyDemo1 {
public static void main(String[] args) throws IOException {
/*
* 1:创建RandomAccessFile读取原文件
* 2:创建RandomAccessFile用于写到目标文件
* 3:循环从原文件读取一个字节写入到目标文件，直到
* 原文见所有内容都读取完毕
* 4:关闭RandomAccessFile
*/
//1
RandomAccessFile src
= new RandomAccessFile("wnwb.exe","r");
//2
RandomAccessFile des
= new RandomAccessFile("wnwb_copy.exe","rw");
long start = System.currentTimeMillis();
//3
int d = -1;
while((d = src.read())!=-1){
des.write(d);
}
long end = System.currentTimeMillis();
System.out.println("文件复制完毕!");
System.out.println("耗时:"+(end-start)+"ms");
src.close();
des.close();
}
}
import java.io.IOException;
import java.io.RandomAccessFile;
/**
* 若想提高读写效率，需要提高读写的数据量，从而降低
* 读写次数。
* @author Administrator
*
*/
public class CopyDemo2 {
public static void main(String[] args) throws IOException {
RandomAccessFile src
= new RandomAccessFile("wnwb.exe","r");
RandomAccessFile des
= new RandomAccessFile("wnwb_copy2.exe","rw");
//10k 缓存
byte[] buf = new byte[1024*10];
//记录每次实际读取到的字节量
int len = -1;
long start = System.currentTimeMillis();
while((len = src.read(buf))!=-1){
/*
* void write(byte[] d,int offset,int len)
* 将给定的字节数组中从offset处的字节开始连续
* len个字节写入文件
*/
des.write(buf,0,len);
}
long end = System.currentTimeMillis();
System.out.println("复制完毕!");
System.out.println("耗时:"+(end-start)+"ms");
src.close();
des.close();
}
}
示例五：
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* FileInputStream
* 用于读取文件中字节数据的流
* 是一个低级流
* @author Administrator
*
*/
public class FISDemo {
public static void main(String[] args) throws IOException {
FileInputStream fis
= new FileInputStream("fos.txt");
byte[] buf = new byte[100];
/*
* 尝试读取100个字节，返回值为实际读取到的字节量
*/
int len = fis.read(buf);
String str = new String(buf,0,len,"UTF-8");
System.out.println(str);
fis.close();
}
}import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* FileOutputStream 文件的字节输出流
* 用于向文件中写出字节的流
* 是一个低级流
* @author Administrator
*
*/
public class FOSDemo {
public static void main(String[] args) throws IOException {
/*
* FOS有两种创建模式:
* 第一种:重写模式
* FileOutputStream(String str)
* FileOutputStream(File file)
* 基于上面方式创建的流对文件的写操作是重写的，会将
* 文件以前的内容全部清除。然后重新写内容
*
* FileOutputStream(String str,Boolean append)
* FileOutputStream(File file,Boolean append)
* 基于上面方式创建的流对文件的操作时追加写操作。
* 所有内容会追加到文件末尾。前提是第二个参数为true
*
*/
FileOutputStream fos
= new FileOutputStream("fos.txt",true);
String str = "摩擦摩擦是魔鬼的步伐，哎呦我去滑板鞋!";
byte[] dat = str.getBytes("UTF-8");
fos.write(dat);
/*
* 流使用完毕后要关闭，以释放
*/
fos.close();
}
}
示例六：
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 缓冲流由于内部维护了一个字节数组，所以可以一次读写
* 若干字节，从而降低读写次数提高效率。
* 对于缓冲输出流而言，需要注意写出数据后的缓冲区问题
* @author Administrator
*
*/
public class BOSDemo {
public static void main(String[] args) throws IOException {
FileOutputStream fos
= new FileOutputStream("bos.txt");
BufferedOutputStream bos
= new BufferedOutputStream(fos);
String str = "我爱北京天安门!";
bos.write(str.getBytes());
/*
* void flush()
* 该方法会将缓冲流的缓冲字节数组中现有的内容强制性
* 写出，而不是等到缓冲字节数组放满才写出。
* 通常我们需要写出的及时性时会调用该方法。但是要知道
* 频繁调用该方法会增加写出次数降低写出效率。
*/
// bos.flush();
bos.close();
}
}
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* InputStreamReader
* 字符输入流
* 特点:可以按照指定的字符集将对应的字节转换为字符
* 后返回
* @author Administrator
*
*/
public class ISRDemo {
public static void main(String[] args) throws IOException {
FileInputStream fis
= new FileInputStream("osw.txt");
InputStreamReader isr
= new InputStreamReader(fis,"UTF-8");
int d = -1;
while((d = isr.read()) != -1){
/*
* 由于isr读取的是一个字符，所以返回的int值
* 低16位有效。
*/
System.out.print((char)d);
}
isr.close();
}
}
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
/**
* java.io.OutputStreamWriter
* 字符流都是高级流。方便我们读写字符数据。
* 字符流只能读写字符数据。
*
* OutputStreamWriter可以方便我们按照给定的字符集将
* 字符数据转换为字节后写出
* @author Administrator
*
*/
public class OSWDemo {
public static void main(String[] args) throws IOException {
FileOutputStream fos
= new FileOutputStream("osw.txt");
/*
* OutputStreamWriter(OutputStream out)
* 默认创建出来的字符输出流是按照当前系统默认的
* 字符集将字符串转换为对应的字节的。
*
* OutputStreamWriter(OutputStream out,
* String charsetName)
* 第二个参数用来指定字符集，这样就会按照指定的字符集
* 将字符串转换为对应的字节了。
*/
OutputStreamWriter osw
= new OutputStreamWriter(fos,"UTF-8");
osw.write("我爱达内苍老师!");
osw.write("随便写点什么。");
osw.close();
}
}
示例八：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 使用文件流进行文件复制操作
* @author Administrator
*
*/
public class CopyDemo1 {
public static void main(String[] args) throws IOException {
/*
* 创建文件输入流读取原文件
* 创建文件输出流用些写到目标文件
* 循环从原文件读取字节写入目标文件
* 完成后将流关闭
*/
FileInputStream fis
= new FileInputStream("wnwb.exe");
FileOutputStream fos
= new FileOutputStream("wnwb_copy3.exe");
byte[] buf = new byte[1024*10];
int len = -1;
while((len = fis.read(buf))!=-1){
fos.write(buf,0,len);
}
fis.close();
fos.close();
}
}
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* BOS与BIS
* 缓冲字节输入与输出流可以提高读写效率
* 内部维护一个缓冲区，原理还是提高了读写的数据量减少
* 读写次数来实现提高读写效率的
* @author Administrator
*
*/
public class CopyDemo2 {
public static void main(String[] args) throws IOException {
FileInputStream fis
= new FileInputStream("wnwb.exe");
BufferedInputStream bis
= new BufferedInputStream(fis);
FileOutputStream fos
= new FileOutputStream("wnwb_copy4.exe");
BufferedOutputStream bos
= new BufferedOutputStream(fos);
int d = -1;
long start = System.currentTimeMillis();
while((d = bis.read())!=-1){
bos.write(d);
}
long end = System.currentTimeMillis();
System.out.println("复制完毕!耗时"+(end-start)+"ms");
/*
* 关闭流的时候，我们只需要关闭最外层的高级流即可
* 因为它在关闭自身时会先将它处理的流关闭，然后
* 才会关闭自己。
*/
bis.close();
bos.close();
}
}
示例九：
import java.io.Serializable;
import java.util.List;
/**
* 该类的实例用于测试对象序列化与反序列化
* @author Administrator
*/
public class Person implements Serializable{
/*
* 版本号应当自行维护，它对是否能反序列化成功起到很
* 重要的作用
* 若需要反序列化的对象与现在类的版本号不一样，反序列
* 化失败
* 若需要反序列化的对象与现在类的版本号一致，若类的属性
* 定义发生了变化，那么会启动兼容模式。
* 以前对象中有的属性，现在还有的就还原该属性的值
* 以前对象中有的属性，现在类中没有那么就放弃该属性值
* 以前对象中没有的属性，现在类中有的就用该属性默认值
*
*/
private static final long serialVersionUID = 1L;
private String name;
private int age;
private String gender;
/*
* transient关键字
* 该关键字只有在当前类的实例被序列化时才有用。作用是
* 在序列化为字节时忽略该属性的值。
*/
private transient List otherInfo;
public Person(){}
public Person(String name, int age, String gender, List otherInfo) {
super();
this.name = name;
this.age = age;
this.gender = gender;
this.otherInfo = otherInfo;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public List getOtherInfo() {
return otherInfo;
}
public void setOtherInfo(List otherInfo) {
this.otherInfo = otherInfo;
}
public String toString(){
return name+","+age+","+gender+","+otherInfo;
}
} import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
/**
* ObjectOutputStream
* 用于对象序列化的高级流
* 使用它可以方便的将对象转换为一组字节后写出
* @author Administrator
*
*/
public class OOSDemo {
public static void main(String[] args) throws IOException {
FileOutputStream fos
= new FileOutputStream("person.obj");
ObjectOutputStream oos
= new ObjectOutputStream(fos);
Person person = new Person();
person.setName("苍老师");
person.setAge(30);
person.setGender("女");
List info = new ArrayList();
info.add("喜欢写毛笔字");
info.add("喜欢拍电影");
info.add("喜欢唱歌");
person.setOtherInfo(info);
/*
* void writeObject(Object obj)
* ObjectOutputStream提供的该方法用于将给定的对象
* 转换为对应的一组字节，然后通过其处理的流将这些
* 字节写出
*
* 要想通过对象输出流的writeObject方法将给定对象
* 进行序列化，前提是该对象所属的类必须实现可序列化
* 接口。
*/
oos.writeObject(person);
/*
* 当我们调用完writeObject方法时，该方法
* 首先会将我们给定的person对象转化为一组字节(序列化)
* 然后通过oos处理的fos将字节写出。那么fos会将这些
* 字节最终写入到文件中做长久保存(持久化)
*
* 所以oos负责将对象转化为一组字节，而不负责字节的
* 实际去向。
*
* fos将oos提供的字节做真实的写出操作，写入文件。
*
*/
System.out.println("序列化完毕");
oos.close();
}
}
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
/**
* java.io.ObjectInputStream
* 用于对象反序列化的流
* 需要注意的是，若想通过OIS将字节进行反序列化为对象
* 前提是，这些字节应当是OOS将对象转化的字节。
* @author Administrator
*
*/
public class OISDemo {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//读取person.obj文件
FileInputStream fis
= new FileInputStream("person.obj");
ObjectInputStream ois
= new ObjectInputStream(fis);
/*
* Object readObject()
* 读取若干字节，将其还原为对象。但返回时是以
* Object类型返回的。
*
* 该方法可能会抛出ClassNotFoundException
* 当调用该方法时实际读取的字节不是由oos序列化的
* 字节时会抛出该异常
*/
Object obj = ois.readObject();
Person person = (Person)obj;
System.out.println(person);
ois.close();
}
}
示例十：
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
/**
* java.io.PrintWriter
* 缓冲字符输出流，特点:具有自动行刷新
* 该流会自动在内部创建BufferedWriter作为缓冲功能。
* 因为该流提供了行刷新，有兼具缓冲功能，所以更常用。
* @author Administrator
*
*/
public class PrintWriterDemo1 {
public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
/*
* PrintWriter(File f)
* PrintWriter(String pathname)
* 以上两种构造方法都是可以直接创建一个基于文件进行
* 写操作的缓冲流。并且以上两种构造方法还支持第二个
* 参数，是一个字符串类型的参数。可以指定字符集。
* 若不指定，使用系统默认字符集。
*/
PrintWriter pw = new PrintWriter("pw.txt","UTF-8");
pw.println("我爱北京天安门");
pw.println("我还爱北京达内苍老师");
pw.close();
}
}
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
/**
* 将流包装为PrintWriter
* 若包装的是流，可以具有自动行刷新
* @author Administrator
*
*/
public class PrintWriterDemo2 {
public static void main(String[] args) throws IOException {
FileOutputStream fos
= new FileOutputStream("pw2.txt");
OutputStreamWriter osw
= new OutputStreamWriter(fos,"UTF-8");
/*
* PrintWriter(OutputStream out)
* 若是直接包装字节流，那么是按照系统默认字符集将
* 字符串转换为字节后写出。
*
* 所以，若需要指定字符集，那么就要在字节流与缓冲
* 字符流之间包装OSW,来指定字符集。
*/
PrintWriter pw
= new PrintWriter(osw);
pw.println("在写点内容");
pw.println("写点什么都行");
pw.close();
}
}
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
/**
* 当PrintWriter处理的是一个流，就可以具有自动行刷新
* @author Administrator
*
*/
public class PrintWriterDemo3 {
public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
FileOutputStream fos
= new FileOutputStream("pw3.txt");
OutputStreamWriter osw
= new OutputStreamWriter(fos,"UTF-8");
/*
* 创建一个具有自动行刷新的PrintWriter
* 若构造方法中第一个参数是流，那么就可以传入
* 第二个参数，该参数为boolean值，若为true,则
* 具有自动行刷新
*/
PrintWriter pw
= new PrintWriter(osw,true);
/*
* 若当前PrintWrinter具有自动行刷新功能，那么
* 每当我们调用一次println方法写出字符串，就会
* 自动flush，将该字符串写出。但是应当明白，这样
* 会增加写出次数，降低写出效率。通常这样做的目的是
* 要求写出具有即时性。
*/
pw.println("你好!");
pw.println("!!!!");
pw.close();
}
}
示例十一：
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* BufferedReader
* 缓冲字符输入流，特点:以行为单位读取字符串
* @author Administrator
*
*/
public class BufferedReaderDemo1 {
public static void main(String[] args) throws IOException {
/*
* 读取当前程序的源文件，并输出到控制台
*/
FileInputStream fis
= new FileInputStream("."+File.separator+
"src"+File.separator+
"day03"+File.separator+
"BufferedReaderDemo1.java"
);
InputStreamReader isr
= new InputStreamReader(fis);
/*
* BufferedReader(Reader reader)
* 缓冲字符输入流只能处理一个字符流
*/
BufferedReader br
= new BufferedReader(isr);
/*
* String readLine()
* 缓冲字符输入流的readLine方法，可以以行为单位
* 读取字符串。
* 该方法会连续读取若干字符，直到读取到换行符为止
* 然后将之前读取的所有字符组成一个字符串返回，该
* 字符串中不含有最后的换行符。
* 若直接读取到一个换行符，那么返回值为空字符串。
* 若读取到文件末尾，则返回null.
*/
String line = null;
while((line = br.readLine())!=null){
System.out.println(line);
}
br.close();
}
}