文件管理

File类

相对路径：相对于项目的路径 绝对路径 路径全称
import java.io.File;
import java.lang.Object;
字段：跨平台的分隔符可能不同可以调用去查看
路径分隔符（;）File.pathSeparator()
名称分隔符（\）File.separator()
他们相当于类里面的常量

System.out.println(File.separator)
//Ctrl+鼠标左键pathSeparator
public static final String pathSeparator = "" + pathSeparatorChar;

一.File类内的三种构造方法

//构造方法的参数即括号内都是用双引号
1.File​(String pathname)
//通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例
2.File​(File parent, String child)文件
路径对象，文件名
//从父抽象路径名和子路径名字符串创建新的 File实例
3.File​(String parent, String child)
路径名，文件名
//从父路径名字符串和子路径名字符串创建新的 File实例

二.File类内的常用方法

File的createNewFile方法

对象名.createNewFile()；
创建的是文本文件
当且仅当具有此名称的文件尚不存在时，以原子方式创建由此抽象路径名命名的新空文件

public boolean createNewFile() throws IOException

File的mkdir方法和mkdirs

对象名.mkdir()；
创建的是文件夹
mkdirs 创建此抽象路径名指定的目录，包括任何必需但不存在的父目录D://****/**/*把它最后个前面的文件夹都创出来，而mkdir就创建最后那个，前面的需要有，不然出错

public boolean mkdir() 

getAbsoluteFile()、getAbsolutePath()

返回此抽象路径名的绝对形式。诸如D://***/**/
亲测一致，就返回值不一样

public String getAbsolutePath()//返回此抽象路径名的绝对路径名字符串
public File getAbsoluteFile()//返回此抽象路径名的绝对形式

getName()、getPath()

public String getName()//返回此抽象路径名表示的文件或目录的名称。
public String getPath()//将此抽象路径名转换为路径名字符串

getParent()、getParentFile()

返回此抽象路径名父项的路径名字符串，如果此路径名未指定父目录，则返回 null 。
返回此抽象路径名父项的抽象路径名，如果此路径名未指定父目录，则返回 null 。即获取父文件夹的对象

public String getParent()
public File getParentFile()

length()

返回此抽象路径名表示的文件的长度。1024kb=1m

public long length()

exists() 、isFile()、 isDirectory()

public boolean exists()//测试此抽象路径名表示的文件或目录是否存在
public boolean isFile()//测试此抽象路径名表示的文件是否为普通文件
public boolean isDirectory()//测试此抽象路径名表示的文件是否为目录

list()、listFile()

public String[] list()//返回一个字符串数组，用于命名此抽象路径名表示的目录中的文件和目录
public File[] listFiles()//返回一个抽象路径名数组，表示此抽象路径名表示的目录中的文件。

renameTo​(File dest)

重命名此抽象路径名表示的文件，相当于移动了 文件
此方法行为的许多方面本质上都依赖于平台：
重命名操作可能无法将文件从一个文件系统移动到另一个文件系统，它可能不是原子的，如果具有目标抽象路径名的文件，它可能不会成功已经存在。 应始终检查返回值以确保重命名操作成功

public boolean renameTo(File dest)

---

File练习

import java.io.File;
public class DemoFile {
    
	//搞D盘，C可能异常
    public static void main(String[] args) throws IOException {
    
    	//创建对象，参数："D://+****"，此时调用的是一参构造方法
        File file = new File("D://1.txt");
        //创建flag来表示是创建文件还是已存在
        boolean flag = file.createNewFile();
        System.out.println(flag?"创建成功":"创建失败");//三目运算符
        
        //创建dir对象，在java中先命名在C盘为"dir创建的文件夹"
        File dir = new File("D://dir创建的文件夹");
        //dir.mkdir();//调用方法创建它你创建一次就注释掉

        File a = new File(dir,"a.txt");//通过创建的那个文件对象
        //a.createNewFile();
        File b = new File("D://dir创建的文件夹","b.txt");//通过文件的路径，文本文件
        //b.createNewFile();
        a.delete();
        b.delete();
        file.delete();
        dir.delete();
		
		File f = new File("一个路径");
		File newf = new File("你要改的那个路径");
		file.renameTo(newf);
		
		
    }
}

mkdir与createNewFile的调用区别

File dir = new File ("C://1.txt");
//dir.createNewFile();上面那个创建的是文本文件,名字是1,.后面是它的格式
dir.mkdir();
//这个就是生成一个文件夹，名字就是  1.txt

---

File遍历

import java.io.*;

public class DemoListFile {
    
    public static void main(String[] args) {
    
        File file = new File("E:\\");
        File[] files = file.listFiles();
        listFiles(files);

    }

