黑马程序员之----------javaIO流File类



------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

 

 File 类操作

1.File类

File类是对文件系统中文件以及文件夹进行封装的对象，通过对象的思想来操作文件和文件夹。 

 

1. 构造函数-----初始化

 

public class Demo1 {

public static void main(String[] args){

//构造函数File(String pathname)

File f1=new File("d:\\abc\\t.txt");

//File(String parent,String child)

File f2=new File("d:\\abc","tt.txt");

//File(String parent,String child)

File f4=new File(f1,"tttt.txt");

//separator 跨平台分隔符,建议使用

File f3=new File("d:\\abc"+File.separator+"ttt.txt");

}

}

 

方法摘要
boolean	canRead()  测试应用程序是否可以读取此抽象路径名表示的文件。
boolean	canWrite()  测试应用程序是否可以修改此抽象路径名表示的文件。
int	compareTo(File pathname)  按字母顺序比较两个抽象路径名。
boolean	createNewFile()  当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
static  File	createTempFile(String prefix, String suffix)            在默认临时文件目录中创建一个空文件，使用给定前缀和后缀生成其名称。
static  File	createTempFile(String prefix, String suffix, File directory)             在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。
boolean	delete() 删除此抽象路径名表示的文件或目录。
boolean	equals(Object obj)  测试此抽象路径名与给定对象是否相等。
boolean	exists()  测试此抽象路径名表示的文件或目录是否存在。
File	getAbsoluteFile()  返回此抽象路径名的绝对路径名形式。
String	getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。
String	getName() 返回由此抽象路径名表示的文件或目录的名称。
String	getParent()   返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
File	getParentFile()  返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null。
String	getPath()  将此抽象路径名转换为一个路径名字符串。
boolean	isAbsolute()  测试此抽象路径名是否为绝对路径名。
boolean	isDirectory()  测试此抽象路径名表示的文件是否是一个目录。
boolean	isFile()  测试此抽象路径名表示的文件是否是一个标准文件。
boolean	isHidden()  测试此抽象路径名指定的文件是否是一个隐藏文件。
long	lastModified() 返回此抽象路径名表示的文件最后一次被修改的时间。
long	length() 返回由此抽象路径名表示的文件的长度。
String []	list() 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
String[]	list(FilenameFilter filter)  返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。
File[]	listFiles() 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
File[]	listFiles(FileFilter filter)            返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
File[]	listFiles(FilenameFilter filter)            返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。
static  File[]	listRoots() 列出可用的文件系统根。
boolean	mkdir() 创建此抽象路径名指定的目录。
boolean	mkdirs() 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
boolean	renameTo(File dest) 重新命名此抽象路径名表示的文件。
String	toString() 返回此抽象路径名的路径名字符串。

 

 

2. 基本操作

import java.io.File;

import java.io.IOException;

public class Demo2 {

public static void main(String[] args){

// 根据指定的路径创建一个File对象

String fileName="D:"+File.separator+"tt.txt";

File file=new File(fileName);

//创建文件

try{

file.createNewFile();

//当文件存在时返回false

}catch(IOException e){

e.printStackTrace();

}

// 获取该File对象的名字

System.out.println("文件名为："+file.getName());

// 获取该File对象的绝对路径

System.out.println("绝对路径为："+file.getAbsolutePath());

// 获取该File对象的相对路径

System.out.println("路径为："+file.getPath());

//获取该File对象的目录

System.out.println("所属磁盘目录为："+file.getParent());

// 判断该File对象是不是目录

if(!file.exists()){

file.mkdir();

}

System.out.println("此文件是目录吗："+file.isDirectory());

// 判断该File对象是否可读

System.out.println("它是处于可读状态吗？"+file.canRead());

// 判断该File对象是否可写

System.out.println("它是处于可写状态吗？"+file.canWrite());

// 获取该File对象中的字符长度

System.out.println("它是处于可写状态吗？"+file.length());

// 获取该File对象最后修改时间

System.out.println("此文件最后修改的为："+file.lastModified());

//当文件不存在时返回false

System.out.println(file.delete());

} 

}

 

File操作//创建文件

import java.io.File;

import java.io.IOException;

 

//此方法的主要作用是判断创建文件是否成功，如果成功则返回true否则返回false

