文件

最新推荐文章于 2025-09-07 20:32:33 发布

weixin_33786077

最新推荐文章于 2025-09-07 20:32:33 发布

阅读量76

点赞数

CC 4.0 BY-SA版权

文章标签： java

原文链接：http://blog.51cto.com/saibro/1184367

本文详细介绍了Java中File类的功能及使用方法，包括文件和目录的创建、删除、重命名、属性获取等操作，同时深入探讨了文件输入输出流、字节缓存流等高级特性。

1. File 类用来代表一个文件，一个目录名或一个目录名和文件名组合。
File类共提供了3中构造方法
1. File(String path) Path可是带绝对路径的文件名，带相对路径的文件名，或者某个目录
2. File(String path,String name) path表示所对应的文件或目录的绝对或相对路径，name表示文件或目录名
3. File(File dir,String name) 使用一个已有的File对象作为参数，表示文件或目录的路径，第二个字符表示文件名或目录名
2. 建立与删除文件
创建文件
public boolean createNewFile();创建一个空文件
重命名文件
public boolean renameTo(File newFile);将文件重命名成newFile对应的文件名
删除文件
public void delete();删除文件
创建目录
public boolean mkdir();创建当前目录的子目录
下面一组句子将文件改名并且设置成只读
File f=new File("c:\t.txt");
f.renameTo(new File("c:\tt.txt"));
f.setReadOnly();
下面的语句建立目录
File f=new File("c:\demo"); 其中的参数是要建立文件名
f.mkdir();
下面的语句建立文件后将其删除
File f=new File("demo.txt");
f.delete();
3. 获取文件或目录的属性
判断文件或目录是否存在
public boolean exists();
判断是文件还是目录
public boolean isFile();
public boolean isDirectory();
获取文件或目录名称与路径
public String getName();
public String getPath();
获取文件的长度
public long length();
获取文件的读写属性
public boolean canRead();
public boolean canWrite();
比较两个文件或目录
public boolean equals(File f);
4. 获取目录成员
File类有个String list[] 方法，可以将目录中所有文件名保存在一个字符串数组中，然后逐一的将这些文件显示出来
代码如下：
import java.io.File;
public class tt{
public void static print(String s){
System.out.print(s);
}
public static void main(String args[]){
String path=".";
File f=new File(path);
if(f.isDirectory()){
print("文件路径"+path+"\n");
String s[]=f.list();
for(int i=0;i<f.length;i++){
File ff=new File(path,s[i]);
if(ff.isDrectory()){
print(s[i]+"是个目录\n");
}elseif(ff.isFile()){
print(s[i]+"是个文件\n");
print(ff.canRead()?"可以读取\n":"不可以读取\n");
}
}
}
}
}
5. 文件名过滤
可以利用文件名过滤器接口(FilenameFilter)将其他类型的文件过滤掉，只保留所需要的文件
该接口包含唯一的抽象方法 boolean accept (File dir,String name);
建立一个文件名过滤器的方法如下：
1. 定义一个实现FilenameFilter 接口的类，如 FileFilterDemo
2. 定义要保留文件名和后缀名的成员变量 name 和 ext
3. 定义该类的构造方法，并设置参数能够初始化成员变量
4. 定义accept方法，利用字符串的startWith(name)方法和endWith(ext)方法，判断是否符合文件名和后缀名
例子如下：
class FilenameFilterDemo implements FilenameFilter{
private name;
private ext;
public FilenameFilterDemo(String name,String ext){
this.name=name;
this.ext=ext;
}
public boolean accept(File dir,String filename){
boolean fString=true;
if(name!=null){
fString &= filename.startWith(name);
}
if(ext!=null){
fString &= filename.endWith(ext);
}
return (fString);
}
}
定义好文件名过滤器后，将工作目录作为参数，建立File 对象
创建文件名过滤对象，并将要提取的文件名和后缀名作为创建时的构造方法参数
使用File对象调用list() 对象，并将过滤类的对象作为list()的参数
例子如下：
import java.io.*;
class FilenameFilterDemo implements FilenameFilter{
private name;
private ext;
public FilenameFilterDemo(String name,String ext){
this.name=name;
this.ext=ext;
}
public boolean accept(File dir,String filename){
boolean fString=true;
if(name!=null){
fString &= filename.startWith(name);
}
if(ext!=null){
fString &= filename.endWith(ext);
}
return (fString);
}
public class javadir{
static void print(String s){
System.out.print(s);
}
public static void main(String args[]){
File path=new File(".");
print("文件路径"+path);
FilenameFilter x=new FilenameFilterDemo(args[0],args[1]);
String s[]=path.list(x);
for(int i=0;i<s.length;i++){
print(s[i]);
}
}
}
}
6. 文件输入流(FileInputString)
FileInputString类是从InputStream类派生出来的简单输入流类，它可以处理简单的文件传输操作
它的构造方法有三种形式
FileInputStream(String filename) FileInputStream(File file) FileInputStream(FileDescriptor fd)
FileInputStream的构造方法用于建立一个从文件中读取底层数据的字节流
此类的主要方法
int read() 从流中读入一个字节，并将该字节作为一个整数返回，若没有数据则返回-1
int read(byte b[]) 该方法以一个字节型数组作为参数，可以用于一次读取多个字节，读入的字节直接放入数组b[]中，并返回读取的字节数
long skip(long n)throws IOException 跳过指定的字节数
int available()throws IOException 返回当前流中可用的字节数
void close() 关闭当前流对象
例子如下：
import java.io.*;
public class javadir{
public static void print(String s){
System.out.print(s);
}
public static void main(String args[]) throws Exception{
int size=f.available();
FileInputStream f=new FileInputStream("t.txt");
print("该文件共有"+size+"字节");
byte data[]=new byte[size];
if(f.read(data)!=size) print("不能读取\n");
else print(new String(data,0,size));
f.close();
}
}
7. 文件输出流(FileOutputStream)
它可以简单的向文件写入数据
它的构造方法有三种：
FileOutputStream(String filename) FileOutputStream(File file) FileOutputStream(FileDescript fd)
需要注意的是，如果用一个已经存在的文件名创建一个FileOutputStream对象，则这个文件将在无警告的情况下被一个空文件覆盖
常用的方法有如下几种：
write(int b) 向流中写入一个字节
write(byte[] b)向流中写入一个字节数组
write(byte[] b,int off,int len) 在从数组的第off个位置，写入len个数据
void close() 关闭流对象
import java.io.*;
public class javadir{
public static void print(String s){
System.out.print(s);
}
public static void main(String args[]) throws Exception{
byte []data="you will never win,if you do not begin".getBytes();//“”部分是一个字符串对象，因此可以调用getBytes()方法，该方法将字符串对象根据所在平台默认的字符集编码成字节数据序列，然后存储到data字节中
FileOutputStream f=new FileOutputStream("t.txt");
for(int i=0;i<data.length;i++){ f.write(data[i]); }
FileOutputStream ff=new FileOutputStream("t.txt",true);
ff.write(data);
FileOutputStream fff=new FileOutputStream("t.txt",true);
fff.write(data,0,18);
f.close();
ff.close();
fff.close();
}
}
8. 字节数组输入流(ByteArrayInputStream)
它可以用于读取字节数组，并存入字节数组输入流对象中
它的构造方法如下：
ByteArrayInputStream(byte[] bytedata) ByteArrayInputStream(byte[] bytedata,int start,int len)
它的主要方法有：
int read() int read(byte b[]) long skip(long n) int available() void close()
Synchronized void mark(int readlimit) 在流中标记一个位置
Synchronized void reset() throws IOException 重新设置到流中上一次mark方法所标记的位置
boolean markSupport() 返回一个表示流是否支持mark，reset操作的布尔值
例子如下：
import java.io.*;
public class javadir{
public static void print(char s){
System.out.print(s);
}
public static void main(String args[]) throws Exception{
byte[] data="success is never ending ".getBytes();
ByteArrayInputStream f=new ByteArrayInputStream(data);
int ch;
while((ch=f.read())!=-1) print((char)ch);
}
}
字节数组输出流(ByteArrayOutputStream)
它可以将字节数组中的数据输出到ByteArrayOutputStream中
它的构造方法如下：
ByteArrayOutputStream() ByteArrayOutputStream(int len)
int len 为输出的字节数，如果建立该对象是未设置输出长度，则预设32个字节
此类除了具有一般OutputStream所具有的方法外如 void write(int b) void write(byte b[]) write(byte b[],int off,int len) void close()
还有两个常用的方法 byte[] toByteArray 配置一个新的字节组 void writeto(OutputStream out) 将ByteArrayOutputStream对象的内容写入OUTputStrean对象中
此类的第一个构造方法直接读取字节数组bytedata的全部元素到字节数组输出流对象中，第二个构造方法从字节数组bytedata中一Start为起点读取len个字节到字节数组输出流对象中
9. 数据输出流(DataOutputStream)
向输出流中写Java的基本数据类型，写入的数据和方式是可以移植的，它们能用对应的DataInputStream类读取，
它的构造方法如下：
public DataOutputStream(OutputStream out) out是一个OutputStream对象，所以必须创建一个OutputStream对象
DataOutputStream提供了多个方法来输出各种类型的数据，除了一般输出流具有的void write
还有以下方法：
public final void writeBoolean(boolean v)
public final void writeByte(int v)
public final void writeChar(int v)
public final void writeInt(int v)
public final void writeDouble(double v)
public final void writeBytes(String s)
public final void writeUTF(String str)//写的是一个采用UTF_8编码的字符串，使得字符串数据独立于平台
例子如下：
import java.io.*;
public class javadir{
public static void main(String args[]){
double e=2.7;
int i=8;
boolean ok=true;
char cc='A';
String s="2010 expo";
try{
FileOutputStream fs_out=new FileOutputStream("t.txt");
DataOutputStream out=new DataOutputStream(fs_out);
out.writeDouble(e);
out.writeInt(i);
out.writeBoolean(ok);
out.writeChar(cc);
out.writeUTF(s);
out.close();
}catch(FileNotFoundException fe){
System.out.println(fe);
}catch(IOException ioe){
System.out.println(ioe);
}
}
}
数据输入流(DataInputStream)
这个类已与机器无关的方式从一个流中读取java的基本类型，所读的数据应是DataOutputStream对象所写入的
它的构造方法如下：
public DataOutputStream(InputStream) 此构造方法需要一个底层的输入对象作为参数，如FileInputStream的对象
该类除了int read()等方法外，还有一些直接读取基本类型的成员方法
public final int skipBytes(int n)
public final boolean readBoolean()
public final byte readByte()
public final char readChar()
public final int readInt()
public final double readDouble()
public final String readString()
例子如下：
import java.io.*;
public class javadir{
public static void main(String args[]){
try{
FileInputStream fs_in=new FileInputStream("t.txt");
DataInputStream in=new DataInputStream(fs_in);
double e=in.readDouble();System.out.println(e);
int i=in.readInt();System.out.println(i);
boolean ok=in.readBoolean();System.out.println(ok);
char cc=in.readChar();System.out.println(cc);
String s=in.readUTF();System.out.println(s);
in.close();
}catch(FileNotFoundException fd){
System.out.println(fd);
}catch(IOException ioe){
System.out.println(ioe);
}
}
}
11. 缓存输出流(BufferedOutputStream)
此类增强了输出流的批量数据输出能力，它与另一个输出流相连，将它作为自己的输入，
它可以从与它相连的输出流中填充数据到内部缓存，一次输出
它的构造方法如下：
public BufferedOutputStream(OutputStream out)
public BufferedOutputStream(OutputStream out,int len) len是缓存大小
其主要方法除了 void write(int b)等还有一个常用的方法，void flush() throws IOException该方法清空流并强制将缓存区的数据写入到流中
例子如下：
import java.io.*;
public class javadir{
public static void main(String args[]){
try{
long start=System.currentTimeMillis();
FileOutputStream fs_out=new FileOutputStream("t.txt");
BufferedOutputStream bfs_out=new BufferedOutputStream(fs_out);
DataOutputStream out=new DataOutputStream(bfs_out);
for(int i=0;i<10000;i++){
out.writeDouble(Math.random());
}
out.close();
long stop=System.currentTimeMillis();
System.out.println("时间差为:"+(stop-start));
}catch(FileNotFoundException fd){
System.out.println(fd);
}catch(IOException ioe){
System.out.println(ioe);
}
}
}
缓存输入流(BufferedInputStream)
此类增强了输入流的批量数据处理能力，它与另一个输入流相连，将它作为自己的输入，当读物==读取或跳过流中的字节时，
就会从与它相连的输入流中在填充数据到内部缓存
它的构造方法如下：
public BufferedInputStream(InputStream in) public BufferedInputStream(InputStream in,int len)
10. 格式化输出流(PrintStream)
它的常用构造方法如下：
PrintStream(OutputStream out) PrintStream(OutputStream out,boolean flag) flag是个清理标识，flag为true是，当换行符'\n'出现在输出流中，PrintStream会自动输出流中的数据；
flag 为false 时，当换行符'\n'出现在输出流中,PrintStream则不会自动输出流中的数据
它有如下形式的write() 方法； public void write(int b) public void write(byte b[],int off,int len)
例子如下：
import java.io.*;
public class javadir{
public static void main(String args[]) throws Exception{
PrintStream outfile=new PrintStream(new FileOutputStream("t.txt"));
outfile.println("sin 30 degree="+Math.sin(Math.sin(Math.PI/6)));
System.out.println("sin 30 degree="+Math.sin(Math.sin(Math.PI/6)));
outfile.close();
}
}
11. 字符集输入流(Reader)
此方法以一个字符型数组作为参数，可用于一次读取多个字符，读入字符直接放入数组中，并返回读取的字符数
该方法类似于上一中read方法，不同的是设置了偏移量off 。这里的偏移量指的是可以从字符型数组的第off个位置起，读取len个字符
这个方法还可以用于防止数组越界，其用法是off设置成0,len设置成数组长度
long skip(long n) throws IOException 跳过指定的字符数
Synchronized void mark(int readlimit) 在字符流中标记一个位置
Synchronized void reset() 重新设置到上一次标记的位置
public void close()
boolean markSupport()
字符集输出流(Writer)
主要方法如下：
write(int c) 向Write流对象中写入一个字符
write(char[] cc) 向流对象中写入一个字符数组
write(char[] cc,int off,int len) 从数组的第off个位置，写入len个字符长度到流对象中
write(String s) 向流对象中写入一个字符串
write(String str,int off,int len) 字符串的第off个位置，写入len个字符
void close()
public void flush() throws IOException
上述两个类都是最高层的类，一般并不直接使用它们
FileReader类
此类可以方便的将一个文件连接到其他需要以Reader作为输入参数的类上
其构造方法如下：
FileReader(String filename)
FileReader(File file)
FileReader(FileDescript fd)
FileReader可用于读取字符文件中的内容，但一次只能读取一个字符，所以通常将FileReader对象内置于BufferedReader对象中
BufferedReader类
从字符输入流中读取文本，在必要时将字符存入缓存
其构造方法如下所示：
public BufferedReader(Reader in) public BufferedReader(Reader in,int len)
此类除了具有Reader类的一般方法外，还有以下方法
public String readLine() throws IOException 该方法读取一行文字，到达最后返回null
import java.io.*;
public class javadir{
public static void main(String args[]) throws IOException{
FileReader fr=new FileReader("t.class");
BufferedReader br=new BufferedReader(fr);
String s;
while((s=br.readLine())!=null) System.out.println(s);
fr.close();
}
}
以上两个类合起来用
FileWrite类
此类把字符输入流与文件连接起来
它的构造方法如下：
FileWrite(File file)
FileWrite(String filename)
FileWrite(String filename,boolean append)
BufferedWrite类
此类用来创建一个字符缓存输入流，它主要为其他类如PrintWrite提供一个字符输入流
它的构造方法如下：
public BufferedWrite(Writer out)
public BufferedWrite(Write out,int len)
此类除了提供了Writer类具有的方法外，还提供了如下方法：
void newLine() 插入一个新行符
void flush() 强迫刷新
PrintWrite类
此类为格式化字符流提供了一些实用的方法，它最好还是与其他输出流一起使用，提高流的效率
它的构造方法如下：