java 操作文件File类

拼搏现实的明天。 2022-05-15 14:50 304阅读 0赞

# File 文件类 #

**用来将文件或者文件夹封装成为对象。**

**方便对文件与文件夹的属性信息进行操作。**

**File对象可以作为参数传递给流的构造函数。**

**</pre></div><div></div><h2>File 类的常用的方法。</h2><div><pre name="code" class="java">import java.io.\*;  
/\*File类的常见方法  
 1.创建。  
   boolean  createNewFile();  
   boolean  mkdir();创建文件夹  
   boolean mkdirs();创建多级文件夹。  
     
 2.删除。  
   boolean delete();  
   void  deleteOnExit();在程序退出时删除文件。  
    
 3.判断。  
     boolean canExcute(); 判断是否可执行  
     boolean exists(); 文件事是否存在。  
     isFile();文件  
     isDirectory();文件夹  
     isHidden();//java能得到文件中的隐藏文件但是对隐藏文件时不能访问的  
     isAbsolute();//绝对路径即时不存在也能得到。  
 4.获取信息。  
     getName();  
     getPath();  
     getParent();  
       
     getAbsolutePath();  
     long lastModified();  
     long length();  
   
 \*/  
public class FileDemo \{  
   
    /\*\*  
     \* @param args  
     \*/  
    public static void main(String\[\] args)throws IOException \{  
        // TODO Auto-generated method stub  
          method\_4();  
    \}  
      public static void method\_1() throws IOException\{  
             File f= new File("d:\\\\file.txt");  
             f.deleteOnExit();//告诉程序当程序结束时才删除f关联的文件 即使发生异常也不受影响  
           //System.out.println("creat:"+f.createNewFile());  
            System.out.println("delete:"+f.delete());  
            
      \}  
      public static void method\_2()\{  
           File  f = new File("file.txt");  
          // System.out.println("execute:"+f.canExecute());  
          // System.out.println("exists:"+f.exists());  
           //创建文件夹  
           File dir = new File("d:\\\\abc");  
           File dirs = new File("d:\\\\abc\\\\a\\\\b\\\\c");  
            System.out.println("dir:"+dir.mkdir());  
            System.out.println("dirs:"+dirs.mkdirs());  
      \}  
      public static void method\_3()\{  
          File f = new File("file.txt");  
          System.out.println("path:"+f.getPath());  
          System.out.println("absolutePath:"+f.getAbsolutePath());  
          System.out.println("parentpath:"+f.getParent());//该方法返回的是绝对路径中文件的父目录。如获取的是相对路径返回的是null。  
                                                           // 如果相对路径中有上一层目录那么该目录就是返回结果。  
      \}  
      public static void method\_4()\{  
          File f1= new File("d:\\\\a.txt");  
          File f2= new File("haha.txt");  
          System.out.println(f2.renameTo(f1));//类似于剪切功能  
      \}  
     public static void consMethod()\{  
         //将a.txt封装成file对象，可以将已有的和为出现的文件或者文件夹封装为对象。  
          File f1 = new File("d:\\\\a.txt");  
            
          File f2 = new File("d:\\\\abc","b.txt");  
          File d = new  File("d:\\\\abc");  
          File f3= new File(d,"a.txt");  
          System.out.println("f1:"+f1);  
          System.out.println("f2:"+f2);  
          System.out.println("f3:"+f3);  
          //跨平台分隔符<span style="font-family: Arial, Helvetica, sans-serif;">File.separator</span>  
          File f4 = new File("d:"+File.separator+"abc"+File.separator+"a.txt");  
          System.out.println("f4:"+f4);  
                    
     \}  
\}  
获取系统根目录例子  
import java.io.\*;  
public class FileDemo2 \{  
   
    /\*\*  
     \* @param args  
     \*/  
    public static void main(String\[\] args) \{  
        // TODO Auto-generated method stub  
          listDemo();  
    \}  
      
    public static void listDemo()\{  
         File f = new File("d:\\\\");  
         String\[\] names= f.list();//调用list方法的对象必须封装一个目录，封装文件返回为null  
         for(String name : names)\{  
             System.out.println(name);  
         \}  
    \}  
    public static void listRootsDemo()\{  
        File\[\] files=File.listRoots();  
          
        for(File f: files)  
        \{  
            System.out.println(f);  
        \}  
    \}  
\}**

**递归输出文件列表  
import java.io.\*;  
/\*  
 列出指定目录下的文件或文件夹，包含子目录中的内容。  
 也就是列出指定目录下所有内容。  
   
 递归注意  
   
 1 注意要有结束  
   
 2 要注意递归的次数 防止内存溢出  
 \*/  
   
public class FileDemo3 \{  
   
