1、File

1、文件的分隔符和，路径分隔符

// 获取路径分隔符，文件分隔符
// 路径中的两个反斜杠代表一个反斜杠
System.out.println(File.pathSeparator);
System.out.println(File.separator);

2、文件路径打印

File fil1 = new File("C://a.txt");
System.out.println(fil1.toString());
// 路径分成两部分
File fil2 = new File("C://", "a.txt");
System.out.println(fil2.toString());
// 路径组合
File parent = new File("C://");
File file = new File(parent, "hello.java");
System.out.println(file.toString());

3、getAbsolutePath() 、getPath()

File file1 = new File("/Users/shiji/PacketTracer7/nets");
System.out.println(file1.getAbsolutePath()); // /Users/shiji/PacketTracer7/nets
// 获取当前文件夹下面nets文件路径
File file2 = new File("nets");
System.out.println(file2.getAbsolutePath()); // /Users/shiji/study/java/itcast/nets
// getPath()
File file3 = new File("/Users/shiji/PacketTracer7/nets");
System.out.println(file3.getPath()); // /Users/shiji/PacketTracer7/nets
// 获取当前文件夹下面nets文件路径
File file4 = new File("nets");
System.out.println(file4.getPath());  // nets
System.out.println(file4.toString()); // nets

// getName
File file5 = new File("/Users/shiji/PacketTracer7/nets");
System.out.println(file5.getName()); // nets
File file6 = new File("/Users/shiji/PacketTracer7");
System.out.println(file6.getName()); // PacketTracer7

4、length()、exists()、isDirectory()、isFile()

// Length
File file7 = new File("/Users/shiji/PacketTracer7/nets");
System.out.println(file7.length()); // 130字节
// 判断构造方法中路径是否存在
System.out.println(file7.exists()); // true
// 判断构造方法中给定的路径是否以文件夹结尾
System.out.println(file7.isDirectory()); // false
// 判断构造方法中给定的路径是否以文件结尾
System.out.println(file7.isFile()); // true

4、createNewFile()、mkdir()、mkdirs()

// 1、文件不存在创建文件返回true，否则返回false，
// 2、此方法只能创建文件不能创建文件夹
// 3、createNewFile 抛出IOException异常，路径不存在时抛出异常
File file8 = new File("/Users/shiji/PacketTracer7/1.txt");
System.out.println(file8.createNewFile()); // true
// 1、mkdir 单级文件夹
// 2、mkdirs 单级多级都可以创建
// 3、文件夹不存在返回 true，否则返回false
// 4、此方法只能创建文件夹不能创建文件
File file9 = new File("/Users/shiji/PacketTracer7/a");
System.out.println(file9.mkdir()); // true
File file10 = new File("/Users/shiji/PacketTracer7/b/c/d");
System.out.println(file10.mkdirs()); // true
// delete 删除文件或者目录
File file11 = new File("/Users/shiji/PacketTracer7/b/c/d");
System.out.println(file11.delete());

5、list()、listFiles()

// list() 返回一个string数组，返回目录中的所有子文件或目录
// File[] listFiles() 返回一个File文件数组，返回目录中的所有子文件或目录
File file12 = new File("/Users/shiji/PacketTracer7");
String[] arr = file12.list();
for (String fileName : arr) {
      System.out.println(fileName);
}
File file13 = new File("/Users/shiji/PacketTracer7");
File[] files = file13.listFiles();
for (File fileName : files) {
     System.out.println(fileName);
}

6、打印文件目录下面所有.txt文件

public class Demo01File {
    public static void main(String[] args) throws IOException {
        File file8 = new File("/Users/shiji/PacketTracer7");
        getAllFiles(file8);
    }
    public static void getAllFiles(File dir) {
        File files[] = dir.listFiles();
        for (File f : files) {
            if (f.isDirectory()) {
                getAllFiles(f);
            } else  {
                String filename = f.getName();
                if (filename.endsWith(".txt"))
                    System.out.println(f.toString());
            }
        }
    }
}

2、文件过滤器

1、FileFilter

// 匿名类
File files[] = dir.listFiles(new FileFilter() {
       @Override
       public boolean accept(File pathname) {
            return pathname.isDirectory() || pathname.getName().toLowerCase().endsWith(".txt");
       }
});

2、FilenameFilter

File files[] = dir.listFiles(new FilenameFilter() {
       @Override
       public boolean accept(File dir, String name) {
           return new File(dir, name).isDirectory() || name.toLowerCase().endsWith(".txt");
       }
});

3、IO字节流

1、OutputStream:字节输出流
1）、相关方法

• public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。
• public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。
• public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。
• public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
• public abstract void write(int b) ：将指定的字节输出流。
  2）、写入数据的原理(内存-->硬盘)
  java程序-->JVM(java虚拟机)-->OS(操作系统)-->OS调用写数据的方法-->把数据写入到文件中

构造方法的作用：

