java中关于文件流的总结

      [File类]
      1、 作用： 用于对磁盘文件进行操作。 删除、创建等。
      
      2、 三种常用的构造函数：
        ① File file1 = new File("F:\\test");
           直接传入一个路径，拿到一个文件或者是文件夹。
         ② File file2 = new File("F:\\test","test.txt");
          第一个参数传入父路径、 第二个参数传入子路径或者文件。
         ③ File file3 = new File(file1,"test.txt");
         第一个参数传入一个父路径的file对象， 第二个参数传入子路径或者文件。
     
     3、 路径的表示：
        文件夹的分隔，可以使用"/"(通常用于Linux系统，Windows也适用)
        也可以使用"\\"(通常用于Windows)，注意一个\需要进行转义。。
     
    
    public static void main(String[] args) {
    
    File file1 = new File("F:/test");
    
    File file2 = new File("F:\\test","test.txt");
    
    File file3 = new File(file1,"test.txt");
    
    
    /**
     * 检测文件是否可读
     */
    System.out.println(file1.canRead());
    /**
     * 检测文件是否可写
     */
    System.out.println(file2.canWrite());
    /**
     * 比较两个对象是否相等
     */
    System.out.println(file2.equals(file3));
    /**
     * 检测文件是否存在
     */
    System.out.println(file1.exists());
    /***
     * 取到文件的绝对路径
     */
    System.out.println(file1.getAbsolutePath());
    /**
     * 取到文件名或者文件夹名
     */
    System.out.println(file2.getName());
    /**
     * 取到当前文件或文件夹的父路径
     */
    System.out.println(file1.getParent());
    /**
     * 检测当前文件是否是绝对路径
     */
    System.out.println(file1.isAbsolute());
    /**
     * 检测当前路径是否是目录
     */
    System.out.println(file2.isDirectory());
    /**
     * 检测当前路径是否是文件
     */
    System.out.println(file1.isFile());
    
    /**
     * 删除文件: 删除成功返回true，删除失败返回false
     * 如果删除的是文件夹，则只能删除空文件夹，否则删除失败！
     */

// System.out.println(file2.delete());
System.out.println("--------------------------");
System.out.println(file1.delete());
System.out.println("--------------------------");

    /**
     * 创建一个新文件。 创建失败返回false
     */

// System.out.println("_________________________________");
// try {
// System.out.println(file3.createNewFile());
// } catch (IOException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }

    /**
     * 创建一个文件夹。只有当文件夹不存在时，才能创建成功。
     * mkdir: 只能创建一层目录，如果倒数第二层目录也不存在，将创建失败。
     * mkdirs： 可以创建多层目录，无论有几层不存在，都可以依次创建。
     */
    System.out.println("_________________________________");
    System.out.println(file1.mkdir());
    System.out.println(file1.mkdirs());
    
    /**
     * 获得文件所在分区的总大小和可用大小，以字节B为单位。
     */
    System.out.println(file1.getTotalSpace());
    System.out.println(file1.getUsableSpace());
    
    /**
     * 返回当前文件或文件夹的大小。单位B
     */
    System.out.println(file2.length());
    
    
    /**
     * list(): 返回当前目录中的所有文件和文件夹的名字。 返回值类型为String数组
     * 
     * 可以在参数中，传入FilenameFilter接口的实现类对象，表示对列表中的所有文件进行遍历过滤。
     * 需要重写accept方法，如果保留当前文件return true ，如果不要当前文件，return false
     */

// String[] list = file1.list(new FilenameFilter() {
// // dir: 表示包含当前文件的父路径；
// // name： 表示当前文件名
// public boolean accept(File dir, String name) {
// if(name.endsWith(".txt")){
// return true;
// }else{
// return false;
// }
// }
// });
// for (String item : list) {
// System.out.println(item);
// }

    /**
     * .listFiles(): 返回当前目录中所有的文件和文件夹的路径。 返回值类型为File数组。
     * 同样可以对文件进行过滤：
     * ① 与list()一样，使用FilenameFilter进行过滤；
     * ② 使用FileFilter接口的实现类，进行过滤。
     */

// File[] files = file1.listFiles(new FileFilter() {
// // pathname 表示当前文件的全路径(包括路径名和文件名)。
// public boolean accept(File pathname) {
// if(pathname.getName().endsWith(".txt")){
// return true;
// }else{
// return false;
// }
// }
// });
// for (File file : files) {
// System.out.println(file.getParent()+"-----"+file.getName());
// }

    /**
     * 重命名一个文件。 要求传入一个新文件名的file对象。
     */

// File file4 = new File("F:\test\test08.txt");
// System.out.println(file1.renameTo(file4));

// System.out.println(file1.setReadOnly());
// System.out.println(file1.setLastModified(new Date().getTime()));

}

}