    /\*\*  
     \* @param args  
     \*/  
    public static void main(String\[\] args) \{  
        // TODO Auto-generated method stub  
          File  f= new File("d:\\\\u盘备份");  
             showDir(f,0);  
           //System.out.println(getSum(10));  
    \}  
      
       public  static String getLevel(int level)  
       \{  
            StringBuilder sb= new StringBuilder();  
            for(int i=0; i<level;i++)\{  
                sb.append(" ");  
            \}  
            sb.append("|--");  
           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 i=0;i<files.length;i++)  
          \{  
              if(files\[i\].isDirectory())  
                  showDir(files\[i\],level);  
              else  
                  System.out.println(getLevel(level)+files\[i\]);  
          \}  
            
         
     \}  
     //补充:递归方法求和   
     public static int getSum(int num)\{  
         if(num==1)  
             return 1;  
         else return num+getSum(--num);  
      \}  
\}**

**删除文件夹实例  
import java.io.\*;  
/\*  
 \* 删除文件夹要先删除里边的文件。因此就要用到递归了  
 \* 从里往外删除文件  
 \*   
 \*/  
public class FileRemoveDir \{  
   
    /\*\*  
     \* @param args  
     \*/  
    public static void main(String\[\] args) \{  
        // TODO Auto-generated method stub  
         File file= new File("d:\\\\abc");  
         removeDir(file);  
    \}  
     public static void removeDir(File dir)  
     \{  
         File\[\] files =dir.listFiles();  
         for(int i=0;i<files.length;i++)  
         \{  
             if(files\[i\].isDirectory())  
             \{  
                 removeDir(files\[i\]);  
             \}else  
                 System.out.println(files\[i\].toString()+"file:"+files\[i\].delete());  
         \}  
         System.out.println(dir+"dir:"+dir.delete());  
     \}  
\}**

**查找文件夹指定类型保存在文件中  
import java.io.\*;  
import java.util.\*;  
/\*  
 将一个指定目录下的java文件的绝对路径，存储到一个文件中。  
 建立一个java文件列表清单。  
   
 思路：  
 1.对指定的目录进行递归。  
 2.获取递归过程所有的java文件的路径。  
 3.将这些路径存储到集合中。  
 4.将集合中的数据写入到一个中。  
   
 \* \*/  
public class JavaFileList \{  
   
    /\*\*  
     \* @param args  
     \* @throws IOException   
     \*/  
    public static void main(String\[\] args) throws IOException \{  
        // TODO Auto-generated method stub  
        File dir = new File("d:\\\\u盘备份");  
        List<File> list= new ArrayList<File>();  
        fileToList(dir,list);  
        File f =new File("javaList.txt");   
         writeToFile(list,f);  
    \}  
    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.add(file);  
            \}  
              
        \}  
    \}  
    public static void writeToFile(List<File> List, File f) throws IOException  
    \{  
        BufferedWriter bw= new BufferedWriter(new FileWriter(f));  
        try\{  
            for(File file: List)  
            \{  
                String path= file.getAbsolutePath();  
                bw.write(path);  
                bw.newLine();  
                bw.flush();  
                  
            \}  
        \}catch(Exception e)\{  
            throw new RuntimeException("失败！");  
        \}  
        finally\{  
            try\{  
                if(bw!=null)  
                    bw.close();  
            \}catch(Exception ex)\{  
                throw new RuntimeException("关闭失败！");  
            \}  
        \}  
          
    \}  
\}  
Propreties与流关联的集合类HashTable的子类  
import java.io.\*;  
import java.util.\*;  
public class PropertiesDemo \{  
   
    /\*\*  
     \* @param args  
     \* @throws IOException   
     \*/  
    public static void main(String\[\] args) throws IOException \{  
        // TODO Auto-generated method stub  
                    //setAndget();  
        //method\_1();  
        loadDemo();  
    \}  
    //load方法进行文件的集合加载。  
    public static void loadDemo() throws IOException  
    \{  
        FileInputStream fis= new FileInputStream("info.txt");  
        Properties prop= new Properties();  
        prop.load(fis);  
        prop.list(System.out);  
        prop.setProperty("wangwu","25");  
        FileOutputStream fos= new FileOutputStream("info.txt");  
        prop.store(fos, "haha");  
    \}  
    //将info.txt中的键值数据存到集合中进行操作。  
    /\*步骤:  
     1.用一个流和info.txt文件关联。  
     2.读取一行数据，将该数据用"="进行切割。  
     3.等号左边为建，右边卫值。存入Porperties集合中即可.  
     \*/  
    public static void method\_1() throws IOException  
    \{  
    BufferedReader br= new BufferedReader(new FileReader("info.txt"));  
    String line=null;  
    Properties prop= new Properties();  
    while((line=br.readLine())!=null)  
    \{  
        String\[\] s=line.split("=");  
        prop.setProperty(s\[0\], s\[1\]);  
    \}  
    System.out.println(prop);  
    \}  
    //设置和获取元素  
    public static void setAndget()  
    \{  
        Properties prop = new Properties();  
        prop.setProperty("zhangsan", "34");  
        prop.setProperty("lisi", "22");  
        System.out.println(prop);  
        String value =prop.getProperty("zhangsan");  
        System.out.println(value);  
        Set<String>  names = prop.stringPropertyNames();  
        for(String name:names)  
        \{  
            System.out.println(prop.getProperty(name));  
        \}  
    \}  
\}**

