Java入门——（7）IO（输入与输出）
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 class Example01 { 2 public static void main(String[] args) throws Exception{ 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<bytes.length;i++){ 20 OutputStream.write(bytes[i]); 21 } 22 OutputStream.close(); 23 } 24 }
文件拷贝：
1 public class Example04 { 2 public static void main(String[] args) throws Exception{ 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 }
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 class Example07 { 2 public static void main(String[] args) throws Exception{ 3 //创建一个带缓冲区的输入流 4 BufferedInputStream bis = new BufferedInputStream( 5 new FileInputStream("src.txt")); 6 //创建一个带缓冲区的输出流 7 BufferedOutputStream bos = new BufferedOutputStream( 8 new FileOutputStream("des.txt")); 9 int len; 10 while ((len=bis.read())!=-1){ 11 bos.write(len); 12 } 13 bis.close(); 14 bos.close(); 15 } 16 }
二、字符流
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 class Example10 { 2 public static void main(String[] args) throws Exception{ 3 FileReader reader = new FileReader("src.txt"); 4 //创建一个BufferedReader缓冲对象 5 BufferedReader br = new BufferedReader(reader); 6 FileWriter writer = new FileWriter("des.txt"); 7 //创建一个BufferedWriter缓冲对象 8 BufferedWriter bw = new BufferedWriter(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 }
BufferedReader一直接子类——LineNumberReader ,一个可以跟踪行号的输入流。
1 public class Example11 { 2 public static void main(String[] args) throws Exception{ 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 }
5、转换流
转换流是一种字符流，只能实现字节流读写文本数据的时候，通过转换流来使用字符高效流的方法。而不能实现图片、音频等数据的读写。
InputStreamReader:理解上是字节流通向字符流的桥梁，使用上为：
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
OutputStreamWriter:理解上是字符流通向字节流的桥梁，使用上还是通过字节流转成字符流：
BufferedWriter bw = new BufferedWriter (new OutputStreamWriter(System.out));
1 public class Example12 { 2 public static void main(String[] args) throws Exception{ 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 = new OutputStreamWriter(out); 9 //对字符输出流对象进行包装 10 BufferedWriter bw = new BufferedWriter(osw); 11 String line; 12 while ((line=br.readLine())!=null){ //判断是否读到文件末尾 13 bw.write(line); //输出读取到文件 14 } 15 br.close(); 16 bw.close(); 17 } 18 }
三、其他IO流
1、ObjectOutputStream、ObjectInputStream
序列化：把对象按照流一样的方式传输或者存储。(ObjectOutputStream).
当对象进行序列化时，必须保证该对象实现Serializable接口，否则程序会出现NotSerializableException异常。
反序列号：把网络中的流数据或者文件中的流数据（二进制数据）还原成对象。(ObjectInputStream).
1 public class Example13 { 2 public static void main(String[] args) throws Exception{ 3 //序列化对象 4 Person person = new Person("p1","zhangsan",20); 5 //创建文件输出流对象，将数据写入objectStream.txt 6 FileOutputStream fos = new FileOutputStream("objectStream.txt"); 7 //创建对象输出流对象，用于处理输出流对象写入的数据 8 ObjectOutputStream oos = new ObjectOutputStream(fos); 9 //将Person对象输出到输出流中 10 oos.writeObject(person); 11 oos.close(); 12 13 //反序列化对象 14 FileInputStream fis = new FileInputStream("object.txt"); 15 //创建文件输入流对象，用于读取指定文件的数据 16 ObjectInputStream ois = new ObjectInputStream(fis); 17 //创建对象输入流，并且从指定的输入流中过读取数据 18 Object p = ois.readObject(); 19 System.out.println(p); 20 ois.close(); 21 } 22 } 23 class Person implements Serializable{ 24 private String id; 25 private String name; 26 private int age; 27 public Person(String id, String name, int age) { 28 super(); 29 this.id = id; 30 this.name = name; 31 this.age = age; 32 } 33 public String getId() { 34 return id; 35 } 36 public String getName() { 37 return name; 38 } 39 public int getAge() { 40 return age; 41 } 42 }
2、DataInputStream,DataOutputStream
有时候并不需要存储整个对象的信息，而只需要存储对象的成员数据，这些成员数据的类型又都是基本数据类型，可使用数据操作流：DataInputStream,DataOutputStream 。
1 public class Example15 { 2 public static void main(String[] args) throws Exception{ 3 BufferedOutputStream bos = new BufferedOutputStream( 4 new FileOutputStream("/Users/Shared/ioexample/dataStream.txt")); 5 DataOutputStream dos = new DataOutputStream(bos); 6 dos.writeByte(12); //写一个字节 7 dos.writeChar('1'); //写一个字符 8 dos.writeBoolean(true); //写一个布尔值 9 dos.writeUTF("同学，你好"); //写一个转换成UTF-8的字符串 10 dos.close(); //关闭流 11 BufferedInputStream bis= new BufferedInputStream( 12 new FileInputStream("/Users/Shared/ioexample/dataStream.txt")); 13 DataInputStream dis = new DataInputStream(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 }
只有读取数据的顺序与写数据的顺序保持一致，才能保证最终数据的正常性。
3、打印流PrintStream
1 public class Example16 { 2 public static void main(String[] args) throws Exception{ 3 PrintStream ps = new PrintStream( 4 new FileOutputStream("printStream.txt",true)); 5 Student stu = new Student(); 6 ps.print("这是一个数字"); 7 ps.println(19); 8 ps.println(stu); 9 } 10 } 11 class Student { 12 @Override 13 public String toString() { 14 return "我是一个学生"; 15 } 16 }
4、标准输入输出流（in、out、err）
1 public class Example17 { 2 public static void main(String[] args) throws Exception{ 3 StringBuffer sb = new StringBuffer(); 4 int ch; 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 }
|
重定向流常用的静态方法
|
|
|
方法声明
|
功能描述
|
|
void setIn(InputStream in)
|
对标准输入流重定向
|
|
void setOut(PrintStream out)
|
对标准输出流重定向
|
|
void setErr(PrintStream out)
|
对标准错误输出流重定向
|
5、管道流（PipedInputStream、PipedOutputStream）
多线程之间可以通过此管道流实现数据的传输。
1 public class Example19 { 2 public static void main(String[] args) throws Exception{ 3 final PipedInputStream pis = new PipedInputStream();//创建PipedInputStream对象 4 final PipedOutputStream pos = new PipedOutputStream(); 5 //PipedInputStream和PipedOutputStream建立连接，也可写成pos.connect(pis) 6 pis.connect(pos); 7 new Thread(new Runnable(){ //创立线程 8 public void run(){ 9 //将从键盘读取的数据写入管道流中 10 BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 11 //将从键盘读取的数据写入管道流中 12 PrintStream ps = new PrintStream(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(new Runnable() { 24 @Override 25 public void run() { 26 //下面代码是从管道流中读取数据，每读一行数据输出一次 27 BufferedReader br = new BufferedReader(new InputStreamReader(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 }
6、ByteArrayOutputStream、ByteArrayInputStream
将数据写入（读取）到缓冲区，最后一次性写入（输出）到文件。
如果读取的文件非常大，就不能使用这个列，否则会造成内存溢出。
1 public class Example20 { 2 public static void main(String[] args) throws Exception{ 3 //将数据写入缓冲区中 4 FileInputStream fs = new FileInputStream("source.txt"); 5 //创建一个字接数据缓冲区 6 ByteArrayOutputStream bos = new ByteArrayOutputStream(); 7 FileOutputStream fos = new FileOutputStream("target1.txt"); 8 //下面的代码是循环读取缓冲区中的数据，并将数据一次性写入文件 9 int b1; 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 int b2; 23 while ((b2=bis.read())!=-1){ 24 System.out.println((char)b2); 25 } 26 bis.close(); 27 } 28 }
7、CharArrayReader和CharArrayWriter
将字符型数据临时存入缓冲区。
1 public class Example22 { 2 public static void main(String[] args) throws Exception{ 3 FileReader fr = new FileReader("A.txt");//创建一个FileReader对象 4 CharArrayWriter cw = new CharArrayWriter();//在内存中创建一个字符数组缓冲区 5 //下面打代码是将数据写入缓冲区 6 int b; 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 }
8、SequenceInputStream
SequenceInputStream类可以将几个输入流串联在一起。
构造方法：
1、SequenceInputStream(InputStream s1, InputStream s2)2、SequenceInputStream(Enumeration<? extends InputStream> e)
1 import java.io.FileInputStream; 2 import java.io.FileOutputStream; 3 import java.io.SequenceInputStream; 4 import java.util.Enumeration; 5 import java.util.Vector; 6 7 public class Example24 { 8 public static void main(String[] args) throws Exception{ 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 = new SequenceInputStream(e); 21 FileOutputStream fs= new FileOutputStream("stream.txt"); 22 int len; 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 }
四、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 class Example25 { 2 public static void main(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 }
2、遍历目录下的文件（过滤）
1 public class Example27 { 2 public static void main(String[] args) throws Exception{ 3 File file = new File("/Users/Shared/第八章IO练习/src/datastream"); 4 FilenameFilter filenameFilter= new FilenameFilter() { 5 @Override 6 public boolean accept(File dir, String name) { 7 File currFile = new File(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 }
3、删除文件及目录
1 import java.io.File; 2 3 public class Example30 { 4 public static void main(String[] args) { 5 File file =new File("/Users/Shared/第八章IO练习/src/delete"); 6 deleteDir(file); 7 } 8 9 public static void deleteDir(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 }
五、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 class Example31 { 2 3 public static void main(String[] args) throws Exception{ 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 }
