IO流位于java.io包中，根据操作数据不同，分为字节流和字符流；根据数据输入方面的不同又可分为输入流和输出流，无论是何种流，最终都依赖于操作系统。

一、字节流：

1、字节流，主要用于图片、音频、视频的传输，以二进制的形式进行，分为字节输入流和字节输出流；字节流操作的是字节数组；字符流操作的是字符数组。

2、字节输入与字节输出流的继承体系图

3、InputStream 与OutputStream常用方法

InputStream 常用方法

方法声明

功能描述

int read()

从输入流读取一个8位的字节，把它转换为0-255之间的整数，并返回这一整数

int read(byte[] b)

从输入流读取若干字节，把它们保存到参数b指定的字节数组中，返回的整数表示读取的字节数

int read(byte[] b,int off,len)

从输入流读取若干字节，把它们保存到参数b指定的字节数组中，off指定字节数组开始保存数据的起始下标，len表示读取的字节

void close()

关闭此输入流并释放与该流关联的所有系统资源

OutputStream 常用方法

方法声明

功能描述

void write(int b)

向输出流写入一个字节

void write(byte[]  b)

把参数b指定的字节数组的所有字节写到输出流

void write(byte[] b,int off,len)

将指定byte数组中从偏移量off开始的len个字节写入输出流

void flush()

刷新此输出流并强制写出所有缓冲的输出字节

void close()

关闭此输出流并释放与该流关联的所有系统资源

4、字节流读写文件：

FileInputStream 是操作文件的的字节输入流，专门用于读取文件中的数据。

FileOutputStream是操作文件的的字节输出流，专门用于把数据写入文件。

示例：

