java 操作文件File类

最新推荐文章于 2023-03-23 15:51:07 发布
最新推荐文章于 2023-03-23 15:51:07 发布
阅读量194 收藏
点赞数

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();
    }
    
    
}

 

二月的微笑
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
文件操作类（java）
09-05
java实现对文件的基本操作，如创建,删除，读取，写入，解压缩，复制，移动等操作。{@link #createFile(String)} * * {@link #readFile(String, String)} * * {@link #moveFile(String, String)} * {@link #moveFiles(String, String)} * * {@link #copyFile(File, File)} * {@link #copyDirectory(String, String)} * {@link #copyDirectoryContents(String, String)} * * {@link #deleteFile(String)} * {@link #deleteFile(File)} * * {@link #zipFile(String, String)} * {@link #zipFile(String, File)} * {@link #zipFiles(String, HashMap)} * {@link #zipFiles(String, File[], File)} * {@link #zipFile(ZipOutputStream, File, String, BufferedOutputStream)} * * {@link #unZipFile(String, String)}
JAVA操作文件
weixin_64015613的博客
04-05 1048
计算机中的文件 什么是文件？ 在我们日常生活中，我们认为文件就是记录着一些信息的本子。这些本子上可以记录任何我们想记录的信息。并且我们可以将多个本子夹在一起，形成一个大的文件夹。 那么计算机也是如此，在计算机中也可以通过类似我们生活中这样的方式来形成一个记录有效信息的文件。 在计算机中，一个文件的主要信息包括两种，一种是主要信息，也就是你真正想写的内容，例如你在一个记事本中写了这么一行字：你好中国!! 上面是你主要想写的内容，但还包括另一方面的信息，也就是这个文件的名字，类型和大小！这一部
java操作文件
weixin_37565521的博客
03-14 137
import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.FileReader; import java.io.FileWriter...
Java操作文件
风萧萧兮易水寒，壮士一去兮不复还
05-27 209
Java中操作文件主要使用io包中的输入输出流，我这里要说的是操作普通文件，如jpg、pdf等字节流文件和txt等字符流文件。XML文件、Excel和属性文件有专门的工具去操作，这里就不再赘述。 Java中io流可分为字节流和字符流两类。字节流主要用来操作字节类型的文件，如jpg、pdf、rar等，字符流主要用来操作字符类型的文件，如txt、html、jsp等等。根据流的方向又可分为输入流和输出...
Java 中操作文件
mzpqq的博客
05-29 143
目录1. File 常用构造方法2 常用方法示例1：观察 get 系列的特点和差异getPath() VS getAbsolutePath() VS getCanonicalPath()示例2：文件判断与创建示例3：文件存在删除/不存在创建示例4：观察 deleteOnExit示例5：观察目录的创建示例6：观察文件重命名 Java 中通过 java.io.File类来对一个文件（包括目录）进行抽象的描述。注意，有 File 对象，并不代表真实存在该文件。 1. File 常用构造方法 我们先来看看 F
Java文件操作类 File实现代码
08-29
主要介绍了Java文件操作类 File实现代码,需要的朋友可以参考下
Java-文件操作File类
12-21
 Java中提供的文件操作类主要是File，File类既可用于表示磁盘上存在的一个普通文件，也可用于表示该普通文件所在的目录，这里主要对其构造方法和基本的常用方法进行介绍。 正文： 文件类File概述  Java中的File类...
Java文件操作类FileManager
01-20
为此我单独写了一个文件操作的类，需要时先把这个类的代码粘过去，再调用方便多了。 import java.io.BufferedReader; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io....
java文件操作工具类
11-11
java文件操作工具类是java中针对文件操作的一个工具类，可以方便的读取，下载，上传文件等操作，希望可以帮到大家。
java文件操作工具类分享(file文件工具类)
09-04
java文件操作工具类(文件工具类)
用Java操作文件
05-31 803
/** * Java对文件的基本操作 */package file;import java.io.*;public class FileClass {    //private String sFileName;    //private String sFolderName;    String sPath;    String sFilePath;    String sContent;   
Java 文件操作
lfm1010123的博客
07-20 1200
详细介绍了 File 类、InputStream 类、OutputStream 类
Java文件操作
m0_56620669的博客
04-06 4922
Java的文件操作, 主要包含两类操作: 文件系统相关的操作, 比如创建文件, 文件改名的操作等 文件内容相关的操作 File类 构造方法: 构造方法内可以写绝对路径,也可以写相对路径. 典型方法: 查看文件名,路径名 public static void main(String[] args) throws IOException { File file = new File("./test.txt"); System.out.println(.
【 Java 中操作文件 】
qq_64317046的博客
03-23 218
Java 中通过类来对一个文件（包括目录）进行抽象的描述.注意，有 File 对象，并不代表真实存在该文件InputStream 只是一个抽象类，要使用还需要具体的实现类。关于 InputStream 的实现类有很多，基本可以认为不同的输入设备都可以对应一个 InputStream 类，我们现在只关心从文件中读取，所以使用方法：OutputStream 同样只是一个抽象类，要使用还需要具体的实现类。我们现在还是只关心写入文件中，所以使用。
java中使用file类删除文件
最新发布
07-15
你可以使用Java中的File类来删除文件。下面是一个例子： ```java import java.io.File; public class DeleteFileExample { public static void main(String[] args) { File file = new File("path/to/file.txt")...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值