java学习第二十天之创建删除文件、文件夹、写入文件_java文件流实现创建删除文件夹-CSDN博客

本文链接：https://blog.csdn.net/weiyumeizi/article/details/66972514

删除文件、文件夹

package cn.myio.demo;

import java.io.File;

public class DeleteDirDemo {
    /**
    * @param 删除一个带内容的文件夹，必须从里往外删
    */
    public static void main(String[] args) {
        File dir = new File("D:\\java\\workspace\\Stage2\\src\\cn\\myio\\demo\\abc");
        System.out.println(dir.delete());
        delDir(dir);
    }

    /**
     * @param dir
     */
    private static void delDir(File dir) {
//      1、列出当前目录下的文件以及文件夹
        File[] files=dir.listFiles();

//      2、对该数组进行遍历
        for (File file : files) {
            if(file.isDirectory()){
                delDir(file);
            }else {
                System.out.println(file+"已删除"+file.delete());
            }
        }
        System.out.println(dir+"已删除"+dir.delete());
    }
}

递归

package cn.myio.demo;

public class DiGuiDemo {
    /**
    * @param 递归：函数自身调用自身。函数内部又使用到了该函数的功能
    * 什么时候使用？
    * 功能被重复使用，但是每次该功能使用参与预算的数据不同是，可以考虑递归方式解决
    * 
    * 使用时，一定要定义条件
    * 注意递归次数过多，会出现内存溢出
    */
    public static void main(String[] args) {
        int sum = getSum(3);
        System.out.println("sum"+":\t"+sum);
    }
    /**
     * @param i
     * @return
     */
    private static int getSum(int i) {
        if(i==1)
            return i;
        return i+getSum(i-1);
    }
    public void show() {
        show();     
    }
}

调用文件接口

package cn.myio.demo;

import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;
import java.util.jar.Attributes.Name;

public class FileBySuffix implements FilenameFilter{

    private String suffix;
    public FileBySuffix(String suffix) {
        super();
        this.suffix=suffix;
    }
    //   Name被遍历目录中的文件夹或者文件的名称

    @Override 
    public boolean accept(File dir, String name) {
        return name.endsWith(suffix);
    }
}

获取文件数据

package cn.myio.demo;

import java.io.File;

public class FileDemo {
    /**
    * @param args
    * Flie类 常见方法
    * 1、名字  获取名称
    * String getName();
    * 2、大小  获取大小
    * long length();
    * 3、获取类型
    * 没有
    * 4、获取所在目录
    * String space();
    */
    public static void main(String[] args) {

        File file=new File("c:\\1.txt");

        String file_name=file.getName();//获取名称
        System.out.println(file_name);

        long len=file.length();//获取大小
        System.out.println(len);

        String space=file.getPath();
        System.out.println(space);
    }
}

创建文件、文件夹、查看是否隐藏

package cn.myio.demo;

import java.io.File;
import java.io.IOException;
import java.sql.Date;
import java.text.DateFormat;

public class FileDemo1 {
    /**
    * @param args
    * File  方法
    * 1、获取文件的绝对路径
    *   String getAbsolutePath();
    * 2、获取文件的路径
    *   String getPath();
    * 3、获取文件的最后一次修改时间，要求是X年X月X日。时间
    *   String lastModified();
    * 4、文件是否是隐藏的
    *   boolean isHidden();
    * 5、发现File对象封装的文件或者 文件夹是可以存在的也可以是不存在的
    * 那么不存在的可否用file的功能创建按呢？ 
    *   创建功能
    *       boolean createNewFile();
    *   删除功能
    *       boolean delete();
    * 6、一个File对象封装的文件或者文件夹到底是否存在内容？
    * 是否存在
        boolean exists();
    *7、getFreeSpace()方法是什么意思？用Demo验证。getTotalSpace()  getUsableSpace()
     * @throws IOException 
    */
    public static void main(String[] args) throws IOException {

        File file=new File("D:\\java\\workspace\\Stage2\\src\\cn\\myio\\demo\\2.txt");

//      methodDemo1(file);

//      methodDemo2(file);

        File file2=new File("D:\\java\\workspace\\Stage2\\src\\cn\\myio\\demo\\abc");
        methodDemo3(file2);

        methodDemo4();

    }

    /**
     * 
     */
    private static void methodDemo4() {
        File file =new File("C:\\");
        System.out.println(file.getFreeSpace());//可用空间的大小
    }

    /**
     * @param file2
     */
    private static void methodDemo3(File file) {

//      创建文件夹
        boolean dir=file.mkdir();
        System.out.println(dir);


        boolean exist=file.exists();
        System.out.println(exist);

        boolean del=file.delete();//删除文件夹时，必须保证该文件夹没有内容。有内容必须先把内容删除，才可以删除当前文件
        System.out.println(del);

//      3、创建多级目录
        boolean dirs=file.mkdirs();
        System.out.println(dirs);

//      4、判断是不是文件、是不是文件夹
        System.out.println("file:"+file.isFile());
        System.out.println("dir:"+file.isDirectory());

    }

