--
学习了毕老师的java io技术的File操作，获益匪浅，将平时可能用到的一些东西记下来，以备不时只需，所谓好记性不如烂笔头嘛~
我们知道，IO流的操作很大程度上都跟File是有关联的，所以java为文件专门提过了一个类——File，File类在java程序中也是使用度非常高的一个类。
通过查阅java JDK知道，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 实例。 |
parent
- 父路径名字符串，
child
- 子路径名字符串 ，比如说一个路径为 D:\java\test\FileDemo.txt
那么“D:\java\test\”就相当于“FileDemo.txt”的parent，而反之为child
二、常用方法：
总结从四个方面看：
1、创建File对象
boolean createNewFile():在制定位置创建文件，如果该文件已经存在，则不创建，返回为false，明显和输出流是不一样的，输出流对象已奖励就要创建文件，而且文件如果存在的话会被覆盖。
boolean mkdir():创建文件夹
boolean mkdirs():也是创建文件夹，那么这两个到底有啥区别呢，最大的区别就是mkdirs()可以创建多级文件夹，就是文件夹下面还可以再有文件夹，而mkdir则只能创建一级文件夹。
...
2、删除
boolean delete() ://这没什么好说的
void deleteOnExit() 就跟方法名一样，在JVM终止时，请求删除次抽象路径名表示的文件或路径。
...
3、判断
boolean exists() 文件或文件夹是否存在
boolean canExecute() 应用程序是否可以执行此抽象路径名表示的文件。
isFile()
isDirectory();
isHiden() 测试此抽象路径名指定的文件是否是一个隐藏文件。
isAbsolute() 测试此抽象路径名是否为绝对路径名。
...
4、获取信息。
getName()获取文件名
getPath() 得到路径
getParent()
getAbsolutePath()
long lastModified()
long length()
long lastModified()
long length()
... ...
三、示例说明以上用法
import java.io.*;
public class FileDemo
{
public static void main(String[] args) throws IOException
{
//consMethod();
//method_1();
//method_2();
//method_3();
//method_4();
method_5();
}
public static void method_5() throws IOException
{
File f2 = new File("C:\\Test2.java");
File f1 = new File("D:\\haha.java");
sop("rename:"+ f1.renameTo(f2));
}
public static void method_4() throws IOException
{
File f = new File("file.txt");
sop("path:" + f.getPath());
sop("AbsolutePath:" + f.getAbsolutePath());
sop("Parent:" + f.getParent()); //该方法返回的是绝对路径中的文件父目录，如果获取的是相对路径，返回null
//如果相对路径中有上一层目录，该目录就是返回结果
}
public static void method_3() throws IOException
{
File f = new File("file.txt");
//在判断文件对象是否是文件或是目录是，必须要先判断该文件对象封装的内容是否存在
//通过exists判断。
//f.createNewFile();
f.mkdir();
sop("dir:" + f.isDirectory());
sop("File:" + f.isFile());
}
public static void method_2() throws IOException
{
File f = new File("file.txt");
//sop("canExecute:" + f.canExecute());
sop("exists: " + f.exists());
//创建文件夹 mkdir只能创建一级目录
File dir = new File("abc\\s\\c\\a");
sop("mkdirs:" + dir.mkdirs());
}
public static void method_1() throws IOException
{
File f = new File("file.txt");
f.deleteOnExit();// 在虚拟机终止时，请求删除此抽象路径名表示的文件或目录。
// sop("create : " + f.createNewFile());
sop("delete:" + f.delete());
}
//创建File对象
public static void consMethod()
{
//将a.txt封装成file对象，可以将已有的和未出现的文件或文件夹封装厂对象。
File f1 = new File("a.txt");
//
File f2 = new File("C:" + File.separator + "abc","b.txt");
File d = new File("c:\\abc");
File f3 = new File(d,"c.txt");
sop("f1:" + f1);
sop("f2:" + f2);
sop("f3:" + f3);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}/*
列出指定目录下文件或者文件夹，包含子目录中的内容。
也就是列出指定目录下所有内容。
因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现的还是目录的话，还可以再次调用本功能。
也就是函数自身调用自身。
这种表现形式，或者编程手法，称为递归。
递归要注意：
1，限定条件。
2，要注意递归的次数。尽量避免内存溢出。
*/
import java.io.*;
public class FileDemo3
{
public static void main(String[] args)
{
File dir = new File("F:\\javastudy\\day20");
showDir(dir,0);
}
public static String getLevel(int level)
{
StringBuilder sb = new StringBuilder();
sb.append("|--");
for(int x=0; x<level; x++)
{
//sb.append("|--");
sb.insert(0,"| ");
}
return sb.toString();
}
public static void showDir(File dir,int level)
{
System.out.println(getLevel(level)+dir.getName());
level++;
File[] files = dir.listFiles();
for(int x=0; x<files.length; x++)
{
if(files[x].isDirectory())
showDir(files[x],level);
else
System.out.println(getLevel(level)+files[x]);
}
}
}
在学习IO的最后，学习了一个很重要的类RandomAccessFile，其不是IO体系中的子类，而是直接继承自Object。蛋挞是IO包中的成员，因为它具备了读和写的功能。原理是在函数内部封装了一个数组，是通过指针对数的元素进行操作，可以通过提供的方法getFilePointer()获取指正的位置，也就是文件读到什么位置了，同时也可以用seek方法表示该指针所指的位置。显然能完成读写必然在其内部封装了字节输入输出流。
RandomAccessFile(File file,String mode)创建从中读取和向其中写入（可选）的随机访问文件流，该文件由 File 参数指定。 |
RandomAccessFile(String name,String mode)创建从中读取和向其中写入（可选）的随机访问文件流，该文件具有指定名称。 |
从构造函数可以看出，该类只能操作文件，操作的模式有：只读：r，读写：rw等，jdk提供的模式有：
mode
参数指定用以打开文件的访问模式。允许的值及其含意为：
对最常用的两种模式（r和rw）的说明：
值
含意
"r" 以只读方式打开。调用结果对象的任何 write 方法都将导致抛出 IOException。"rw" 打开以便读取和写入。如果该文件尚不存在，则尝试创建该文件。 "rws" 打开以便读取和写入，对于 "rw"，还要求对文件的内容或元数据的每个更新都同步写入到底层存储设备。 "rwd" 打开以便读取和写入，对于 "rw"，还要求对文件内容的每个更新都同步写入到底层存储设备
如果模式为只读 r ，不会创建文件。回去读取一个已存在的文件，如果该文件不存在，则会出现异常；如果模式rw操作的文件不存在，会自动创建，如果不存在则不会覆盖。而且该对象的构造函数要操作的文件不存在，会自动创建，如果不存在则不会覆盖。
举一例说明：程序很简单，就是尝试使用两种模式，读写文件
public class RandomAccessFileDemo
{
public static void main(String[] args) throws IOException
{
//writeFile();
//System.out.println(Integer.toBinaryString(258));
//readFile();
writeFile_2();
}
public static void readFile() throws IOException
{
RandomAccessFile raf = new RandomAccessFile("run.txt" , "r");
//调整对象中的指针
//raf.seek(8);
//跳过指定的字节数
raf.skipBytes(8);
byte[] buf = new byte[4];
raf.read(buf);
String name = new String(buf);
int age = raf.readInt();
System.out.println("name = " + name);
System.out.println("age = " + age);
raf.close();
}
public static void writeFile_2() throws IOException
{
RandomAccessFile raf = new RandomAccessFile("run.txt","rw");
raf.seek(8);//只想8位置的字符
raf.write("周七".getBytes());
raf.writeInt(103);
raf.close();
}
public static void writeFile() throws IOException
{
RandomAccessFile raf = new RandomAccessFile("run.txt","rw");
raf.write("李四".getBytes());
raf.writeInt(97);
raf.write("王五".getBytes());
raf.writeInt(99);
raf.close();
}
}
284
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
