Java核心类库——文件和文件夹的管理File类

一、File类的有什么作用
 　　java.io.File 用于表示文件(目录),也就是说程序员可以通过File类在程序中操作硬盘上的文件和目录.
　　 File类只用于表示文件(目录)的信息(名称  大小等),不能对文件内容进行访问(访问用RandomAccessFile)
二、 java.io.File 基本 API
 File 代表文件系统中对文件/目录的管理操作(增删改查, CRUD)
 常用API方法:
  File(String)   指定文件名的构造器
  long length()    文件的长度
  long lastModified()  最后一次修改的时间(是个long)
  String getName()  返回由此抽象路径名表示的文件或目录的名称。
  String getPath()   将此抽象路径名转换为一个路径名字符串
  boolean exists()   检查是否存在
  boolean dir.isFile()  检查是否是文件
  boolean dir.isDirectory() 检查是否是目录/文件夹
  boolean mkdir()   创建一个目录
  boolean mkdirs()  创建一系列目录(demo/sub/sub同时创建3个文件夹)
  boolean delete()   删除此抽象路径名表示的文件或目录
       (如果此路径名表示一个目录，则该目录必须为空才能删除。 )
  boolean createNewFile() throw IOException 当且仅当不存在具有此抽象路径名指定名
           称的文件时，不可分地创建一个新的空文件 
  File[] listFile()   返回一个抽象路径名数组，这些路径名表示此
       抽象路径名表示的目录中的文件

例子:

import java.io.File;
import java.io.IOException;
/**
 *  文件系统的管理 :pwd,ls
 *
 */
public class FSDemo {

 public static void main(String[] args) throws IOException {
  /*注意：Java程序的当前目录：是JAVA程序的启动文件夹，在
   * ECLIPSE开发的项目中，启动文件夹是项目文件夹，就是当前目录*/
  File dir = new File(".");//当前目录
  
  //getCanonicalPath()：返回的规范的路径名，不包括: . .. 
  String path = dir.getCanonicalPath();
  System.out.println(path);
  
  //getAbsolutePath(): 返回绝对路径，可能包含 ：. ..
  path = dir.getAbsolutePath();
  System.out.println(path);
  //以上代码相当于：Linux的pwd命令
  
  //File demo = new File("demo");//相对路径
  File demo = new File(dir,"demo");//dir是父目录,这里的dir就是.(当前目录)
  
  //new File()只是在内存中创建对象，不代表在硬盘上创建文件夹
  //或文件，可以使用方法exists()检查文件/文件甲是否存在
  
  System.out.println(demo.exists());//false
  //检查当前目录下有没有demo文件对象
  if(!demo.exists()){
   demo.mkdir();//创建文件夹
   //demo.mkdirs();创建系列文件夹，如:demo/sub/sub
  }
  File file = new File(demo,"demo.txt");
  if(!file.exists()){
   file.createNewFile();//创建文件,
  }
  System.out.println(file.isDirectory());//false
  System.out.println(file.isFile());//true
  System.out.println(demo.isDirectory());//true
  System.out.println(demo.isFile());//false
  
  System.out.println(file.canRead());//true 该文件是否可读
  System.out.println(file.isHidden());//false  该文件或目录是否为隐藏
  System.out.println(file.lastModified());//1334837570000(返回long的毫秒数)
  System.out.println(file.length());//0
  
  file.delete();//删除文件
  demo.delete();//只能删除空文件夹
 }
}

例子2

import java.io.File;
import java.util.Arrays;
import java.util.Comparator;

public class ListFileDemo {
 public static void main(String[] args) {
  //以下代码相当于linux的ls命令
  File dir = new File("/etc");//在linux操作系统下
  File[] files = dir.listFiles();
  for(File file: files){
   System.out.println(file);
  }
 }

}

三 回调模式和FileFilter
 FileFilter 类是对操作文件的过滤,相当于Linux命令:ls|grep p
  API 方法 :File[] listFile(FileFilter)
例

import java.io.File;
import java.io.FileFilter;