    /**
     * @param file
     * @throws IOException 
     */
    private static void methodDemo2(File file) throws IOException {
//      1、创建文件夹
        boolean b=file.createNewFile();//创建文件  如果文件存在。则不创建返回false  不存在就创建 返回true
        System.out.println(b);

//      2、删除
        boolean d=file.delete();
        System.out.println("delete:"+d);
    }

    /**
     * @param file
     */
    private static void methodDemo1(File file) {
        String path=file.getAbsolutePath();//获取文件的绝对路径，即使封装的是相对的，获取的也是绝对的
        System.out.println(path);//获取的是file对象的封装路径，封装的是什么，获取的的就是什么


        String path1=file.getPath();
        System.out.println(path1);

        long time=file.lastModified();//现在的Unix时间戳(Unix timestamp)
        Date date=new Date(time);//日期转换
        String str_date=DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG).format(date);
        System.out.println(str_date);

        boolean b=file.isHidden();//判断文件是否隐藏
        System.out.println("isHiddden"+b);
    }
}

过滤文件名称

package cn.myio.demo;

import java.io.File;
import java.io.FilenameFilter;

public class FileDemo3 {
    /**
    * @param args
    */
    public static void main(String[] args) {

//      获取指定文件夹中的所有文件和文件夹的名称。能不能只获取.java文件呢？
        File file=new File("C:\\");
        String[] names=file.list();//列出当前目录下的所有文件和文件夹名称，包含隐藏文件
                                    //只能获取名称，不能获取大小
        /*for(String name:names){
            System.out.println(name);
        }*/
        /*
         //同上面一种写法
        if(names!=null){
            for(String name:names){
                System.out.println(name);
            }
        }
        */

        File[] files=file.listFiles();
        /*for(File f:files){
            System.out.println(f);
        }*/

        //获取指定目录下.java文件
        File file2=new File("D:\\java\\workspace\\Stage2\\src\\cn\\myio\\demo");

//      传入一个过滤器
//      String[] name_filter=file2.list(new FileBySuffix(".class"));//过滤后缀名的过滤器
        FilenameFilter filter=new FileBySuffix(".java");//过滤后缀名的过滤器
        filter=new FilerByContain("Demo");

        String[] names2=file2.list(filter);
        for(String name:names2){
//          if(name.endsWith(".java"))//相当于过滤
                System.out.println(name);

        }
    }
}

package cn.myio.demo;

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

public class FileFilterDemo {
    /**
    * @param 文件过滤器  FileFilter
    */
    public static void main(String[] args) {
        File dir=new File("C:\\");
//      传递过滤器
        FileFilter filter=new FilerByFile();
        File[] files=dir.listFiles(filter);
        for (File file : files) {
            System.out.println(file);
        }
    }
}

输出流写入文件

package cn.myio.demo;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutPutStramDemo {
    /**
    * @param 将数据包写到文件当中
    * 使用字节输出流
    * FileOutputStream
     * @throws IOException 
    */
    public static void main(String[] args) throws IOException {
        File file=new File("D:\\java\\workspace\\Stage2\\src\\cn\\myio\\demo\\tempfile");
    /*  
        1、创建字节输出流对象，用于从奥做文件，在对象初始化时，必须明确数据存储的目的地
        输出流所关联的目的地，如果不存在，会自动创建
    */  
        FileOutputStream fileOutputStream=new FileOutputStream("D:\\java\\workspace\\Stage2\\src\\cn\\myio\\demo3.txt");

//      调用输出流的写功能
        String string="3sdsfsf";
        byte[] buf=string.getBytes();
        fileOutputStream.write(buf);
        fileOutputStream.write("我是大灰狼".getBytes());

//      3、释放资源
        fileOutputStream.close();
    }
}

package cn.myio.demo;

import java.io.File;
import java.io.FilenameFilter;

public class FilerByContain implements FilenameFilter {
    private String content;

    /**
     * @param content
     */
    public FilerByContain(String content) {
        super();
        this.content = content;
    }

    @Override
    public boolean accept(File dir, String name) {
        return name.contains(content);
    }

}

package cn.myio.demo;

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

public class FilerByFile implements FileFilter {

    @Override
    public boolean accept(File pathname) {
        return pathname.isFile();
    }
    /**
    * @param args
    */
}

package cn.myio.demo;

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

/**
 * @author john5
 *
 */
public class FilterBySuffix implements FileFilter {
    private String suffix;
    @Override
    public boolean accept(File pathname) {
        return pathname.getName().endsWith(suffix);
    }
    /**
     * @param suffix
     */
    public FilterBySuffix(String suffix) {
        super();
        this.suffix = suffix;
    }

}

获取文件夹下的内容

package cn.myio.demo;

import java.io.File;