    public static void listFiles(File[] files){
    
        if(files != null && files.length>0){
    
            for (File f:files) {
    
                if(f.isFile()){
    
                    //是文件
                    if(f.getName().endsWith(".avi")){
    
                        //找到一个avi文件
                        //E:\Python\第02周-Python3.5-零基础-高级-项目实战最新教程-共14章节\第二周-第05章节-Python3.5-python数据类型.avi
                        //E:\Python\第02周-Python3.5-零基础-高级-项目实战最新教程-共14章节\第二周-第05章节-Python3.5-python数据类型.avi
                        System.out.println(f.getAbsolutePath());
                    }
                }else{
    
                    File[] files2 = f.listFiles();
                    listFiles(files2);
                }
            }

        }

    }
}

文件的过滤器
FileFilter接口
下面的方法和实现类都必须是static…

public interface FileFilter {
    
    boolean accept(File pathname);
}

import java.io.*;

public class DemoFilter {
    
    public static void main(String[] args) {
    
        File file = new File("c:\\");
        filter(file);
    }
    public static void filter(File file){
    
        //创建一个过滤器并创建规则
        FileFilter filter = new AVIFileFilter();
        //通过文件获取子文件夹，把上面的过滤器加载创建文件数组的时候
        File[] files = file.listFiles(filter);
        if(files!=null && files.length > 0)
        for (File f:files) {
    
            if(f.isDirectory()){
    
                filter(f);
            }else{
    
                System.out.println("发现avi"+f.getAbsolutePath());
            }
        }
    }
    static class AVIFileFilter implements FileFilter{
    
        @Override
        public boolean accept(File pathname) {
    
            //实现过滤器接口的方法（快捷键impements），过滤是否是avi
            if(pathname.getName().endsWith(".avi")||pathname.isDirectory())
                return true;
            return false;
        }
    }
}

优化后

import java.io.*;

public class DemoFilter2 {
    
    public static void main(String[] args) {
    
        File file = new File("E:\\");
        filter(file);
    }
    public static void filter(File file){
    
        //把接口的实现用匿名内部类实现
        //并把这个实现了的借口直接过滤在创建的文件夹数组如下行
        File[] files = file.listFiles(new FileFilter() {
    
            @Override
            public boolean accept(File pathname) {
    
                if(pathname.getName().endsWith(".avi")||pathname.isDirectory()){
    
                    return true;
                }
                return false;
            }
        });
        if(files!=null && files.length > 0)
            for(File f:files) {
    
                if(f.isDirectory()){
    
                    filter(f);
                }else{
    
                    System.out.println("发现avi"+f.getAbsolutePath());
                }
            }
    }
}

IO流

IO概述：移动文件，数据传输操作，看做是一种数据流动，按照流动的方向分为输入Input输出Output
java中的IO操作主要指java.io包下的一些常用类的使用，通过这些类对数据进行读取（输入Input）和写出（输出Output）
IO流的分类：按照列的方向分为输入流和输出流
按流动的数据类型分为字节流和字符流

	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

上面的都是最顶级的父类

字节流

一切皆字节：计算机任何数据都是以二进制形式存储的
java.lang.Object
java.io.OutputStream 抽象类

java.io.FileOutputStream实例类 子类

构造器

FileOutputStream​(File file)
FileOutputStream​(String name)
FileOutputStream​(String name, boolean append)
FileOutputStream​(File file, boolean append)

方法

FileOutputStream实例代码

public static void main(String[] args) throws IOException {
    
        //一个流重新创建时才是否追加，不追加再写入会清空原内容,流关闭之前都是写的一个内容
        FileOutputStream fos = new FileOutputStream("E:\\a.txt",true);//加true就是写入追加
        //fos.write(65);//字节写入出来就是A
        //fos.close();//流关闭后在写入就出错
        byte[] bytes = {
    65,66,67,68};//{};内可换成“ABCD”.getByte();
        fos.write(bytes);
        //写一部分,一下标两个内容
        fos.write(bytes,1,2);
        fos.close();
}

java.io.FileInputStream实例类 子类

java.io.InputStream 抽象类其父类

构造器

FileInputStream​(File file)
FileInputStream​(String name)

read方法及应用

public int read() throws IOException