public class ListFilesDemo2 {
 public static void main(String[] args) {
  //ls /etc |grep p
  File dir = new File("/etc");
  /*dir.listFiles(filter)重载的列目录方法，参数是过滤条件
  根据过滤条件过滤列目录的结果
  FileFilter 接口，声明了过滤方法accapt(file) 如果这个方法返回
  true,表示这个文件被接受，保留作为方法的结果
  */

  File[] files = dir.listFiles(new FileFilter(){
   public boolean accept(File file){ //此方法的调用属于回调模式(不用自己去调用)
    return file.isFile() && 
    file.getName().matches(".+p.+");//此处代表文件名中有p,可用正则表达式
   }
  });
  for(File file:files){
   if(file.isDirectory()){//根据是文件夹还是文件作出有差别的打印
    System.out.println("["+file.getName()+"]");
   }else{
    System.out.println(file.getName());
   }
  }
 }
}

四 RandomAccessFile
RandomAccessFile类有什么用？
　　 RandomAccessFile类是Java提供的功能丰富的文件内容访问类,它提供了多种方法访问文件
内容,既可以读取文件内容,也可以向文件输出数据,RandomAccessFile支持"随即访问"方式,可以访问文件的任意位置

1）Java 文件模型，文件是byte by byte 是数据集合
data : 41 42 00 00 00 ff d6 d0 ……
index: 0 1 2 3 4 5 6 7 ……
porinter: ^
注意:data中为16进制数
16进制：41 对应 0100 0001 是一个字节

1024＊1024＊1024*1024
  k     M        G      T
5M Byte = 5 * 1024 * 1024个Byte组成的序列

2) 打开文件，有两种模式"rw"(读写),"r"(读)
RandomAccessFile raf = new RandomAccessFile(file,"rw");
打开文件时候默认文件指针在开头 pointer = 0

3)写入方法:raf.write(int)将整整的" 低八位"写入到文件中，
   指针自动移动到下一个位置，准备再次写入

＊ 文件名的扩展名要明确指定，没有默认扩展名现象!

4)读取文件
 　　int b = raf.read() 从文件中读取一个byte(8位)填充到int 的低8位,高24位为0,返回值
范围整数:0-255,如果返回-1表示读取到了文件末尾!每次读取后自动移动文件指针,准备下次读取

5) 文件读写完成以后一定要关闭文件
 　　Sun官方说明,如果不关闭,可能遇到一些意想不到的错误,根据具体操作平台不同会有不同
在使用过程中,切记文件读写完后要关闭文件.

例子

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
 * 随机读写文件 
 * data: 41 42 ff ff ff fe
 * index:  0  1  2  3  4  5  6
 * pointer:        ^
 */
public class RAFDemo {
 public static void main(String[] args) throws IOException {
  String file = "raf.dat";
  RandomAccessFile raf = new RandomAccessFile(file,"rw");
  System.out.println(raf.length());//0
  System.out.println(raf.getFilePointer());//0
  raf.write(0xffffff41);//底八位是41，前面的f没用，向文件写入41
  System.out.println(raf.getFilePointer());//1
  raf.write(66);//向文件写入42(十六进制)
  System.out.println(raf.getFilePointer());//2
  //如何将 -2 写入到文件！
  int i = -2;//Oxfffffffe
  //raf.write(i);//写入的是fe(高24位舍弃),不是-2
  //>>>:无符号移位运算(向右移动数位，低位溢出，高位补0)
  //>>  有符号移位运算，向右移动数位，低位溢出，高位正数补0，负数补1，保证符号不变
       //i = 11111111 11111111 11111111 11111110
  raf.write(i>>>24);//00000000 00000000 00000000 11111111 
  raf.write(i>>>16);//00000000 00000000 11111111 11111111
  raf.write(i>>>8); //00000000 11111111 11111111 11111110
  raf.write(i);   //11111111 11111111 11111111 11111110
  
  System.out.println(raf.getFilePointer());//6
  String str = "中国";
  byte[] buf = str.getBytes("GBK");//将"中国"转为GBK编码
  raf.write(buf);
  
  //读取文件内容
  System.out.println("读取文件内容");
  raf.seek(0);//使pointer回到0
  int b = raf.read();//读41,同时poiner+1
  System.out.println(Integer.toHexString(b));//用16进制打印出来41
  b = raf.read();//读42,同时poiner+1
  System.out.println(Integer.toHexString(b));//用16进制打印出来42
  
  System.out.println("重新读取文件内容");
  raf.seek(0);//使pointer回到0
  while((b= raf.read()) != -1){
   ;//读一个,同时poiner+1
   System.out.println(Integer.toHexString(b));//用16进制打印出来
  } 
  raf.close();//关闭文件
 }
}