public class Demo4 {

public static boolean createFile(String destFileName) {

File file = new File(destFileName); // 根据指定的文件名创建File对象

if (file.exists()) { // 判断该文件是否存在

System.out.println("创建单个文件" + destFileName + "失败，目标文件已存在！");

return false; // 如果存在，则不需创建则返回fasle

}

if (destFileName.endsWith(File.separator)) {// 如果传入的文件名是以文件分隔符结尾的，则说明此File对象是个目录而不是文件

System.out.println("创建单个文件" + destFileName + "失败，目标文件不能为目录！");

return false;// 因为不是文件所以不可能创建成功，则返回false

}

if (!file.getParentFile().exists()) {

// 如果目标文件所在的文件夹不存在，则创建父文件夹

System.out.println("创建" + file.getName() + "所在目录不存在，正在创建！");

if (!file.getParentFile().mkdirs()) {// 判断父文件夹是否存在，如果存在则表示创建成功否则不成功

System.out.println("创建目标文件所在的目录失败！");

return false;

}

}

// 创建目标文件

try {

if (file.createNewFile()) {// 调用createNewFile方法，判断创建指定文件是否成功

System.out.println("创建单个文件" + destFileName + "成功！");

return true;

} else {

System.out.println("创建单个文件" + destFileName + "失败！");

return false;

}

} catch (IOException e) {

e.printStackTrace();

System.out.println("创建文件" + destFileName + "失败！" + e.getMessage());

return false;

}

}

 

public static void main(String[] args) {

// 创建目录

String dirName = "D:/temp/aa";

// 创建文件

String fileName = dirName + "/bb/ccFile.txt";

Demo4.createFile(fileName);

}

}

 

移动某个指定的文件，但移动成功后不会覆盖已存在的目标文件

import java.io.File;

 