//============================================================================================================

      [Java中的IO流]
      1、 根据流的方向： 输入流和输出流
        根据读取文字的大小: 字节流和字符流
        (字节流按字节读取，读取中文时容易乱码； 字符流按照字符读取，通常用于读取中文)
         根据读取的方式： 节点流和缓存流
     
     

public class Demo03_FileInputStream_FileOutStream {
public static void main(String[] args) {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream("F:/test.txt");
/**
* 如果第二个参数省略，或传入false，则表示每次写入时将原文件清空，从文件头部开始写入。
* 如果第二个参数传入true，则表示不清空原文件，在文件末尾处追加新内容。
*/
fos = new FileOutputStream("F:/out.txt",false);
System.out.println(fis.available());
StringBuffer sb = new StringBuffer();

        /**
         * 按照字节，一个一个字节读取文件
         */
        int n = -1;
        while ((n = fis.read()) != -1) {
            sb.append((char)n);
        }
        System.out.println(sb);
        
        /**
         * 将byte数组直接声明为输入流的长度，一次性读出所有文字。
         */

// byte[] bytes = new byte[fis.available()];
// fis.read(bytes);
// sb.append(new String(bytes));
// System.out.println(sb);

        /**
         * 一次读取1024个字节。
         */

// byte[] bytes = new byte[1024];
// int n = -1;
// while ((n = fis.read(bytes)) != -1) {
// sb.append(new String(bytes));
// }
// System.out.println(sb);

        sb.reverse();
        /**
         * 将字符串转为Byte数组，并通过输出流写入文件。
         */
        fos.write("12345".getBytes());
        System.out.println(sb);
        
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        /**
         * finally 无论上述代码是否会出现异常，都会执行的一段代码；
         * 通常用于关闭各种资源。
         */
        try {
            fis.close();
            fos.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
}

}

      [BufferedInputStream、BufferedOutputStream]
      
      继承自java.io.FilterOutputStream（此类是过滤输出流的所有类的超类）
     
     1、 作用： 在基本流的基础上进行包装，读取或者写入文件时，将通过缓存进行。
         即，先将内容写入到缓存区，缓存区满以后再进行读取或写入操作。
        可以大大减小文件的操作次数，提高写入效率。
      
      2、 缓存流的使用：
         在基本流的基础之上，进行包装：
         new BufferedInputStream(new FileInputStream("F:/test.txt"));
         这种写法，我们称之为IO链，IO关闭时只需要关闭最外层流，内层流将自动关闭。
         
      3、 BufferedOutputStream在关闭前，通常调用bos.flush();
         表示关闭前将缓存进行刷新，将缓存区剩余未满的内容写入文件。
         但是一般.close()方法，自带刷新功能。
      
    public class Demo04_BufferedInputStream_BufferedOutStream {
public static void main(String[] args) {
    
    BufferedInputStream bis = null;
    BufferedOutputStream bos = null;
    try {
        bis = new BufferedInputStream(new FileInputStream("F:/test.txt"));
        
        bos =  new BufferedOutputStream(new FileOutputStream("F:/out.txt",false));
        
        StringBuffer sb = new StringBuffer();
        
        int n = -1;
        while ((n = bis.read()) != -1) {
            sb.append((char)n);
        }
        System.out.println(sb);
        
        bos.write(sb.toString().getBytes());
        
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        /**
         * finally 无论上述代码是否会出现异常，都会执行的一段代码；
         * 通常用于关闭各种资源。
         */
        try {

// fis.close();
bis.close();
// fos.close();

            /**
             * 在程序最后，刷新缓存流，将缓存流中未满的内容，写入到文件中。
             * 调用close()方法，将自动刷新。
             */
            bos.flush();
            bos.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
}

}

转载于:https://www.cnblogs.com/dadada-jiasheng/p/8912208.html