1 public classExample01 {2 public static void main(String[] args) throwsException{3 //创建一个文件字节型输入流

4 InputStream inputStream = new FileInputStream("test.txt");5 int b = 0; //定义一个int类型的变量b，记住每一次读取的一个字节

6 while (true){7 b=inputStream.read();//变量b记住读取的一个字节

8 if(b==-1){ //如果读取的字节为-1，跳出while循环

9 break;10 }11 System.out.println(b); //否则将b写出

12 }13 inputStream.close();14

15 //创建一个文件字节输出流

16 OutputStream OutputStream= new FileOutputStream("example.txt",true);17 String string = "人之初";18 byte [] bytes=string.getBytes();19 for (int i = 0;i

View Code

文件拷贝：

1 public classExample04 {2 public static void main(String[] args) throwsException{3 //创建一个字节输入流，用于读取当前目录下source文件中的docx文件

4 InputStream in = new FileInputStream("source/IO工具包.mp4") ;5 //创建一个文件字节输出流，用于将读取的数据写入target目录下的文件中

6 OutputStream out = new FileOutputStream("target/IO工具包.mp4");7 byte [] buff = new byte[1024]; //定义一个字节数组，作为缓冲区

8 int len; //定义一个int类型的变量len记住读取读入缓冲区的字节数9 //int len = 0 ;//定义一个int类型变量，记住每次读取的一个字节

10 long begintime =System.currentTimeMillis();11 while ((len=in.read(buff))!=-1){ //判断是否读到文件末尾

12 out.write(buff,0,len); //从第一字节开始，向文件写入len个字节

13 }14 long endtime =System.currentTimeMillis();15 System.out.println("耗时"+(endtime-begintime)+"毫秒");16 in.close();17 out.close();18 }19 }

View Code

5、装饰设计模式思想：

TextReader:读取文本；

MediaReader:读取媒体数据；

抽取共性，形成体系。

Reader

|---TextReader  read()

|---MediaReader

需求1：

提高读取文本的效率，使用缓冲技术，提供一个读取文本更高效的读取方法。

覆盖TextReader中的方法。建立高效的read方法。所以建立一个TextReader的子类，用于高效的读取。

Reader

|---TextReader  read()

|--BufferedTextReader

|---MediaReader

需求2：

提高读取媒体数据的效率，派生一个高效的子类，用于高效的读取。

Reader

|---TextReader  read()

|--BufferedTextReader

|---MediaReader

|--BufferedMediaReader

发现一个小问题，如果Reader中还有读取其他数据的子类，如果要高效，那岂不是还要给这个子类添加一个高效子类？

是的，为了给具体的读取数据的对象增加一些功能，是需要通过子类来完成的。

但是这样做，会导致这个继承体系很臃肿！仅仅为了增加一些功能，而进行继承，不建议的。

这些子类无非就是需要高效，而且这些高效的功能实现是一致的。就是提供一个缓冲区而以。

干脆，单独定义一个具备这个缓冲功能的对象，哪个子类需要被缓冲，就将哪个子类传递进来。

class BufferedReader  extends Reader{

private [];//提供数据

BufferedReader(Reader r){    //对Reader高效就行

}

read(){操作的是数组}  //高效的读取动作

}

此时继承体系：

Reader

|---TextReader

|---MediaReader

|---BufferedReader

发现这种设计方式减少了继承体系的臃肿，增减功能，比继承更为灵活。

这种设计方式称为：装饰设计模式。

解决问题：给一组类增加功能，避免继承的臃肿，提高灵活。

注意：装饰类和被装饰类必须属于同一体系，通常装饰类都会提供构造函数接收被装饰类对象。装饰类通常不单独存在。

6、字节缓冲流

使用的是装饰设计模式

示例：

1 public classExample07 {2 public static void main(String[] args) throwsException{3 //创建一个带缓冲区的输入流

4 BufferedInputStream bis = newBufferedInputStream(5 new FileInputStream("src.txt"));6 //创建一个带缓冲区的输出流

7 BufferedOutputStream bos = newBufferedOutputStream(8 new FileOutputStream("des.txt"));9 intlen;10 while ((len=bis.read())!=-1){11 bos.write(len);12 }13 bis.close();14 bos.close();15 }16 }

View Code

二、字符流

1、字符流：为了便于操作数据中的字符数据。原理：字节流+编码表。

2、字符流继承体系

3、基类方法摘要

Reader方法摘要

abstract  void close()

关闭该流并释放与之关联的所有资源。

void mark(int readAheadLimit)

标记流中的当前位置。

boolean markSupported()

判断此流是否支持 mark() 操作。

int read()

读取单个字符。

int read(char[] cbuf)

将字符读入数组。

abstract  int read(char[] cbuf, int off, int len)

将字符读入数组的某一部分。

int read(CharBuffer target)

试图将字符读入指定的字符缓冲区。

boolean ready()

判断是否准备读取此流。

void reset()

重置该流。

long skip(long n)

跳过字符。

Writer方法摘要

void close()

关闭此流，但要先刷新它。

void flush()

刷新该流的缓冲。

String getEncoding()

返回此流使用的字符编码的名称。

void write(char[] cbuf, int off, int len)

写入字符数组的某一部分。

void write(int c)

写入单个字符。

void write(String str, int off, int len)

写入字符串的某一部分。

flush()和close()的区别？

flush()；将流中的缓冲区缓冲中的数据刷新到目的地中，刷新后，流还可以继续使用；

close()；关闭资源，但在关闭前会将缓冲区中的数据刷新到目的地，否则丢失数据，然后再关闭流，流不可以使用。

如果写入数据多，一边写一边刷新，最后一次可以不刷新，由close()完成刷新并关闭。

4、字符流操作文件

FileReader 和FileWriter 用于读写文件；BufferedReader 和BufferdeWriter是具有缓冲功能的流，可以提高读写效率。

BufferedReader中有一重要的方法readLind()，该方法用于一次读取一行文本。

1 public classExample10 {2 public static void main(String[] args) throwsException{3 FileReader reader = new FileReader("src.txt");4 //创建一个BufferedReader缓冲对象

5 BufferedReader br = newBufferedReader(reader);6 FileWriter writer = new FileWriter("des.txt");7 //创建一个BufferedWriter缓冲对象

8 BufferedWriter bw = newBufferedWriter(writer);9 String string;10 while ((string=br.readLine())!=null){11 bw.write(string);12 bw.newLine();//写入一个换行符，该方法会根据不同的操作系统生成相应的换行符

13 }14 br.close();15 bw.close();16 }17 }

View Code

BufferedReader一直接子类——LineNumberReader ,一个可以跟踪行号的输入流。

1 public classExample11 {2 public static void main(String[] args) throwsException{3 FileReader fr = new FileReader("/Users/Shared/第八章IO练习/exampele09.txt"); //创建字符输入流

4 FileWriter fw = new FileWriter("copy.txt");//创建字符输出流

5 LineNumberReader lr = new LineNumberReader(fr); //包装

6 lr.setLineNumber(0); //设置读取文件的起始行号

7 String line = null;8 while ((line=lr.readLine())!=null){9 fw.write(lr.getLineNumber()+":"+line);//将行号写入到文件中

10 fw.write("\r\n"); //写入换行

11 }12 lr.close();13 fw.close();14 }15 }

View Code

5、转换流

转换流是一种字符流，只能实现字节流读写文本数据的时候，通过转换流来使用字符高效流的方法。而不能实现图片、音频等数据的读写。

InputStreamReader:理解上是字节流通向字符流的桥梁，使用上为：

BufferedReader  br = new BufferedReader(new InputStreamReader(System.in));

OutputStreamWriter:理解上是字符流通向字节流的桥梁，使用上还是通过字节流转成字符流：

BufferedWriter  bw = new BufferedWriter (new OutputStreamWriter(System.out));

1 public classExample12 {2 public static void main(String[] args) throwsException{3 FileInputStream in= new FileInputStream("src1.txt");//创建字节输入流

4 InputStreamReader isr = new InputStreamReader(in);//将字节流输入转换成字符输入流

5 BufferedReader br = new BufferedReader(isr);//对字符流对象进行包装

6 FileOutputStream out = new FileOutputStream("des1.txt");7 //将字节流转换为字符输出流

8 OutputStreamWriter osw = newOutputStreamWriter(out);9 //对字符输出流对象进行包装

10 BufferedWriter bw = newBufferedWriter(osw);11 String line;12 while ((line=br.readLine())!=null){ //判断是否读到文件末尾

13 bw.write(line); //输出读取到文件

14 }15 br.close();16 bw.close();17 }18 }

View Code

三、其他IO流

1、ObjectOutputStream、ObjectInputStream

序列化：把对象按照流一样的方式传输或者存储。(ObjectOutputStream).

当对象进行序列化时，必须保证该对象实现Serializable接口，否则程序会出现NotSerializableException异常。

反序列号：把网络中的流数据或者文件中的流数据(二进制数据)还原成对象。(ObjectInputStream).

1 public classExample13 {2 public static void main(String[] args) throwsException{3 //序列化对象

4 Person person = new Person("p1","zhangsan",20);5 //创建文件输出流对象，将数据写入objectStream.txt

6 FileOutputStream fos = new FileOutputStream("objectStream.txt");7 //创建对象输出流对象，用于处理输出流对象写入的数据

8 ObjectOutputStream oos = newObjectOutputStream(fos);9 //将Person对象输出到输出流中

10 oos.writeObject(person);11 oos.close();12

13 //反序列化对象

14 FileInputStream fis = new FileInputStream("object.txt");15 //创建文件输入流对象，用于读取指定文件的数据

16 ObjectInputStream ois = newObjectInputStream(fis);17 //创建对象输入流，并且从指定的输入流中过读取数据

18 Object p =ois.readObject();19 System.out.println(p);20 ois.close();21 }22 }23 class Person implementsSerializable{24 privateString id;25 privateString name;26 private intage;27 public Person(String id, String name, intage) {28 super();29 this.id =id;30 this.name =name;31 this.age =age;32 }33 publicString getId() {34 returnid;35 }36 publicString getName() {37 returnname;38 }39 public intgetAge() {40 returnage;41 }42 }

View Code

2、DataInputStream,DataOutputStream

有时候并不需要存储整个对象的信息，而只需要存储对象的成员数据，这些成员数据的类型又都是基本数据类型，可使用数据操作流：DataInputStream,DataOutputStream 。

1 public classExample15 {2 public static void main(String[] args) throwsException{3 BufferedOutputStream bos = newBufferedOutputStream(4 new FileOutputStream("/Users/Shared/ioexample/dataStream.txt"));5 DataOutputStream dos = newDataOutputStream(bos);6 dos.writeByte(12); //写一个字节

7 dos.writeChar('1'); //写一个字符

8 dos.writeBoolean(true); //写一个布尔值

9 dos.writeUTF("同学，你好"); //写一个转换成UTF-8的字符串

10 dos.close(); //关闭流

11 BufferedInputStream bis= newBufferedInputStream(12 new FileInputStream("/Users/Shared/ioexample/dataStream.txt"));13 DataInputStream dis = newDataInputStream(bis);14 System.out.println(dis.readByte()); //读取一个字节

15 System.out.println(dis.readChar()); //读取一个字符

16 System.out.println(dis.readBoolean()); //读取一个布尔值

17 System.out.println(dis.readUTF()); //读一个转换成UTF-8编码的字符串

18 dis.close (); //关闭流

19 }20 }

View Code

只有读取数据的顺序与写数据的顺序保持一致，才能保证最终数据的正常性。

3、打印流PrintStream

1 public classExample16 {2 public static void main(String[] args) throwsException{3 PrintStream ps = newPrintStream(4 new FileOutputStream("printStream.txt",true));5 Student stu = newStudent();6 ps.print("这是一个数字");7 ps.println(19);8 ps.println(stu);9 }10 }11 classStudent {12 @Override13 publicString toString() {14 return "我是一个学生";15 }16 }

View Code

4、标准输入输出流(in、out、err)

1 public classExample17 {2 public static void main(String[] args) throwsException{3 StringBuffer sb = newStringBuffer();4 intch;5 //while循环用于读取键盘输入的数据

6 while ((ch=System.in.read())!=-1){ //判断是否读取到数据的末尾7 //对输入的字符进行判断，如果是回车"\r"或者换行"\n",则跳出循环

8 if(ch =='\r' || ch=='\n'){9 break;10 }11 sb.append((char)ch); //将读取到的数据添加到sb中

12 }13 System.out.println (sb); //打印键盘输入的数据

14 }15 }

View Code

重定向流常用的静态方法

方法声明

功能描述

void setIn(InputStream in)

对标准输入流重定向

void setOut(PrintStream out)

对标准输出流重定向

void setErr(PrintStream out)

对标准错误输出流重定向

5、管道流(PipedInputStream、PipedOutputStream)

多线程之间可以通过此管道流实现数据的传输。

1 public classExample19 {2 public static void main(String[] args) throwsException{3 final PipedInputStream pis = new PipedInputStream();//创建PipedInputStream对象

4 final PipedOutputStream pos = newPipedOutputStream();5 //PipedInputStream和PipedOutputStream建立连接，也可写成pos.connect(pis)

6 pis.connect(pos);7 new Thread(new Runnable(){ //创立线程

8 public voidrun(){9 //将从键盘读取的数据写入管道流中

10 BufferedReader br = new BufferedReader(newInputStreamReader(System.in));11 //将从键盘读取的数据写入管道流中

12 PrintStream ps = newPrintStream(pos);13 while (true){14 try{15 System.out.println(br.readLine());16 Thread.sleep(1000);17 }catch(Exception e){18 e.printStackTrace();19 }20 }21 }22 },"发送数据的线程").start();23 new Thread(newRunnable() {24 @Override25 public voidrun() {26 //下面代码是从管道流中读取数据，每读一行数据输出一次

27 BufferedReader br = new BufferedReader(newInputStreamReader(pis));28 while (true){29 try{30 System.out.println(Thread.currentThread().getName()+"收到的内容："+br.readLine());31 }catch(IOException e){32 e.printStackTrace();33 }34 }35 }36 },"接收数据的线程").start();37 }38 }

View Code

6、ByteArrayOutputStream、ByteArrayInputStream

将数据写入(读取)到缓冲区，最后一次性写入(输出)到文件。

如果读取的文件非常大，就不能使用这个列，否则会造成内存溢出。

1 public classExample20 {2 public static void main(String[] args) throwsException{3 //将数据写入缓冲区中

4 FileInputStream fs = new FileInputStream("source.txt");5 //创建一个字接数据缓冲区

6 ByteArrayOutputStream bos = newByteArrayOutputStream();7 FileOutputStream fos = new FileOutputStream("target1.txt");8 //下面的代码是循环读取缓冲区中的数据，并将数据一次性写入文件

9 intb1;10 while ((b1=fs.read())!=-1){11 bos.write(b1);12 }13 fs.close();14 bos.close();15 fos.write(bos.toByteArray());//将缓冲区中的数据一次性写入文件

16 fos.close();17

18 //读取缓冲区中的数据

19 byte[] bufs = new byte[]{97,98,99,100};//创建一个字节数组

20 ByteArrayInputStream bis = new ByteArrayInputStream(bufs);//读取字节数组中的数据21 //下面代码是循环读取缓冲区中的数据

22 intb2;23 while ((b2=bis.read())!=-1){24 System.out.println((char)b2);25 }26 bis.close();27 }28 }

View Code

7、CharArrayReader和CharArrayWriter

将字符型数据临时存入缓冲区。

1 public classExample22 {2 public static void main(String[] args) throwsException{3 FileReader fr = new FileReader("A.txt");//创建一个FileReader对象

4 CharArrayWriter cw = new CharArrayWriter();//在内存中创建一个字符数组缓冲区5 //下面打代码是将数据写入缓冲区

6 intb;7 while ((b=fr.read())!=-1){8 cw.write(b); //将读取的字符写入缓冲区

9 }10 fr.close();11 cw.close();12 char [] c = cw.toCharArray(); //将缓冲区中的数据转换成字符型数组

13 CharArrayReader cr = new CharArrayReader(c); //读取字符数据中的数据14 //下面的代码是从缓冲区中读取数据，并进行打印

15 int i = 0;16 while ((i=cr.read())!=-1){17 System.out.println((char)i);18 }19 cr.close();20 }21 }

View Code

8、SequenceInputStream

SequenceInputStream类可以将几个输入流串联在一起。

构造方法：

1、SequenceInputStream(InputStream s1, InputStream s2)

2、SequenceInputStream(Enumeration extends InputStream> e)

1 importjava.io.FileInputStream;2 importjava.io.FileOutputStream;3 importjava.io.SequenceInputStream;4 importjava.util.Enumeration;5 importjava.util.Vector;6

7 public classExample24 {8 public static void main(String[] args) throwsException{9 Vector vector =new Vector();//创建Vector对象10 //下面代码是创建3个输入流对象

11 FileInputStream in1 =new FileInputStream("stream1.txt");12 FileInputStream in2 =new FileInputStream("stream2.txt");13 FileInputStream in3 =new FileInputStream("stream3.txt");14 //下面代码是向vector中添加三个输入流对象

15 vector.addElement(in1);16 vector.addElement(in2);17 vector.addElement(in3);18 Enumeration e = vector.elements();//获取Vector对象中的元素19 //将Enumeration对象中的流合并

20 SequenceInputStream sis = newSequenceInputStream(e);21 FileOutputStream fs= new FileOutputStream("stream.txt");22 intlen;23 byte[]buf = new byte[1024]; //创建一个大小为1024个字节数组的缓冲区

24 while ((len=sis.read(buf))!=-1){25 fs.write(buf,0,len);26 }27 sis.close();28 fs.close();29 }30 }

View Code

四、File类

对文件本身进行操作

1、File类的常用方法

构造方法摘要

File(File parent, String child)

根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。

File(String pathname)

通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。

File(String parent, String child)

根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

File(URI uri)

通过将给定的 file: URI 转换为一个抽象路径名来创建一个新的 File 实例。

File类常用方法摘要

boolean exists()

测试此抽象路径名表示的文件或目录是否存在。

boolean delete()

删除此抽象路径名表示的文件或目录,删除成功则返回true，否则返回false；

boolean createNewFile()

当且仅当不存在具有此抽象路径名指定名称的文件时，才创建指定的新的文件。

String getName()

返回由此抽象路径名表示的文件或目录的名称。

String getPath()

返回File对象对应的路径

String getAbsolutePath()

返回File对象对应的绝对路径名字符串。

String getParent()

返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。

boolean canRead()

测试应用程序是否可以读取此抽象路径名表示的文件。

boolean canWrite()

测试应用程序是否可以修改此抽象路径名表示的文件。

boolean isFile()

测试此抽象路径名表示的文件是否是一个标准文件。

boolean isDirectory()

测试此抽象路径名表示的文件是否是一个目录。

boolean isAbsolute()

测试此抽象路径名是否为绝对路径名。

long lastModified()

返回此抽象路径名表示的文件最后一次被修改的时间。

long length()

返回由此抽象路径名表示的文件的长度。

String[]  list()

返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。

File[] listFiles()

返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。

示例：

1 public classExample25 {2 public static voidmain(String[] args) {3 File file = new File("example1.txt");//创建File文件对象，表示一个文件

4 System.out.println("文件名称"+file.getName());5 System.out.println("文件的相对路径"+file.getPath());6 System.out.println("文件的绝对路径"+file.getAbsolutePath());7 System.out.println("文件的父路径"+file.getParent());8 System.out.println(file.canRead()?"文件可读":"文件不可读");9 System.out.println(file.canWrite()?"文件可写":"文件不可写");10 System.out.println(file.isFile()?"是一个文件":"不是一个文件");11 System.out.println(file.isDirectory()?"是一个目录":"不是一个目录");12 System.out.println(file.isAbsolute()?"是绝对路径":"不是绝对路径");13 System.out.println("最后修改时间"+file.lastModified());14 System.out.println("文件大小"+file.length()+"bytes");15 System.out.println("是否成功删除"+file.delete());16 }17 }

View Code

2、遍历目录下的文件(过滤)

1 public classExample27 {2 public static void main(String[] args) throwsException{3 File file = new File("/Users/Shared/第八章IO练习/src/datastream");4 FilenameFilter filenameFilter= newFilenameFilter() {5 @Override6 public booleanaccept(File dir, String name) {7 File currFile = newFile(dir,name);8 if (currFile.isFile()&&name.endsWith(".java")){9 return true;10 }else{11 return false;12 }13 }14 };15 if(file.exists()){16 String [] lists =file.list(filenameFilter);17 for(String name:lists){18 System.out.println(name);19 }20 }21 }22 }

View Code

3、删除文件及目录

1 importjava.io.File;2

3 public classExample30 {4 public static voidmain(String[] args) {5 File file =new File("/Users/Shared/第八章IO练习/src/delete");6 deleteDir(file);7 }8

9 public static voiddeleteDir(File dir) {10 if(dir.exists()){11 File[] files=dir.listFiles();12 for(File file:files){13 if(file.isDirectory()){14 deleteDir(file);15 }else{16 file.delete();17 }18 }19 dir.delete();20 }21 }22 }

View Code

五、RandomAccessFile

不属于流类，但具有读写文件数据的功能，可以随机地从文件任意位置开始执行读写数据操作。

1、应用场景：

①向10G文件末尾插入指定内容，或者向指定指针位置进行插入或者修改内容。

②断点续传，使用seek()方法不断的更新下载资源的位置。

2、构造方法与定位文件位置的方法

构造方法

方法声明

功能描述

RandomAccessFile(File file, String mode)

创建随机访问文件流，以从File参数指定的文件中读取，并可选择写入文件。

RandomAccessFile(String name, String mode)

创建随机访问文件流，以从中指定名称的文件读取，并可选择写入文件。

构造函数中mode参数传值介绍:

r 代表以只读方式打开指定文件 。

rw 以读写方式打开指定文件 。

rws 读写方式打开，并对内容或元数据都同步写入底层存储设备 。

rwd 读写方式打开，对文件内容的更新同步更新至底层存储设备 。

RandomAccesseFile定位文件位置的方法

方法声明

功能描述

long getFilePointer()

返回当前读写指针所处的位置

void seek(long pos)

设定读写指针的位置，与文件开头相隔pos个字节数

Int skipBytes(int n)

使读写指针从当前位置开始，跳过n个字节

Void setLength(long newLength)

设置此文件的长度

软件试用次数限制小案例：

1 public classExample31 {2

3 public static void main(String[] args) throwsException{4

5 //在time.txt文件中输入数字5

6

7 RandomAccessFile raf = new RandomAccessFile("time.txt","rw");8

9 int times = 0; //int类型的表露表示试用次数

10

11 times=Integer.parseInt(raf.readLine()); //第一次读取文件时times为5

12

13 if (times>0){14

15 //试用一次，次数减少一次

16

17 System.out.println("您还可以试用"+times--+"次数");18

19 raf.seek(0); //使用记录指针指向文件的开头

20

21 raf.writeBytes(times+""); //将剩余的次数再次写入文件

22

23 }else{24

25 System.out.println("软件试用次数已到");26

27 }28

29 raf.close();30

31 }32

33 }

View Code