public class Demo6 {

// 移动某个指定的文件，但移动成功后不会覆盖已存在的目标文件

public static boolean moveA_File(String sourceFileName,

String targetFileName) {

return Demo6.moveA_File(sourceFileName, targetFileName, false);

}

 

// 移动某个指定的文件，但移动成功后可以根据isOverlay的值来决定是否覆盖已存在的目标文件

public static boolean moveA_File(String sourceFileName,

String targetFileName, boolean isOverlay) {

// 判断原文件是否存在

File sourceFile = new File(sourceFileName);

if (!sourceFile.exists()) {

System.out.println("移动文件失败：原文件" + sourceFileName + "不存在！");

return false;

} else if (!sourceFile.isFile()) {

System.out.println("移动文件失败：" + sourceFileName + "不是一个文件！");

return false;

}

File targetFile = new File(targetFileName);

if (targetFile.exists()) {// 判断目标文件是否存在

if (isOverlay) {// 如果目标文件存在，是否允许覆盖目标文件

// 删除已存在的目标文件，无论目标文件是目录还是单个文件

System.out.println("该文件已存在，准备删除它！");

if (!Demo5.deleteAnyone(targetFileName)) {

System.out.println("文件移动失败，删除文件" + targetFileName + "失败！");

return false;

}

} else {

System.out.println("文件移动失败，文件" + targetFileName + "已存在！");

return false;

}

} else {

if (!targetFile.getParentFile().exists()) {

// 如果目标文件所在的目录不存在，则创建目录

System.out.println("该文件所在目录不存在，正在创建！");

if (!targetFile.getParentFile().mkdirs()) {

System.out.println("移动文件失败，创建文件所在的目录失败！");

return false;

}

}

}

// 移动原文件至目标文件

if (sourceFile.renameTo(targetFile)) {

System.out.println("移动文件" + sourceFileName + "到" + targetFileName

+ "成功！");

return true;

} else {

System.out.println("移动文件" + sourceFileName + "到" + targetFileName

+ "失败！");

return true;

}

}

 

public static boolean moveDir(String sourceDirName, String targetDirName) {

// 默认为不覆盖目标文件

return Demo6.moveDir(sourceDirName, targetDirName, false);

}

 

// 移动某个指定的目录，但移动成功后可以根据isOverlay的值来决定是否覆盖当前已存在的目标目录

public static boolean moveDir(String sourceDirName, String targetDirName,

boolean isOverlay) {

// 判断原目录是否存在

File sourceDir = new File(sourceDirName);

if (!sourceDir.exists()) {

System.out.println("移动目录失败，原始目录" + sourceDirName + "不存在！");

return false;

} else if (!sourceDir.isDirectory()) {

System.out.println("移动目录失败，" + sourceDirName + "不是一个目录！");

return false;

}

// 如果目标文件夹名不以文件分隔符结尾，自动添加文件分隔符

if (!targetDirName.endsWith(File.separator)) {

targetDirName = targetDirName + File.separator;

}

File targetDir = new File(targetDirName);

// 如果目标文件夹存在，

if (targetDir.exists()) {

if (isOverlay) {

// 允许覆盖则删除已存在的目标目录

System.out.println("该目录已存在，准备删除它！");

if (!Demo5.deleteAnyone(targetDirName)) {

System.out.println("移动目录失败：删除目录" + targetDirName + "失败！");

}

} else {

System.out.println("移动目录失败：该目录" + targetDirName + "已存在！");

return false;

}

} else {

// 创建目标目录

System.out.println("该目录不存在，正在创建！");

if (!targetDir.mkdirs()) {

System.out.println("移动目录失败：创建该目录失败！");

return false;

}

}

boolean flag = true;

// 移动原目录下的文件和子目录到目标目录下

File[] files = sourceDir.listFiles();

for (int i = 0; i < files.length; i++) {

// 移动子文件

if (files[i].isFile()) {

flag = Demo6.moveA_File(files[i].getAbsolutePath(),

targetDirName + files[i].getName(), isOverlay);

if (!flag) {

break;

}

}

// 移动子目录

else if (files[i].isDirectory()) {

flag = Demo6.moveDir(files[i].getAbsolutePath(), targetDirName

+ files[i].getName(), isOverlay);

if (!flag) {

break;

}

}

}

if (!flag) {

System.out.println("目录" + sourceDirName + "移动到" + targetDirName

+ "失败！");

return false;

}

// 删除原目录

if (Demo5.deleteDir(sourceDirName)) {

System.out.println("目录" + sourceDirName + "移动到" + targetDirName

+ "成功！");

return true;

} else {

System.out.println("目录" + sourceDirName + "移动到" + targetDirName

+ "失败！");

return false;

}

}

 

public static void main(String[] args) {

// 移动文件，如果目标文件存在，则替换

System.out.println("调用moveA_File方法的结果如下：");

String sourceFileName = "D:\\temp\\keytoolcmd.txt";

String targetFileName = "D:\\test\\temp\\keytoolcmd.txt.";

Demo6.moveA_File(sourceFileName, targetFileName, true);

// 移动目录，如果目标目录存在，则不覆盖

System.out.println("\n调用moveDir方法的结果如下：");

String sourceDirName = "D:\\temp\\aa";

String targetDirName = "F:\\abc";

Demo6.moveDir(sourceDirName, targetDirName);

}

}

列出磁盘下的文件和文件夹

public class test {

public static void main(String[] args) {

File[] files = File.listRoots();

for (File file : files) {

System.out.println(file);

if (file.length() > 0) {

String[] filenames = file.list();

for (String filename : filenames) {

System.out.println(filename);

}

}

}

}

}

列出指定目录的全部文件（包括隐藏文件）：

 

使用listFiles列出指定目录的全部文件 listFiles输出的是完整路径

 

public class test {

public static void main(String[] args) {

String fileName = "D:" + File.separator;

File f = new File(fileName);

File[] str = f.listFiles();

for (int i = 0; i < str.length; i++) {

System.out.println(str[i]);

}

}

}

文件过滤

public class test {

public static void main(String[] args) {

File[] files = File.listRoots();

for (File file : files) {

System.out.println(file);

if (file.length() > 0) {

String[] filenames = file.list(new FilenameFilter() {

// file 过滤目录 name 文件名

public boolean accept(File file, String filename) {

return filename.endsWith(".mp3");

}

});

for (String filename : filenames) {

System.out.println(filename);

}

}

}

}

}

     

 

File[]  listFiles() 

File[] listFiles(FilenameFilter filter)

利用递归列出全部文件

public class test {

public static void main(String[] args) {

File f = new File("e:\\音樂");

showDir(f);

}

public static void showDir(File dir) {

System.out.println(dir);

File[] files = dir.listFiles();

for (File file : files) {

if (file.isDirectory())

showDir(file);

else

System.out.println(file);

}

}

}

 

 

移动文件 

找出d盘下所有的 .java 文件，拷贝至 c:\jad 目录下，并将所有文件的类型由.java 修改为.jad 。