五 序列化与基本类型序列化

1) 什么叫序列化?
  将类型int转换为4byte,或者将其他数据类型(如long -> 8byte)的过程,即将数据转换
为 n 个 byte 序列叫做序列化(数据 -> n byte)

2)什么是反序列化?
 将n byte 转换为一个数据的过程(n byte -> 数据)
如:[7f, ff, ff, ff] -> 0x7fffffff

3)RandomAccessFile 提供基本数据类型的读写方法,可以将基本类型数据序列化到文件或者将文件内容反序列化为数据
例子:

import java.io.IOException;
import java.io.RandomAccessFile;
/**
 * 文件的最基本的操作 就是每次读/写 一个byte数据
 * 
 * 序列华 : 数据(int long double)需要拆分为 byte序列写入到文件
 * 反序列化: 将byte重新拼接为数据
 * 
 * image 在内存中是对象,写到文件中,需要进行序列化,有标准:jpg
 */
public class DataIODemo {

 public static void main(String[] args) throws IOException{
  // TODO Auto-generated method stub

  //如何写出基本类型，读取基本类型
  String file = "data.dat";
  RandomAccessFile raf = new RandomAccessFile(file,"rw");
  
  raf.writeInt(-2);//将int -2 拆分为4个byrte写到文件中
  raf.writeLong(-2L);
  raf.writeDouble(-2.0);
  raf.writeBoolean(true);
  
  raf.seek(0);
  int i = raf.readInt();//pointer 4
  long l = raf.readLong();//pointer 8
  double d = raf.readDouble();//pointer 12
  boolean b = raf.readBoolean();//pointer 16
  raf.seek(12);
  double x = raf.readDouble();
  System.out.println(i+","+l+","+d+","+b+","+x);
  
  raf.close();
  IOUtils.print(file);

 }

}

序列化和反序列化的原理如下

import java.io.IOException;
import java.io.RandomAccessFile;

public class RAFDataIODemo {
 public static void main(String[] args)throws IOException{
  String file = "raf.dat";
  IOUtils.print(file);//41 42 ff ff ff fe d6 d0 b9 fa 
  RandomAccessFile raf = new RandomAccessFile(file,"r");
  //如何读取int数据，使用readInt()
  //原理
  raf.seek(2);
  int d1 = raf.read();// 00 00 00 ff
  int d2 = raf.read();// 00 00 00 ff
  int d3 = raf.read();// 00 00 00 ff
  int d4 = raf.read();// 00 00 00 fe
  //(d1<<24) : ff 00 00 00
  //(d2<<16) : 00 ff 00 00
  //(d3<< 8) : 00 00 ff 00
  //(d4  ) : 00 00 00 fe
  // i      : ff ff ff fe
  int i = (d1<<24) + (d2<<16) + (d3<<8) + d4;
  System.out.println(i);
  //使用readInt()
  raf.seek(2);//pointer重回2
  i = raf.readInt();
  System.out.println(i);
  
  
  //读取中文
  raf.seek(6);
  byte[] buf = new byte[4];//4个byte的缓冲区
  //raf.read(byte[])从raf尽可能多的读取byte数据填充到buf中
  //返回读取的个数，返回值介于0~缓冲区大小之间，如果返回-1，表
  //示读取到了文件尾部!
  int n = raf.read(buf);
  //String(byte[] byte,int start,int size,编码方式)
  String str = new String(buf, 0, n,"GBK");
  System.out.println(str);//中国 
  raf.close();
 }
}