java的I/O学习-CSDN博客

本文链接：https://blog.csdn.net/gs344937933/article/details/89448854

File 类

// 定义：
public class File extends Object implements Serializable, Comparable<File>

//构造方法：
public File(URI uri)
public File(File parent,String child)
public File(String parent,String child)
public File(String pathname)

//常用方法：
public boolean createNewFile() throws IOException
public boolean delete()
public boolean exists()
public boolean isDirectory()
public boolean isFile()
public long lastModified()
public long length()
public String[] list()
public File[] listFiles()
public boolean mkdirs()
public File getParentFile()

代码如下：

public class FileDemo {
    public void deleteFile(String filePath){
        File file = new File(filePath);
        if (file.exists()) { 								// 判断文件是否存在
            boolean b = file.delete();								// 删除文件
            System.out.println(" result :" + b);
        } else { 									// 文件不存在
            try {
                System.out.println(file.createNewFile());			// 创建新文件
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public void createFile(String filePath){
        File file = new File(filePath);
        if (!file.getParentFile().exists()) { 					// 现在父路径不存在
            file.getParentFile().mkdirs(); 				// 创建父路径
        }
        try {
            System.out.println(file.createNewFile());			// 创建新文件
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void getInformation(String filePath){
        File file = new File(filePath);
        if (file.exists()) {
            System.out.println("是否是文件：" + (file.isFile()));
            System.out.println("是否是目录：" + (file.isDirectory()));
            // 文件大小是按照字节单位返回的数字，所以需要将字节单元转换为兆（M）的单元
            // 但是考虑到小数点问题，所以使用BigDecimal处理
            System.out.println("文件大小："
                    + (new BigDecimal((double) file.length() / 1024 / 1024)
                    .divide(new BigDecimal(1), 2,
                            BigDecimal.ROUND_HALF_UP)) + "M");
            // 返回的日期是以long的形式返回，可以利用SimpleDateFormat进行格式化操作
            System.out.println("上次修改时间："
                    + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
                    .format(new Date(file.lastModified())));
        }
    }

    public void printDir(String dirPath){
        File file = new File(dirPath);
        if (file.isDirectory()) { 						// 判断当前路径是否为目录
            File result [] = file.listFiles() ;
            for (int x = 0; x < result.length; x++) {
                System.out.println(result[x]);			// 调用toString()
            }
        }
    }
    
    public void printR(File file) {
        if (file.isDirectory()) { 						// 路径为目录
            File result[] = file.listFiles(); 			// 列出子目录
            if (result != null) { 						// 目录可以列出
                for (int x = 0; x < result.length; x++) {
                    printR(result[x]); 					// 递归调用
                }
            }
        }
        System.out.println(file);						// 直接输出完整路径
    }


    public static void main(String[] args) {
        String filePath = "d:" + File.separator  + "19_develop_tool" + File.separator + "test.txt" ;  // 设置文件的路径
        FileDemo fileDemo = new FileDemo();
//        fileDemo.createFile(filePath);
//        fileDemo.deleteFile(filePath);
//        fileDemo.getInformation(filePath);
//        fileDemo.printDir("d:" + File.separator);
        fileDemo.printR(new File("d:" + File.separator + "03_机器学习" + File.separator));
    }
}

字符流与字节流的区别

在 java.io包中流分为两种：字节流 与 字符流
       字节流：InputStream OutputStream   --字节：byte
       字符流：Reader Writer              --字符：char

字节流和字符流：（1）File类不支持文件内容处理，如果要处理文件内容那么必须通过流的操作模式来完成。（2）字节流：InputStream、outputStream，字节流是原生操作，在进行网络数据传输、磁盘数据保存时支持的数据类型是字节。（3）字符流：Reader、Writer，字符流是经过处理后的操作，字符更适合处理中文。（4）优先使用字节流，只有在处理中文的时候才会使用字符流。

不管是字节流还是字符流，其基本操作流程：
（1）要根据文件的路径创建File类对象；
（2）根据字节流或字符流的子类实例化父类对象；
（3）进行数据的读取，写入操作；
（4）关闭流（close）。

字节流

字节输出流：OutputStream （写入）

定义： public abstract class OutputStream extends Object implements Closeable, Flushable

字节输入流： InputStream （读取）

定义： public abstract class InputStream extends Object implements Closeable

public class ByteStreamDemo {
    public void outputStream(String filePath) throws IOException {
        File file = new File(filePath);                     // 1. 根据文件的路径创建File对象

        if (!file.getParentFile().exists()) {              // 如果文件目录不存在，就创建目录
            file.getParentFile().mkdirs();
        }

        OutputStream output = new FileOutputStream(file);   // 2．应该使用OutputStream和其子类进行对象的实例化
        // 字节输出流需要使用byte类型，需要将String类对象变为字节数组
        String str = "今天天气不错，晚上咱们去吃火锅吧！";
        byte data[] = str.getBytes(); 						// 将字符串变为字节数组
        output.write(data);                                 // 3．输出内容
        output.close();                                     // 4. 关闭流
    }

    public void inputStream(String filePath) throws IOException {
        File file = new File(filePath);                     // 1. 根据文件的路径创建File对象

        if (!file.getParentFile().exists()) {            // 如果文件目录不存在，就创建目录
            file.getParentFile().mkdirs();
        }

        InputStream input = new FileInputStream(file);     // 2．应该使用InputStream和其子类进行对象的实例化

        byte data[] = new byte[1024];
        int len = input.read(data);                        // 3．输出内容
        // 读出来的是字节流（byte类型），需要将byte转换成String
        System.out.println("读取的内容：" + new String(data, 0, len));
        input.close();                                     // 4. 关闭流
    }

    public static void main(String[] args) {
        String filePath = "d:" + File.separator  + "19_develop_tool" + File.separator + "test.txt" ;  // 设置文件的路径
        ByteStreamDemo byteStreamDemo = new ByteStreamDemo();
        try {
 //           byteStreamDemo.outputStream(filePath);
            byteStreamDemo.inputStream(filePath);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字符流

字符输出流：Writer

public abstract class Writer extends Object implements Appendable, Closeable, Flushable

字符输入流：Reader

public abstract class Reader extends Object implements Readable, Closeable

public class CharStreamDemo {
    public void writerStream(String filePath) throws IOException {
        File file = new File(filePath);                   // 1. 根据文件的路径创建File对象

        if (!file.getParentFile().exists()) { 			  // 如果文件目录不存在，就创建目录
            file.getParentFile().mkdirs();
        }

        Writer out = new FileWriter(file);               // 2．应该使用OutputStream和其子类进行对象的实例化
        // 字节输出流需要使用byte类型，需要将String类对象变为字节数组
        String str = "今天天气不错，晚上咱们去吃小龙虾吧！";
        out.write(str);                                  // 3．输出内容
        out.close();                                     // 4. 关闭流
    }

    public void readerStream(String filePath) throws IOException {
        File file = new File(filePath);                     // 1. 根据文件的路径创建File对象

        if (!file.getParentFile().exists()) { 		// 如果文件目录不存在，就创建目录
            file.getParentFile().mkdirs();
        }

        Reader in = new FileReader(file);                 // 2．应该使用InputStream和其子类进行对象的实例化

        char data[] = new char[1024];
        int len = in.read(data);                         // 3．输出内容
        // 读出来的是字节流（byte类型），需要将byte转换成String
        System.out.println("读取的内容：" + new String(data, 0, len));
        in.close();                                     // 4. 关闭流
    }

    public static void main(String[] args) {
        String filePath = "d:" + File.separator  + "19_develop_tool" + File.separator + "test.txt" ;  // 设置文件的路径
        CharStreamDemo charStreamDemo = new CharStreamDemo();
        try {
            //charStreamDemo.writerStream(filePath);
            charStreamDemo.readerStream(filePath);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

字节流转换为字符流

两个类：

OutputStreamWriter：将字节输出流变为字符输出流；

InputStreamReader：将字节输入流变为字符输入流；

文件拷贝

public class CopyDemo {
    public static void main(String[] args) throws Exception {
        String srcFile = "d:" + File.separator  + "19_develop_tool" + File.separator + "test.txt" ;
        String dstFile = "d:" + File.separator  + "19_develop_tool" + File.separator + "test11.txt" ;
        long start = System.currentTimeMillis() ;		// 取得复制开始的时间

        // 如果输入参数正确，应该进行源文件有效性的验证
        File inFile = new File(srcFile) ;				// 第一个为源文件路径
        if (!inFile.exists()) {						// 源文件不存在
            System.out.println("源文件不存在，请确认执行路径。");
            System.exit(1);							// 程序退出
        }
        // 如果此时源文件正确，就需要定义输出文件，同时要考虑到输出文件有目录
        File outFile = new File(dstFile) ;
        if (!outFile.getParentFile().exists()) {			// 输出文件路径不存在
            outFile.getParentFile().mkdirs() ;			// 创建目录
        }
        // 实现文件内容的复制，分别定义输出流与输入流对象
        InputStream input = new FileInputStream(inFile) ;
        OutputStream output = new FileOutputStream(outFile) ;
        int temp = 0 ;							// 保存每次读取的数据长度
        byte data [] = new byte [1024] ;				// 每次读取1024个字节
        // 将每次读取进来的数据保存在字节数组里面，并且返回读取的个数
        while((temp = input.read(data)) != -1) {			// 循环读取数据
            output.write(data, 0, temp);				// 输出数组
        }
        input.close(); 							// 关闭输入流
        output.close();							// 关闭输出流
        long end = System.currentTimeMillis() ;			// 取得操作结束时间
        System.out.println("复制所花费的时间：" + (end - start));
    }
}