public class test {

public static void main(String[] args) {

File f1 = new File("d:\\");

moveFile(f1);

}

 

public static void moveFile(File dir) {

File[] files = dir.listFiles();

for (File file : files) {

if (file.isDirectory())

moveFile(file);

else {

if (file.getName().endsWith(".java"))

file.renameTo(new File("c:\\jad\\"

+ file.getName().substring(0,

file.getName().lastIndexOf('.')) + ".jad"));

}

}

}

}

 

 

接口 FilenameFilter

实现此接口的类实例 可用于过滤器文件名。

boolean accept(File dir,String name)

文件name是否应该包含在文件列表dir中。

 

过滤文件方法

public class Demo3 implements FilenameFilter{

// 定义文件的后缀名

private String st="";

// 用构造方法为st变量赋值

public Demo3(String st){

this.st=st;

}

// 重写FilenameFilter接口中的accept方法，判断指定的文件是否在指定的目录中

public boolean accept(File dir, String name) {

if(new File(dir,name).isFile()){

// 如果当前的File对象是一个文件，则返回它是否以指定的后缀结束，是返回true

return name.endsWith(st);

}else{

// 如果是文件夹，则直接返回true

return true;

}

}

}

案例：过滤文件

public class Demo3 {

//获得文件后缀名

public static class MyFileNameFilter implements FilenameFilter{

// 定义文件的后缀名

private String st="";

// 用构造方法为st变量赋值

public MyFileNameFilter(String st){

this.st=st;

}

// 重写FilenameFilter接口中的accept方法，判断指定的文件是否在指定的目录中

public boolean accept(File dir, String name) {

if(new File(dir,name).isFile()){

// 如果当前的File对象是一个文件，则返回它是否以指定的后缀结束，是返回true

return name.endsWith(st);

}else{

// 如果是文件夹，则直接返回true

return true;

}

}

}

//获得文件夹下所有文件

public static void getAllFiles(String dirName){

// 列出指定目录下所有文件和子目录的路径

if(!dirName.endsWith(File.separator)){

// 如果dir不以文件分隔符结尾，自动添加文件分隔符。

dirName=dirName+File.separator;

}

File dirFile=new File(dirName);

if(!dirFile.exists()||(!dirFile.isDirectory())){

// 如果dir对应的文件不存在，或者不是一个文件夹，则退出

System.out.println("失败，找不到指定目录"+dirName);

return;

}

// 列出源文件夹下所有文件（包括子目录）

File[] fileArray=dirFile.listFiles();

for(int i=0;i<fileArray.length;i++){

if(fileArray[i].isFile()){

System.out.println(fileArray[i].getAbsolutePath()+" ");

}else if(fileArray[i].isDirectory()){

System.out.println(fileArray[i].getAbsolutePath()+" ");

Demo3.getAllFiles(fileArray[i].getAbsolutePath());

}

if((i+1)%2==0)

System.out.println();

}

}

//获得符合条件的文件

public static void getFilesByFilter(FilenameFilter filter,// 获取在指定目录下符合指定后缀文件名的所有文件

String dir_Path) {

if (!dir_Path.endsWith(File.separator)) {// 如果目录路径不是以文件分隔符结尾则自动添加文件分隔符。

dir_Path = dir_Path + File.separator;

}

File dir_File = new File(dir_Path);

if (!dir_File.exists() || (!dir_File.isDirectory())) {// 如果指定的目录不存在或不是一个目录则返回

System.out.println("失败！找不到指定目录：" + dir_Path);

return;

}

// 列出指定目录下的所有符合过滤器条件的文件（包括子目录）

File[] fileArray = dir_File.listFiles(filter);

for (int i = 0; i < fileArray.length; i++) {

if (fileArray[i].isFile()) {

System.out.println(fileArray[i].getAbsolutePath() + " 是文件!");

} else if (fileArray[i].isDirectory()) {

System.out.println(fileArray[i].getAbsolutePath() + " 是目录!");

Demo3.getFilesByFilter(filter, fileArray[i].getAbsolutePath());

}

}

}

 

 

public static void main(String[] args) {

String dir = "D:\\workspace\\泛型\\src\\泛型";

System.out.println((dir + "目录下的内容: "));

Demo3.getAllFiles(dir);

System.out.println();

System.out.println("符合过滤器条件的文件如下：");

// 新建一个文件名过滤器。参数为".txt"

MyFileNameFilter myFilenameFilter = new MyFileNameFilter(".java");

Demo3.getFilesByFilter(myFilenameFilter, dir);

}

}

 