read读取一个

        FileInputStream fis = new FileInputStream("E:\\a.txt");
        //byte b = (byte)fis.read();//read返回值是int
        while(true){
    
            //read一次读取一个字节内容
            byte b = (byte)fis.read();
            //read读到末尾时时-1
            if(b ==-1){
    
                break;
            }
            System.out.println(b);

read读取一组(经场用)
一组一组的存在指定个数数组内，不够十个的对上个内存的前几个种植后面面得、

FileInputStream fis = new FileInputStream("E:\\a.txt");
byte[] bytes = new byte[10];
fis.read(bytes);
System.out.println(new String(bytes));
fis.read(bytes);
System.out.println(new String(bytes));
fis.read(bytes);
System.out.println(new String(bytes));
f.close();

加上指定长度就可以避免

FileInputStream fis = new FileInputStream("E:\\a.txt");
byte[] bytes = new byte[10];
int len = fis.read(bytes);
System.out.println(new String(bytes,0,len));
len = fis.read(bytes);
System.out.println(new String(bytes,0,len));
len = fis.read(bytes);
System.out.println(new String(bytes,0,len));

len = fis.read(bytes);
System.out.println(len);
f.close();

文件加密解密

    public static void main(String[] args) throws IOException {
    
        System.out.println("请输入文件存储的绝对路径：");
        Scanner input = new Scanner(System.in);
        //字符串存输入的地址
        String fileName = input.next();
        //源文件a.png
        File oldFile = new File(fileName);
        //加密存储的新文件mi-a.png
        File newFile = new File(oldFile.getParentFile(),"mi-"+oldFile.getName());

        FileInputStream fis= new FileInputStream(oldFile);
        FileOutputStream fos = new FileOutputStream(newFile);
        while(true){
    
            int b = fis.read();
            if(b==-1){
    
                break;
            }
            //^任何数据都是其本身
            fos.write(b^10);
        }
        System.out.println("加密或解密完成");

    }

字符流

字符编码
字节流读文字出现乱码，只有读文字用字符流
字符流是读取一个完整的文字为一个单位，不会出现读一半
字节流除了文字

字符输出Writer 子类FIleWriter

构造方法
FileWriter​(File file)
append的源代码，返回的是Writer（多态），所以append可以连续追加一直调用，调用完还是这个对象态

    @Override
    public Writer append(CharSequence csq) throws IOException {
    
        if (csq instanceof CharBuffer) {
    
            se.write((CharBuffer) csq);
        } else {
    
            se.write(String.valueOf(csq));
        }
        return this;
    }

FileWriter实例

    public static void main(String[] args) throws IOException {
    
        FileWriter fw = new FileWriter("E:\\b.txt",true);
        fw.write("爱");
       // FileWriter fw2 = (FileWriter)fw.append("你");
		fw.append("你").append("你").append("你");
        fw.close();
        //System.out.println(fw==fw2);
    }

字符输 Reader 入子类FileReader

FileReader
跟FileInputStream类似

public static void main(String[] args) throws IOException {
    
        FileReader fr = new FileReader("E:a.txt");
        //int c= fr.read();
        //System.out.println((char)c);

        char[] chars = new char[100];//创建的数组都有默认值100很大后面变成空格打印出来
        //fr.read(chars);
        //System.out.println(((int)chars[0]);看看初试的值

        //那么就指定出来长度，read返回的是int
        int len = fr.read(chars);
        System.out.println(new String(chars,0,len));
        fr.close();

    }

flush刷新管道

flush和close，close 相当于把刷新管道关闭，相当于刷新了
不刷新在内存中没有传到文件

转换流InputStreamReader与OutputStreamWriter

    public static void main(String[] args) throws IOException {
    
        //转换流
        //字节流装饰为字符流  ：使用了装饰者设计模式
        FileInputStream fis = new FileInputStream("E:\\a.txt");
        //将字节输入流 转换为字符输入流
        //参数1.要装换的字节流
        //参数2.指定编码名称
        InputStreamReader isr = new InputStreamReader(fis);
        while (true) {
    
            int c = isr.read();
            if (c == -1) {
    
                break;
            }
            System.out.println((char) c);
        }

        //字符装饰为字节
        FileOutputStream fos = new FileOutputStream("E:\\a.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos);
        osw.write("回避不");
        osw.close();
    }

特殊流Print与BufferedReader

    public static void main(String[] args) throws IOException {
    
        //字符输出  打印流
        /*System.out.println();//源码out是PrintStream类
        //自己创建个打印
        PrintStream ps = new PrintStream("E:\\c.txt");
        ps.println("床前明月光");//打印在文件，有点像Write*/

        /*PrintWriter pw = new PrintWriter("E:\\c.txt");
        pw.println("床前明月光");
        pw.flush();//这个需要刷新管道缓存*/

        //这两个打印流转换
        FileOutputStream fos = new FileOutputStream("E:\\c.txt");
        PrintWriter pw = new PrintWriter(fos);
        pw.println("哈哈哈");
        pw.flush();

        //缓存读取流，将字符输入流 转换为带有缓存 可以一次读取一行的缓存字符读取流
        FileReader fw = new FileReader("E:\\a.txt");
        BufferedReader br = new BufferedReader(fw);
        br.readLine();
    }

收集异常日志

    public static void main(String[] args) throws FileNotFoundException {
    
        try{
    
            String s = null;
            s.toString();
        }catch(Exception e){
    
            PrintWriter pw = new PrintWriter("c:\\bug.txt");
            SimpleDateFormat sdf = new SimpleDateFormat("yyyyy-MM-dd HH:mm");
            pw.println(sdf.format(new Date()));
            e.printStackTrace(pw);
            pw.close();
        }
    }