**Properties实现程序的使用次数限制  
/\*用于记录应用程序的次数。  
  如果使用次数已到，那么给出注册信息。  
    
    思路:  
    通过Properties属性文件将使用次数的属性存在此文件中，每次使用一次将计数  
    属性修改并重新存到属性文件中，此操作就要借用Properties对象进行操作。  
 属性文件用于键值对的存储方式。  
 这样便于对数据操作。  
   
 键值对是map集合  
 数据是以文件的形式存储，使用io数据。  
 \*/  
import java.io.\*;  
import java.util.\*;  
public class PropertiesCount \{  
   
    /\*\*  
     \* @param args  
     \* @throws IOException   
     \*/  
    public static void main(String\[\] args) throws IOException \{  
        // TODO Auto-generated method stub  
         Properties prop = new Properties();  
          File file= new File("count.ini");  
          if(!file.exists())  
              file.createNewFile();  
         FileInputStream fis = new FileInputStream(file);  
         prop.load(fis);  
         int count=0;  
         String value= prop.getProperty("time");  
         if(value!=null)  
         \{  
             count =Integer.parseInt(value);  
             if(count>=5)  
             \{  
                 System.out.println("您好，使用次数已到请付费");  
                 return;  
             \}  
         \}  
         count++;  
         prop.setProperty("time",count+"");  
         FileOutputStream fos = new FileOutputStream(file);  
         prop.store(fos,"haha");  
    \}  
        
\}**

**PrintStream与PrintWriter 打印流的用法  
/\*打印流  
 为了方便各种数据类型的原样打印。  
   
 字节打印流  
 PrintStream  
 可以接收的参数类型  
 1.file对象 File  
 2.字符串路径。String  
 3.字节输出流 OutputStream  
  PrintWriter  
 可以接收的参数类型  
 1.file对象 File  
 2.字符串路径。String  
 3.字节输出流 OutputStream  
 4.字符输出流 Writer  
 \*/  
import java.io.\*;  
public class PrintStreamDemo \{  
   
    /\*\*  
     \* @param args  
     \* @throws IOException   
     \*/  
    public static void main(String\[\] args) throws IOException \{  
        // TODO Auto-generated method stub  
              BufferedReader bufr=  
                      new BufferedReader(new InputStreamReader(System.in));  
              PrintWriter out = new PrintWriter(System.out);  
              String line = null;  
              while((line=bufr.readLine())!=null)  
              \{  
                  out.println(line.toUpperCase());  
                  out.flush();  
              \}  
              out.close();  
              bufr.close();<pre name="code" class="java">  
\}\}**

**DataInputStream和DataOutputStream 基本数据操作流  
import java.io.\*;  
/\*  
 DataStream类主要用于操作基本数据类型的流的读取和写入  
 \*/  
public class DataInputStreamDemo \{  
   
    /\*\*  
     \* @param args  
     \* @throws Exception   
     \*/  
    public static void main(String\[\] args) throws Exception \{  
        // TODO Auto-generated method stub  
         //writeData();  
        //readData();  
        writeUTFDemo();  
    \}  
    public static void writeUTFDemo() throws IOException  
    \{  
         DataOutputStream dos =  
                   new DataOutputStream(new FileOutputStream("data.txt"));  
         dos.writeUTF("你好");  
         dos.close();  
    \}  
    public static void readData() throws Exception  
    \{  
        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);  
        System.out.println("b:"+b);  
        System.out.println("d:"+d);  
    \}  
   public static void writeData() throws IOException  
   \{  
       DataOutputStream dos =  
               new DataOutputStream(new FileOutputStream("data.txt"));  
       dos.writeInt(234);  
       dos.writeBoolean(true);  
       dos.writeDouble(444.456);  
       dos.close();  
         
   \}  
\}**

**ObjectInputStream和ObjectOutputStream对象操作流  
import java.io.\*;  
public class ObjectStreamDemo \{  
   