3.RandomAccessFile类

该对象并不是流体系中的一员，其封装了字节流，同时还封装了一个缓冲区（字符数组），

通过内部的指针来操作字符数组中的数据。 该对象特点：

 1. 该对象只能操作文件，所以构造函数接收两种类型的参数：a.字符串文件路径；b.File对象。

2. 该对象既可以对文件进行读操作，也能进行写操作，在进行对象实例化时可指定操作模式(r,rw)

注意：该对象在实例化时，如果要操作的文件不存在，会自动创建；

如果文件存在，写数据未指定位置，会从头开始写，即覆盖原有的内容。 

可以用于多线程下载或多个线程同时写数据到文件。

* 使用RandomAccessFile写入文件

 进行写操作

public class Demo1 {

// 所有的异常直接抛出，程序中不再进行处理

public static void main(String args[]) throws Exception{

File f = new File("d:" + File.separator + "test.txt") ; // 指定要操作的文件

RandomAccessFile rdf = null ; // 声明RandomAccessFile类的对象

rdf = new RandomAccessFile(f,"rw") ;// 读写模式，如果文件不存在，会自动创建

String name = null ;

int age = 0 ;

name = "zhangsan" ; // 字符串长度为8

age = 30 ; // 数字的长度为4

rdf.writeBytes(name) ; // 将姓名写入文件之中

rdf.writeInt(age) ; // 将年龄写入文件之中

name = "lisi    " ; // 字符串长度为8

age = 31 ; // 数字的长度为4

rdf.writeBytes(name) ; // 将姓名写入文件之中

rdf.writeInt(age) ; // 将年龄写入文件之中

name = "wangwu  " ; // 字符串长度为8

age = 32 ; // 数字的长度为4

rdf.writeBytes(name) ; // 将姓名写入文件之中

rdf.writeInt(age) ; // 将年龄写入文件之中

rdf.close() ; // 关闭

}

}

 

进行读操作

import java.io.File;

import java.io.RandomAccessFile;

 

public class Demo2 {

// 所有的异常直接抛出，程序中不再进行处理

public static void main(String args[]) throws Exception{

File f = new File("d:" + File.separator + "test.txt") ; // 指定要操作的文件

RandomAccessFile rdf = null ; // 声明RandomAccessFile类的对象

rdf = new RandomAccessFile(f,"r") ;// 以只读的方式打开文件

String name = null ;

int age = 0 ;

byte b[] = new byte[8] ; // 开辟byte数组

// 读取第二个人的信息，意味着要空出第一个人的信息

rdf.skipBytes(12) ; // 跳过第一个人的信息

for(int i=0;i<b.length;i++){

b[i] = rdf.readByte() ; // 读取一个字节

}

name = new String(b) ; // 将读取出来的byte数组变为字符串

age = rdf.readInt() ; // 读取数字

System.out.println("第二个人的信息 --> 姓名：" + name + "；年龄：" + age) ;

// 读取第一个人的信息

rdf.seek(0) ; // 指针回到文件的开头

for(int i=0;i<b.length;i++){

b[i] = rdf.readByte() ; // 读取一个字节

}

name = new String(b) ; // 将读取出来的byte数组变为字符串

age = rdf.readInt() ; // 读取数字

System.out.println("第一个人的信息 --> 姓名：" + name + "；年龄：" + age) ;

rdf.skipBytes(12) ; // 空出第二个人的信息

for(int i=0;i<b.length;i++){

b[i] = rdf.readByte() ; // 读取一个字节

}

name = new String(b) ; // 将读取出来的byte数组变为字符串

age = rdf.readInt() ; // 读取数字

System.out.println("第三个人的信息 --> 姓名：" + name + "；年龄：" + age) ;

rdf.close() ; // 关闭

}

}

 

3.RandomAccessFile类

包含了完全类似于InputStream的read方法和OutputStream的write方法，用法和原来的都一样；而且还包含了readXxx、writeXxx的输入输出方法；

该对象并不是流体系中的一员，其封装了字节流，同时还封装了一个缓冲区（字符数组），