public class GetAllFile {
    /**
    * @param args
    */
    public static void main(String[] args) {
    /*  
        遍历指定目录下的内容（包含子目录中内容）
        递归：函数自身调用自身，函数内部又使用到了该函数的功能
        */
        File dir=new File("D:\\java\\workspace");
        getAllfiles(dir);
    }
    public static void  getAllfiles(File dir) {
        //获取该目录的文件对象数组
        File[] files=dir.listFiles();

//      对数组进行遍历
        for (File file : files) {
            if(file.isDirectory()){
                getAllfiles(file);
            }else {
                System.out.println(file);
            }
            System.out.println(file);
        }
    }
}

输入输出流

package cn.myio.demo;

import java.io.File;

public class IoDemo {
    /**
    * @param args
    *  
    *  /**
    * @param 
    * 流按操作数据分为两种：字节流与字符流
    * 流按流向分为：输入流（读）输出流（写）
    * 字节流的抽象基类：InputSream   OutputStream
    * 字符流的抽象基类
    * 
    *
    * IO流用来处理设备之间的数据传输
        Java对数据的操作是通过 流（系统资源） 的方式的
        Java用于操作流的对象都在java.io包中

        Io：用于处理设备上的数据的技术。设备：内存，硬盘。光盘
        流：系统资源，windows系统本身就可任意操作设备，各种语言只是使用系统平台的这个资源
        并对外提供了各种语言自己的操作功能，这些功能最终调用的是系统资源
        使用完资源一定要记住：释放
        设备上数据最常见的存储表现形式文件file

        先学习一下文件的基本操作
        描述文件或者文件夹的类是file
    */
    private static final String FILE_SAPARATOR=System.getProperty("file.separator");

    public static void main(String[] args) {
//      将具体的路径封装成了File对象。可以封装存在的文件或目录，也可以封装不存在的文件或目录

        File file=new File("C:\\1.txt");

        //File(String parent,String child)
        File file1=new File("C:\\","1.txt");
        File dir=new File("c:\\");
        File file2=new File(dir,"1.txt");
        File file3=new File("c:"+FILE_SAPARATOR+"abc"+FILE_SAPARATOR+"1.txt");      
        File file4=new File("C:\\abc\\1.txt");
        System.out.println(file3);
    }
}

过滤器

package cn.myio.demo;

import java.io.File;
import java.io.FileFilter;
import java.util.ArrayList;
import java.util.List;

public class IODemo2 {
    /**
    * @param 
    * 获取一个想要的指定文件的集合 获取wokespace下（包含子目录）的所有的.java的文件对象，并存储到集合中
    * 思路：
    * 1、既然包含子集合，就需要递归
    * 2、在递归过程中需要过滤器
    * 3、满足条件，都添加到集合中
    * 
    * 
    */

    /**
     * 定义一个获取指定条件的文件的集合
     * 
     *多级目录下都要用到相同的集合和过滤器  那么不要在递归方法中定义，而是不断地进行传递
     * @param dir 需要遍历的目录
     * @param list 用于存储符合条件的File对象
     * @param filter 接受制定的过滤条件
     *
     */
    public static void main(String[] args) {
        File dir=new File("D:\\java\\workspace");
        List<File> list=fileList(dir);
        for (File file : list) {
            System.out.println(file);
        }
    }

    public static void getFileList(File dir,List<File> list,FileFilter filter) {
//      1、通过listFiles放啊，获取dir当前下的所有的文件和文件夹对象
        File[] files=dir.listFiles();
//      2、遍历该数组
        for (File file : files) {
//          3、判断是否是文件夹，如果是，递归。如果不是，那就是文件夹，就需要对文件进行过滤
            if(file.isDirectory()){
                getFileList(dir, list, filter);
            }else {
//              4、通过过滤器对文件进行过滤
                if(filter.accept(file)){
                    list.add(file);
                }
            }

        }
    }
    public static List<File> fileList(File dir) {
//      1、定义集合
        List<File> list=new ArrayList<File>();
//      2、定义过滤器
        /*FileFilter fileFilter=new FileFilter() {

            @Override
            public boolean accept(File pathname) {
                return pathname;
            }
        };*/

        FileFilter filter=new FilterBySuffix(".java");
        getFileList(dir, list, filter);
        return list;
    }
}

调用system方法

package cn.myio.demo;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class IOExceptionDemo {
    /**
    * @param args
    */
    static final String Line_SEPARATOR=System.getProperty("line.separator");
    public static void main(String[] args) throws IOException {

        FileOutputStream fileOutputStream=null;
        try {
//  传入true  续写
             fileOutputStream=new FileOutputStream("D:\\java\\workspace\\Stage2\\src\\cn\\myio\\demo3.txt",true);           
            fileOutputStream.write("\r\n我是大灰狼".getBytes());
            fileOutputStream.write(Line_SEPARATOR.getBytes());

        } catch (IOException e) {

        }finally {
            if(fileOutputStream!=null){//关闭资源前必须判断
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException("关闭失败"+e);
                }
            }

        }
    }
}