    /\*\*  
     \* @param args  
     \* @throws IOException   
     \*/  
    public static void main(String\[\] args) throws Exception \{  
        // TODO Auto-generated method stub  
            writeObj();  
          readObj();  
    \}  
    public static void readObj() throws IOException, IOException, ClassNotFoundException  
    \{  
      ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));  
      Person p =(Person)ois.readObject();  
      System.out.println(p);  
      ois.close();  
        
    \}  
    public static void writeObj() throws IOException, IOException  
    \{  
        ObjectOutputStream oos=  
                new ObjectOutputStream(new FileOutputStream("obj.txt"));  
        oos.writeObject(new Person("lisi",39,"china"));  
        oos.close();  
    \}  
     
\}  
     class Person implements Serializable  
     \{  
         /\*\*  
         \* 自定义  
         \*/  
        private static final long serialVersionUID = 1L;  
        private String name;  
        transient int age;//关键字transient定义的成员也不能被序列化 在堆内存中也无法被序列化  
        static String country="cr" ;//静态成员不能被序列化，不再堆内存中  
           
         Person(String name ,int age,String country)\{  
             this.name=name;  
             this.age=age;  
             this.country=country;  
         \}  
         public String toString()\{  
             return name+":"+age+country;  
         \}  
     \}**

**PipedInputStream 和PipedOutputStream 管道操作流  
import java.io.\*;  
public class PipedStreamDemo \{  
   
    /\*\*  
     \* @param args  
     \* @throws Exception   
     \*/  
    public static void main(String\[\] args) throws Exception \{  
        // TODO Auto-generated method stub  
       PipedInputStream pis= new PipedInputStream();  
       PipedOutputStream pos= new PipedOutputStream();  
       pis.connect(pos);  
         
       PipedRead read = new PipedRead(pis);  
       PipedWrite write = new PipedWrite(pos);  
       new Thread(read).start();  
       new Thread(write).start();  
         
    \}  
   
\}  
   
class PipedRead implements Runnable  
\{  
   private PipedInputStream in;  
   PipedRead(PipedInputStream i)  
   \{  
       this.in=i;  
   \}  
    @Override  
    public void run() \{  
        // TODO Auto-generated method stub  
        try  
        \{   byte\[\] buf = new byte\[1024\];  
            int len=in.read(buf);  
            String s = new String(buf,0,len);  
            System.out.println(s);  
            in.close();  
        \}catch(Exception e)  
        \{  
            throw new RuntimeException("读取失败");  
        \}  
    \}  
\}  
   class PipedWrite implements Runnable\{  
     private  PipedOutputStream pos;  
       PipedWrite(PipedOutputStream out)\{  
           this.pos= out;  
       \}  
    @Override  
    public void run() \{  
        // TODO Auto-generated method stub  
        try  
        \{   
            Thread.sleep(6000);  
            pos.write("ge men lai le".getBytes());  
            pos.close();  
        \}catch(Exception e)  
        \{  
            throw new RuntimeException("写入流失败！");  
        \}  
    \}  
         
   \}**

**RondomAccessFile 随机文件读写流  
import java.io.\*;  
/\*RandomAccessFile  
  该类不是IO体系中的子类  
  而是直接继承Object  
    
  但是他是IO包中的成员，因为它具有读写数据的功能。  
  内部封装了一个数组，而且通过指针对数据元素进行操作。  
  可以通过getFilePointer 获取指针的位置。  
  同时可以通过seek方法改变指针的位置。  
    
  其实就是内部封装了字节输入流和输出流。  
    
  通过其拥有的构造函数可以看出，该类只能操作文件。  
  而且操作文件还有固定的模式。只读 r 读写rw  
    
  如果是只读模式去操作文件，读取已有的文件入如果问价不存在就会报错。  
  如果是读写，如果没有文件会创建一个文件在写入。  
    
 \*/  
public class RandomAccessFileDemo \{  
   
    /\*\*  
     \* @param args  
     \* @throws Exception   
     \*/  
    public static void main(String\[\] args) throws Exception \{  
        // TODO Auto-generated method stub  
             writeFile();  
            readFile();  
    \}  
    public static void readFile() throws IOException  
    \{  
       RandomAccessFile raf = new RandomAccessFile("random.txt","r");  
     //seek方法的使用很频繁 将读取文件中的指针调整位置读取数据  
       raf.seek(8\*3);//跳过开头的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() throws IOException  
    \{  
        RandomAccessFile  raf = new RandomAccessFile("random.txt","rw");  
        raf.write("李四".getBytes());  
        //raf.write(97);//write 方法是写入最低八位的二进制形式。  
        raf.writeInt(97);//writeInt()方法是写入四个字节不会出现乱码。  
        raf.write("王五".getBytes());  
        raf.writeInt(99);  
        raf.seek(8\*3);//跳过一个8字节写入数据  
        raf.write("周七".getBytes());  
        raf.writeInt(98);  
        raf.close();  
    \}  
      
      
\}**