通过内部的指针来操作字符数组中的数据。 所以RandomAccessFile可以不从开始的地方输出，RandomAccessFile可以向已经存在的文件后追加内容。可以随机访问的方式，操作文件数据。

long getFilePointer()：返回文件记录指针的当前位置

void seek(long pos)：将文件记录指针定位到pos位置

RandomAccessFile既可以读也可以写，所以它RandomAccessFile的文件访问模式：

r：以只读方式打开指定文件

rw：以读取、写入方式打开指定文件，如果文件不存在就创建

rws：以读取、写入的方式打开指定文件，相对应rw模式，还要求文件内容和元数据的每个更新都同步写入到底层存储设备

rwd：以读取、写入方式打开指定文件，对于rw，还要求文件内容的每个更新都同步写入到底层设备

 

00001. 1. 该对象只能操作文件，所以构造函数接收两种类型的参数：a.字符串文件路径；b.File对象。

00002. 2. 该对象既可以对文件进行读操作，也能进行写操作，在进行对象实例化时可指定操作模式(r,rw)

注意：该对象在实例化时，如果要操作的文件不存在，会自动创建；

如果文件存在，写数据未指定位置，会从头开始写，即覆盖原有的内容。 

可以用于多线程下载或多个线程同时写数据到文件。

 

 

* 使用RandomAccessFile写入文件

 进行写操作

public class Demo1 {

// 所有的异常直接抛出，程序中不再进行处理

public static void main(String args[]) throws Exception{

File f = new File("d:" + File.separator + "test.txt") ; // 指定要操作的文件

RandomAccessFile rdf = null ; // 声明RandomAccessFile类的对象

rdf = new RandomAccessFile(f,"rw") ;// 读写模式，如果文件不存在，会自动创建

String name = null ;

int age = 0 ;

name = "zhangsan" ; // 字符串长度为8

age = 30 ; // 数字的长度为4

rdf.writeBytes(name) ; // 将姓名写入文件之中

rdf.writeInt(age) ; // 将年龄写入文件之中

name = "lisi    " ; // 字符串长度为8

age = 31 ; // 数字的长度为4

rdf.writeBytes(name) ; // 将姓名写入文件之中

rdf.writeInt(age) ; // 将年龄写入文件之中

name = "wangwu  " ; // 字符串长度为8

age = 32 ; // 数字的长度为4

rdf.writeBytes(name) ; // 将姓名写入文件之中

rdf.writeInt(age) ; // 将年龄写入文件之中

rdf.close() ; // 关闭

}

}

 

进行读操作

import java.io.File;

import java.io.RandomAccessFile;

 

public class Demo2 {

// 所有的异常直接抛出，程序中不再进行处理

public static void main(String args[]) throws Exception{

File f = new File("d:" + File.separator + "test.txt") ; // 指定要操作的文件

RandomAccessFile rdf = null ; // 声明RandomAccessFile类的对象

rdf = new RandomAccessFile(f,"r") ;// 以只读的方式打开文件

String name = null ;

int age = 0 ;

byte b[] = new byte[8] ; // 开辟byte数组

// 读取第二个人的信息，意味着要空出第一个人的信息

rdf.skipBytes(12) ; // 跳过第一个人的信息

for(int i=0;i<b.length;i++){

b[i] = rdf.readByte() ; // 读取一个字节

}

name = new String(b) ; // 将读取出来的byte数组变为字符串

age = rdf.readInt() ; // 读取数字

System.out.println("第二个人的信息 --> 姓名：" + name + "；年龄：" + age) ;

// 读取第一个人的信息

rdf.seek(0) ; // 指针回到文件的开头

for(int i=0;i<b.length;i++){

b[i] = rdf.readByte() ; // 读取一个字节

}

name = new String(b) ; // 将读取出来的byte数组变为字符串

age = rdf.readInt() ; // 读取数字

System.out.println("第一个人的信息 --> 姓名：" + name + "；年龄：" + age) ;

rdf.skipBytes(12) ; // 空出第二个人的信息

for(int i=0;i<b.length;i++){

b[i] = rdf.readByte() ; // 读取一个字节

}

name = new String(b) ; // 将读取出来的byte数组变为字符串

age = rdf.readInt() ; // 读取数字

System.out.println("第三个人的信息 --> 姓名：" + name + "；年龄：" + age) ;

rdf.close() ; // 关闭

}

}

 

 

 

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------