File类详解：
所在包：java.io
用处：可以通过File对象的方法创建文件对象、删除文件、查找文件，判断文件是目录还是正式文件。
文件系统的命名规则：
1. 文件的全名包含文件的路径名和扩展名，单独讲一个文件名是，为只带扩展名的文件名，不含路径。
2. 同一目录下不可能存在同名的目录和真实文件，系统主要有目录类型的文件和真是文件两种，真是文件可以没有扩展名，还有第三种我们不需要就是的虚拟内存文件。
3. 相对目录：指不一路径分隔符开头的文件路径
绝对目录：指以根目录开头的路径，以盘符开头的目录都是绝对目录
当前目录：指相对于程序运行时的目录算起的相对路径
4. 目录分隔符和路径分隔符在liunx和win平台上是不同的，前者为“/”和“：”，后者为“\”和“;”，所以应该使用File类提供的相应属性值。
（注意：能用相对路径的就不要用绝对路径以增强可移植性。）
File类构造方法：
| File(File parent, String child) |
| File(String parent, String child) |
File类常用的方法：
| boolean | delete() |
| boolean | |
| boolean | exists() |
| getAbsoluteFile() | |
| getAbsolutePath() | |
| long | getFreeSpace() |
| getName() | |
| getPath() | |
| boolean | isDirectory() |
| boolean | isFile() |
| long | length() |
| static File[] | listRoots() |
| boolean | mkdir()
|
代码示例：
实现功能：文件创建和删除，打印目录和文件
package lesson11;
import java.io.File;
public class FileTest{
/**
* @param args
*/
public static void main(String[] args) {
FileTest ft = new FileTest();
ft.listRoots();
ft.testCreateAndDelete("D:/Java/Java程序/StudyJava/ NetJava/src/lesson11/Text.txt"); // 路径可变
ft.printDir("src");
// 列出计算机上的根目录
public void listRoots() {
// 直接调用File类
File[] lf = File.listRoots();
System.out.println("磁盘上目录的个数是：" + lf.length);
for (int i = 0; i < lf.length; i++) {
System.out.println("第" + i + "个目录是" + lf[i].getAbsolutePath());
}
}
// 测试文件创建与删除
public void testCreateAndDelete(String fileName) {
// 通过传入的名字构造File对象
File temFile = new File(fileName);
// 判断文件是否存在
if (temFile.exists()) {
if (temFile.isDirectory()) {
System.out.println("这是一个目录：" + temFile.getAbsolutePath());
}
if (temFile.isFile()) {
prinFileAttr(temFile);
// 删除文件
temFile.delete();
String theName = temFile.getName();
String absPath = temFile.getAbsolutePath();
System.out .println("文件已删除，名字是：" + theName + " 绝对路径是：" + absPath);
}
} else {
try {
temFile.createNewFile();
System.out.println("文件已创建！" + temFile.getAbsolutePath());
// 打印出文件的长度
prinFileAttr(temFile);
} catch (Exception ef) {
System.out.println("创建文件失败");
}
}
}
// 打印出文件的相关属性：长度，文件名，父目录名，是否隐藏文件
public void prinFileAttr(File temf) {
System.out.println("文件长度是：" + temf.length());
}
public int printDir(String dirName){
//文件计数器
int count = 0;
File dirFile = new File(dirName);
File[] subFile = dirFile.listFiles();
if(null == subFile||subFile.length==0){
return 0;
}
for(int i=0;i<subFile.length;i++){
if(subFile[i].isDirectory()){
String subDir=subFile[i].getAbsolutePath();
System.out.println("目录："+subDir);
count +=printDir(subDir);
}
if(subFile[i].isFile()){
count++;
String fileName = subFile[i].getAbsolutePath();
System.out.println("文件："+fileName);
}
}
return count;
}
}
异常：
Try catch处理机制：
格式：
try{
可能抛出异常的代码……
//如果没有问题出现，指向如下代码
（A） 其他计算代码
}catch（Exception ef）{
//如果出现异常后执行的代码；
（B）出现异常情况的执行代码
}
异常信息的分析与程序调试：
1. try catch 机制
2. throws:在方法上抛出异常
例：public void Test() throws Exception(){ 方法体 }
注意：当另外一个方法调用了一个声明为可能抛出异常的方法时，要么将调用这个方法的代码放入try catch块中；要么将调用方法也声明为抛出异常。
3. 如果不想再代码中编写try块，就必须对调用方法做如下声明： public void Test(){
throw new Exception(“”);
}
如果方法体中使用throw关键字抛出了Exception类型（或其子类）的对象，在方法的声明中就必须使用throws关键字声明，throws后面异常类名字必须是throw抛出异常对象的类型或其父类类型---因为永远是自动的。
IO流：
在计算机编程中，流就是一个类的对象，很多文件的输入输出操作都以类的成员函数的方式来提供。
计算机中的流其实是一种信息的转换。它是一种有序流，因此相对于某一对象，通常我们把对象接收外界的信息输入（Input）称为输入流，相应地从对象向外输出（Output）信息为输出流，合称为输入/输出流（I/O Streams）。对象间进行信息或者数据的交换时总是先将对象或数据转换为某种形式的流，再通过流的传输，到达目的对象后再将流转换为对象数据。所以，可以把流看作是一种数据的载体，通过它可以实现数据交换和传输。
在JAVA中，流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。
Java中的流分为两种，一种是字节流，另一种是字符流，分别由四个抽象类来表示:InputStream，OutputStream，Reader，Writer。Java中其他多种多样变化的流均是由它们派生出来的。
流的分类：
1. 字节流
2. 过滤流
3. 数据类型流
4. 对象流
InputStream：
常用方法：
| int | available() |
| void | close() |
| int | read() |
| int | read(byte[] b) |
FileInputStream类：
构造方法：
| FileInputStream(File file) |
| FileInputStream(FileDescriptor fdObj) |
| FileInputStream(String name) |
常用方法和InputStream差不多。
OutputStream：
常用方法：
方法摘要
| void | close() |
| void | flush() |
| void | write(byte[] b) |
| void | write(byte[] b, int off, int len) |
| abstract void | write(int b) |
FileOutputStream类：
| 构造方法摘要 | |
| FileOutputStream(File file) | |
| FileOutputStream(File file, boolean append) | |
| FileOutputStream(FileDescriptor fdObj) | |
| FileOutputStream(String name) | |
| FileOutputStream(String name, boolean append) | |
| 方法摘要 | |
| void | close() |
| protected void | finalize() |
| getChannel() | |
| getFD() | |
| void | write(byte[] b) |
| void | write(byte[] b, int off, int len) |
| void | write(int b) |
缓冲流：
功能：提高读写效率
| 构造方法摘要 | |
| BufferedInputStream(InputStream in) | |
| BufferedInputStream(InputStream in, int size) | |
| BufferedOutputStream(OutputStream out) | |
| BufferedOutputStream(OutputStream out, int size) | |
注：对于BufferedOutputStream要么用flush（）方法强制想缓冲区的数据读出来，要么要及时close（），否则数据留在缓冲区，会导致数据没有读到输出文件中。
综合实例：
package lesson12;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class FileIO {
/**定义一个类，实现文件复制功能
* @param args
*/
public static void main(String[] args) {
//注意两个路径的文件的后缀名一定要相同，否则可以复制，但打开会有乱码
String inputFile = "D:/soft/jdk1.6.CHM";
String outputFile = "D:\\Java\\src\\lesson12\\输出文件.CHM";
FileIO file = new FileIO();
file.copy(inputFile,outputFile);
}
//方法
public void copy(String InputFile,String OutputFile) {
try {
//定义输入流
InputStream ips = new FileInputStream(InputFile);
//定义缓冲输入流
BufferedInputStream bis = new BufferedInputStream(ips);
//计算输入文件的长度
int len = ips.available();
//定义一个字节数组，长度为文件大小
byte[] array = new byte[len];
//读取数据
ips.read(array);
//定义文件输出流
OutputStream ops= new FileOutputStream(OutputFile);
//定义缓冲流
BufferedOutputStream bos = new BufferedOutputStream(ops);
//将数组的内容输出到指定文件里
bos.write(array);
//一定要记得关闭流
bos.flush();
ops.close();
ips.close();
bos.close();
bis.close();
System.out.println("文件输出成功！！");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
扫一扫
978
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