• 创建一个FileOutputStream对象
• 会根据构造方法中传递的文件/文件路径，创建一个空的文件
• 会把FileOutputStream对象指向创建号的文件

public class Demo01OutputStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("/Users/shiji/study/java/itcast/day01-code/src/com/sj/IOAndProperties/a.txt");
        // 写数据的时候，会把10机制的整数97转换为二进制整数1100001
        // 记事本存储的是ASCII表中的a
        fos.write(97);
        fos.close();
    }
}

2）、追加写/续写：使用两个参数的构造方法

public class Demo03OutputStream {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("b.txt", true);
        for (int i = 0; i < 5; i++) { 
            fos.write("你好".getBytes());
            //换行符-- windows: \r\n  linux: \n  mac: \r
            fos.write("\r".getBytes());
        }
        fos.close();
    }
}

2、FileOutStream
1）、一次读取一个字节

public class Demo01InputStream {
    public static void main(String[] args) throws IOException {
        // a.txt   ===>  abc
        FileInputStream fis = new FileInputStream("a.txt");
        int len = 0;
        while ((len = fis.read()) != -1) {
            System.out.print((char) len);
        }
        fis.close();
    }
}

2）、一次读取多个字节

public class Demo02InputStream {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("a.txt");
        // byte可以起到缓冲作用，一次读取多个字节
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = fis.read(bytes)) != -1) {
            System.out.println(new String(bytes, 0, len));
        }
        fis.close();
    }
}

4、IO字符流

字节流在读取中文时，可能会出现读取不完整的情况，出现乱码现象
1、FileReader
文件字符输入流
作用：把硬盘文件中的数据以字符的方式读取到内存中
java.io.FileReader extends InputStreamReader extends Reader

public class Demo02Reader {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("b.txt");
        char[] cs = new char[1024];
        int len = 0;
        while ((len = fr.read(cs)) != -1) {
            System.out.println(new String(cs, 0, len));
        }
        fr.close();
    }
}

2、FileWriter
文件字符输出流：把内存中的字符数据写入到文件中
java.io.FileWriter extends OutputStreamWriter extends Writer
使用步骤
1）、创建FileWriter对象，构造方法中绑定要写入数据的目的地
2）、使用FileWriter中的方法writer，把数据写入到内存缓冲区中（字符转换为字节的过程）
3）、使用flush，把内存缓冲区中数据，刷新到文件中，对象可以继续使用。
4）、释放资源（先刷新到缓存区中，然后通知系统释放资源，流对象不可用）

public class Demo03Writer {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("");
        fw.write(97); // 写入到内存缓冲区中
        fw.flush();
        fw.close(); // 也可以将数据写入到文件中
    }
}

try catch 处理

public class Demo01TryCatch {
    public static void main(String[] args) {
        //提高变量fw的作用域,让finally可以使用
        //变量在定义的时候,可以没有值,但是使用的时候必须有值
        //fw = new FileWriter("09_IOAndProperties\\g.txt",true); 执行失败,fw没有值,fw.close会报错
        FileWriter fw = null;
        try{
            //可能会产出异常的代码
            fw = new FileWriter("w:\\09_IOAndProperties\\g.txt",true);
            for (int i = 0; i <10 ; i++) {
                fw.write("HelloWorld"+i+"\r\n");
            }
        }catch(IOException e){
            //异常的处理逻辑
            System.out.println(e);
        }finally {
            //一定会指定的代码
            //创建对象失败了,fw的默认值就是null,null是不能调用方法的,会抛出NullPointerException,需要增加一个判断,不是null在把资源释放
            if(fw!=null){
                try {
                    //fw.close方法声明抛出了IOException异常对象,所以我们就的处理这个异常对象,要么throws,要么try catch
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

JDK7的异常处理情况

public class Demo02JDK7 {
    public static void main(String[] args) {
        try(//1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
            FileInputStream fis = new FileInputStream("c:\\1.jpg");
            //2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
            FileOutputStream fos = new FileOutputStream("d:\\1.jpg");){
            //可能会产出异常的代码
            //一次读取一个字节写入一个字节的方式
            //3.使用字节输入流对象中的方法read读取文件
            int len = 0;
            while((len = fis.read())!=-1){
                //4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
                fos.write(len);
            }
        } catch (IOException e){
            //异常的处理逻辑
            System.out.println(e);
        }
    }
}

JDK9异常处理情况

public class Demo03JDK9 {
    public static void main(String[] args) throws IOException {
        //1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("c:\\1.jpg");
        //2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
        FileOutputStream fos = new FileOutputStream("d:\\1.jpg");

        try(fis;fos){
            //一次读取一个字节写入一个字节的方式
            //3.使用字节输入流对象中的方法read读取文件
            int len = 0;
            while((len = fis.read())!=-1){
                //4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
                fos.write(len);
            }
        }catch (IOException e){
            System.out.println(e);
        }
        //fos.write(1);//Stream Closed
    }
}