常用JavaIO下
File类：文件和目录路径名的抽象表示形式。它有什么用呢？
| public class FileDemo {
public static void main(String[] args) { fileTest(); }
// 创建File对象 public static void fileTest() {
// 将a.txt封装成file对象，可以将文件或文件夹封装成对象。 File f = new File("a.txt");
File f1 = new File("c:\\abc\\a.txt");
File f2 = new File("c:\\abc","a.txt");
File path = new File("c:\\abc"); File f3 = new File(path,"a.txt");
// File.separator与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。 // 也就是说它是一个夸平台的字段，这样写你的代码在windows下和linux下都可以用，不用更改 File f4 = new File("c:" + File.separator + "abc" + File.separator + "a.txt");
System.out.println(f); System.out.println(f1); System.out.println(f2); System.out.println(f3); System.out.println(f4);
} } |
它可以将文件或文件夹封装成对象，也就与之关联起来。F1,f2,f3的效果是一样的。
File类的一些常见方法：
| // 常见方法之创建和删除 public class FileMethodDemo {
public static void main(String[] args) throws IOException { //addFile(); deleteFile(); }
// 删除指定文件 public static void deleteFile() { // 指定路径和文件名 File f = new File("a.txt");
// deleteOnExit();在程序退出时删除指定文件。这个方法是为了防止程序运行过程中 // 发生异常导致代码后面的删除文件语句无法得到执行从而无法删除指定文件
// 调用删除方法,也是返回布尔值 System.out.println("deleteFile:" + f.delete()); }
// 创建新的文件 public static void addFile() throws IOException { // 指定路径和文件名 File f = new File("a.txt");
// 调用创建方法，返回布尔值，真为成功，假为失败，如果已经存在返回假 System.out.println("createNewFile:" + f.createNewFile()); } } |
| // 关于判断的一些方法 public class FileMethodDemo1 {
public static void main(String[] args) throws IOException { panDuan(); }
public static void panDuan() throws IOException { File f = new File("a.txt");
f.createNewFile();
File f1 = new File("abc"); f1.mkdir();
File f2 = new File("abc\\def\\sdf\\asdf\\asdf\\asdf");
// 判断是否存在,在判断是不是文件和文件夹的时候要先判断封装的对象里面是不是存在 System.out.println("exists:" + f.exists()); // 判断是不是文件 System.out.println("isFile:" + f.isFile()); // 判断是不是文件夹 System.out.println("isDirectory:" + f1.isDirectory()); // 创建目录 System.out.println("dirs:" + f2.mkdirs()); } } |
| // 一些获取方法 public class FileMethodDemo2 {
public static void main(String[] args) { methodGet(); }
public static void methodGet() { File f = new File("out.txt");
// 获取名称 System.out.println("name:" + f.getName()); // 获取路径，获取到的是相对路径，写什么就是什么。 System.out.println("path:" + f.getPath()); // 获取绝路径 System.out.println("absolutePath:" + f.getAbsolutePath()); // 获取父目录，如果写的是纯相对路径（像上面写的那样），则返回null， // 如果不纯，如“abc\\out.txt”，则返回abc System.out.println("parent:" + f.getParent()); // 获取最后一次修改文件的时间 System.out.println("lastModify:" + f.lastModified()); // 获取文件的大小 System.out.println("length:" + f.length());
// 重命名，可以是不同的路径，它会将原路径中的文件删掉，在指定路径新建新名称的但内容不变的文件。 // 传说中的剪切也不过如是吧。 File f1 = new File("b.txt"); System.out.println("rename:" + f.renameTo(f1)); } } |
| // 文件列表 public class FileListDemo {
public static void main(String[] args) { listRootTest(); listTest(); }
// 遍历系统有几个盘符，返回一个数组 public static void listRootTest() { File[] fs = File.listRoots();
for (File f : fs) { System.out.println(f); } }
// 将指定目录下的所有文件和文件夹的名称遍历，存入数组中返回 public static void listTest() { File f = new File("c:\\");
String[] names = f.list();
for (String name : names) { System.out.println(name); } } } |
| // 文件列表 public class FileListDemo1 {
public static void main(String[] args) { File f = new File("D:\\java\\eclipse_classic\\IOStudy\\src\\com"); listTest(f); }
// 将指定目录下的所有文件和文件夹的名字和它的子文件夹中的文件名称遍历，存入数组中返回 public static void listTest(File dir) { File[] files = dir.listFiles();
for (File file : files) { //判断如果它是文件夹，则递归调用 if (file.isDirectory()) listTest(file); //输出文件名称 System.out.println(file.getName()); } } } |
小工具类，将指定目录中指定文件格式的路径存储到一个文本文件中，方法查看：
| // 将指定目录下的*.java的绝对路径保存到一个文本文件中 public class FileList {
public static void main(String[] args) throws IOException { File f = new File("src"); // 用一个list来保存 List<File> list = new ArrayList<File>(); fileToList(f, list);
BufferedWriter bw = new BufferedWriter(new FileWriter("list.txt"));
for (File file : list) { //保存绝对路径 bw.write(file.getAbsolutePath()); //换行 bw.newLine(); //刷新缓冲区 bw.flush(); }
}
public static void fileToList(File dir, List<File> list) { // 遍历所有文件，返回数组 File[] files = dir.listFiles();
for (File file : files) {
//如果是目录，则递归 if (file.isDirectory()) { fileToList(file, list); } else { //指定文件的类型 if (file.getName().endsWith(".java")) //将文件的绝对路径存入list中 list.add(file.getAbsoluteFile()); } } } } |
Properties类：Properties类表示了一个持久的属性集。Properties可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。
可以用来做软件的配置文件的存取操作。示例代码如下：
| // 属性集,是Hashtable的子类 public class PropertiesDemo {
public static void main(String[] args) { method(); }
public static void method() { Properties p = new Properties();
// 保存属性以key-value的形式 p.setProperty("zhangsan", "20"); p.setProperty("lisi", "30");
// 修改已存在的属性 p.setProperty("lisi", "59");
// 将属性集打印出来 System.out.println(p); // 获取某个属性的值 System.out.println(p.getProperty("zhangsan"));
// 得到所有的健集 Set<String> key = p.stringPropertyNames();
// 输出所有健 for (String s : key) { //输出所有健，并把值也一起输出来 System.out.println(s + ":" + p.getProperty(s)); }
} } |
读取配置文件示例代码：
| // 从文件中存取配置信息 public class PropertiesDemo1 {
public static void main(String[] args) throws IOException { loadDemo_1(); }
// 这样做无法更新配置信息，就是修改了后无法让硬盘的文件也更新 public static void loadDemo() throws IOException { Properties p = new Properties(); // 读取硬盘上的配置文件 BufferedReader br = new BufferedReader(new FileReader("prop.txt"));
String line = null;
while ((line = br.readLine()) != null) { //用等号作为分隔符来提取key和value String[] sp = line.split("="); //将健-值保存到属性集中 p.setProperty(sp[0], sp[1]); //System.out.println(sp[0] + "...." + sp[1]); }
System.out.println(p); br.close(); }
// Properties提供了一个方法，可以直接操作流public void load(InputStream inStream) // 从输入流中读取属性列表（键和元素对） public static void loadDemo_1() throws IOException { Properties p = new Properties();
// 加载进来 p.load(new FileReader("prop.txt"));
// 修改属性 p.setProperty("wangwu", "88"); // 修改完后需要保存，并且写一些备注信息 p.store(new FileOutputStream("prop.txt"), "age is wrong"); System.out.println(p); } } |
RandomAccessFile类：此类结尾处没有父类名，它是自成一派的工具类，它是直接继承Object类，它的实例支持对随机访问文件的读取和写入。该类不算是IO体系中的子类，但是它是IO包中的成员，因为它具备读和写功能。内部封装了一个数组，而且通过指针对数组中的元素进行操作，可以通过getFilePointer获取指针位置，同时可以通过seek改变指针位置。
其实能完成读写的原理就是内部封装了字节输入流和输出流。
该类只能操作文件，而且操作文件有模式。值可以为“r”,rw,rws,rwd.
常用的是前面两个。参数不能写错，错了会报异常。
如果模式为只读 r，不会创建文件，会去读取一个
已存在的文件，如果该文件不存在，则会出现异常
如果模式为rw，那么操作的文件不存在，会自动
创建。如果存在则不会覆盖。
Public static void writeFile() throws IOException {
RandomAccessFile raf = new RandomAccessFile(“ran.txt”“rw“);
Raf.write(“lisi”.getBytes());
Raf.write(97);
Raf.write(“wangwui”.getBytes());
Raf.write(97);
Raf.close();
}
Public static void readFile() {
RandomAccessFile raf = new RandomAcccessFile(“ran.txt”,“r”);
//Raf.write(“haha”.getBites()); // can not write
Byte [] buf = new byte[4];
Raf.read(buf);
String s = new String(buf);
Int age = raf.readInt();
System.out.println(“name=” + name);
Raf.close();
}
Write方法只能写数据的最低8位，所以当数据太大就会导致字节丢失部分。用writeInt会更好。会显示空格，前面没数据的部分就是没数据的高位。
改变指针位置读取指定数据。
Raf.seek(8);
要取第一个人的时候只要*0就可以了。第二个人*1
还有个特殊的方法，跳过指定的字节数：
Raf.skipBytes(8);它不能回跳。
// 随机写
Public static void writeFile_2() {
RandomAccessFile raf = new RandomAccessFile(“ran.txt”,”rw”);
Raf.seek(8*3);// 指定第四个位置存入
Raf.write(“zouqi”.getBytes());
Raf.writeInt(103);
Raf.close();
}
它不仅可以随机写，还能对数据进行修改，如果指针设置为8*0就会对第一个数据进行修改。
这个类到底还有什么用呢？
它可以分段存入数据，就是将数据分为几段后，可以用单个的线程分别负责每一段数据，这就是传说中的下载软件的多线程下载。IO里面只有它能实现此功能。
操作基本数据类型
DataInputStream DataOutputStream
可以用于操作基本数据类型的数据的对象。
Public static void writeData() throws IOException{
DataOutputStream dos = new DataOutputStream(New FileOutputStream(“data.txt”));
Dos.writeInt(234);
Dos.writeBoolean(true);
Dos.writeDouble(9878.543);
Dos.close();
}
Public static void readData()
{
DataInputStream dis = new DataInputStream(new FileInputStream(“data.txt”));
Int num = dis.readInt();
Boolean b = dis.readBoolean();
Double d = dis.readDouble();
System.out.println(“num=” + num);
Asdfsadfsadfsad
Asfasdfsadfdasf
}
读取的顺序不能乱，不然读出来的是乱码。因为各
个所占的字节数是不一样的。
操作字节数组
ByteArrayInputStream ByteArrayOutputStream
前者：在构造的时候，需要接收数据源，而且数据源
是一个字节数组。
后者：在构造的时候，不用定义数据目的，因为该对象中
已经内部封装了可变长的字节数组。这就是数据目的地
因为这两个流对象并没有
// datasource
ByteArraryInputStream bis = new ByteArraryInputStream(“adsfsadfsaf”.getBytes()):
// 数据目的
Bos = new ByteArrayOutputStream();
Int by = 0;
While ((by = bis.read())!= -1) {
Bos.write(by);
}
System.out.println(bos.size());
-----------------完----------------------
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
