JAVA,IOIOIOIOIOIOIOIOIOIOIOIOIOIO

最新推荐文章于 2025-12-15 08:57:28 发布

原创最新推荐文章于 2025-12-15 08:57:28 发布 · 1.4k 阅读

20 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

IO流

1 File类

package cn.javasm.demo;

import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TestDemo {
    public static void main(String[] args) throws IOException {
        //表示创建了一个指向D盘下的test的file对象
        // file对象在创建的时候不会去检查文件是否真实存在
        // 仅仅是将当前的路径标记为一个file对象
        File file = new File("D:\\sdfdf\\dfdf\\dfd");

        // 创建目录  当且仅当目录不存在时才会创建
//        boolean mkdir = file.mkdir();
        // 创建目录  可以创建多级目录
//        boolean mkdir = file.mkdirs();
//        System.out.println(mkdir);
        // 创建文件  当且仅当文件不存在时才会创建
//        boolean newFile = file.createNewFile();
//        System.out.println(newFile);
        // 删除文件/目录
        // 是从计算机中彻底删除
        // 如果是目录，并且这个目录非空，则删除失败
//        boolean delete = file.delete();
//        System.out.println(delete);
        // 获取目录下的所有的子目录和子文件
//        File[] files = file.listFiles();
//        for (File file1 : files) {
//            System.out.println(file1);
//        }
        // 判断file是否是文件
//        System.out.println(file.isFile());
//        // 判断file是否是目录
//        System.out.println(file.isDirectory());
//        del(file);
//        boolean b = file.canWrite();
//        System.out.println(b);
//        // 判断文件或者目录是否存在
//        boolean exists = file.exists();
//        System.out.println(exists);
        // 获取绝对路径:从盘符开始的路径
        // 相对路径:相对于某个目录的路径
//        String absolutePath = file.getAbsolutePath();
//        System.out.println(absolutePath);

        // 获取剩余空间  单位字节
        long freeSpace = file.getFreeSpace();
        System.out.println(freeSpace);
        // 获取总空间
        long totalSpace = file.getTotalSpace();
        System.out.println(totalSpace);
        // 获取可用空间
        long usableSpace = file.getUsableSpace();
        System.out.println(usableSpace);

        //        // 获取目录/文件  名称
//        // separatorChar-- 目录分隔符  在Windows系统是 \\  在Linux中用/表示
        // pathSeparatorChar -- 路径分隔符  在Windows系统是;   在Linux中是:
//        String name = file.getName();
//        System.out.println(name);
//
//        String parent = file.getParent();
//        System.out.println(parent);
//
//        // 判断是否是绝对路径
//        System.out.println(file.isAbsolute());
//        // 判断是否是隐藏文件
//        System.out.println(file.isHidden());
//        // 获取修改时间距离1970年1月1日的毫秒值
//        System.out.println(file.lastModified());

        // 获取目录或文件名称中带数字的内容  匿名内部类
//        File[] files = file.listFiles(new FileFilter() {
//            // 把所有的子目录和子文件通过参数传递到这个方法中
//            // 如果返回true，对应的内容会留在结果中
//            // 如果返回false，对应的内容会被筛选掉
//            @Override
//            public boolean accept(File file1) {
//                return file1.getName().matches(".*\\d.*");
//            }
//        });
//        File[] files = file.listFiles(f -> f.getName().matches(".*\\d.*"));

//        File[] files = file.listFiles(new FilenameFilter() {
//            // dir  上一级目录
//            // name 当前的目录/文件名称
//            @Override
//            public boolean accept(File dir, String name) {
//                return name.matches(".*\\d.*");
//            }
//        });
//        File[] files = file.listFiles((d, n) -> n.matches(".*\\d.*"));
//        for (File file1 : files) {
//            System.out.println(file1);
//        }
        // 移动并且重命名
//        boolean b = file.renameTo(new File("D:\\test\\西游记.txt"));
//        System.out.println(b);
        // 设置文件只读
//        file.setReadOnly();
        // 设置是否可写
//        file.setWritable(true);

        // 距离计算机元年的毫秒值
        // 设置修改时间
        file.setLastModified(1000L);
    }

    // 课堂练习:删除一个目录
    public static void del(File file){
        if (file.isDirectory()){
            // 如果是目录,获取目录中的所有的子目录和子文件
            File[] files = file.listFiles();
            for (File file1 : files) {
               del(file1);
            }
        }

        // 删除目录/文件
        file.delete();
    }
}

课堂练习：统计工作空间中共有多少个java和class文件

    static int javaCount = 0;
    static int classCount = 0;
    public static void count(File file){
        if (file.isDirectory()){
            // 获取所有的子目录和子文件
            File[] files = file.listFiles();
            for (File file1 : files) {
                count(file1);
            }
        }else if (file.getName().endsWith(".java")){
            javaCount++;
        }else if (file.getName().endsWith(".class")){
            classCount++;
        }
    }

2 IO流

2.1 概述

IO流:传输数据的一套机制

I: input 输入流

O:output 输出流

在java中分为字符流和字节流

字符流:只能读写纯文本的内容

字节流:可以读写所有的文件

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

以上的四个类都是抽象类

2.2 FileWriter类

FileWriter类是字符输出流

public static void main(String[] args) {
        FileWriter fileWriter = null;
        try {
            // 创建字符输出流
            // 创建一个新文件
            // 如果原文件不存在，则使用创建的这个新文件
            // 如果原文件已存在，怎使用新文件覆盖原文件
            // append:追加访问
            fileWriter = new FileWriter("a.txt",true);
            // 向文件中写出一个字符串
            fileWriter.write("你好中国");
            // 冲涮缓冲区
            fileWriter.flush();
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            // 释放资源  释放资源的时候会自动冲涮一次缓冲区
            try {
                if (fileWriter != null){
                    fileWriter.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }finally {
                // 标记成垃圾对象
                fileWriter = null;
            }

        }


    }

2.3 FileReader类

public static void main(String[] args) throws IOException {
        // 创建字符输入流
        // 会检查路径是否真实存在
        FileReader fileReader = new FileReader("a.txt");
        // 一次读取一个字符，如果读取结束，返回-1
//        int read = fileReader.read();
//        System.out.println((char)read);
//        int ch;
//        while ((ch = fileReader.read()) != -1){
//            System.out.println((char)ch);
//        }
        // 创建缓冲数组
        char[] chs = new char[5];
        // 把数据读取到数组中，并且返回实际读取到的内容
//        int len = fileReader.read(chs);
//        System.out.println(len);
//        System.out.println(chs);
        int len;
        while ((len = fileReader.read(chs)) != -1){
            System.out.print(new String(chs,0,len));
        }

        // 释放资源
        fileReader.close();
    }

课堂练习:拷贝一个文本文件

public static void main(String[] args) throws IOException {
        // 拷贝文件
        // 创建字符输入和输出流  Charset:可以指定编码格式
        FileReader fileReader = new FileReader("D:\\西游记.txt", Charset.forName("gbk"));
        FileWriter fileWriter = new FileWriter("D:\\test\\三国演义.txt",Charset.forName("gbk"));

        // 定义实际读取到的长度
        int len;
        // 定义缓冲数组
        char[] chs = new char[1024 * 8];
        while ((len = fileReader.read(chs)) != -1){
            // 写出到新的文件中
            fileWriter.write(chs,0,len);
        }

        // 关流  从里到外关
        fileWriter.close();
        fileReader.close();
    }

2.4 BufferedReader和BufferedWriter

高效的字符流，里面自带缓冲区

public static void main(String[] args) throws IOException {
        // 拷贝文件
        BufferedReader bufferedReader = new BufferedReader(new FileReader("D:\\15681.txt"));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("D:\\石头记.txt"));

        String str = null;
        while ((str = bufferedReader.readLine()) != null){
            bufferedWriter.write(str);
            // 换行
            bufferedWriter.newLine();
        }

        // 释放资源
        bufferedWriter.close();
        bufferedReader.close();
    }

    private static void demo1() throws IOException {
        //        FileReader fileReader = new FileReader("D:\\西游记.txt", Charset.forName("gbk"));
//        // 使用装饰设计模式创建字符输入流
//        BufferedReader bufferedReader = new BufferedReader(fileReader);
//        // 一次读取一行字符串   读取到换行符结束 不包含换行符  读取不到返回null
//        String s = bufferedReader.readLine();
//        System.out.println(s);
//        String str = null;
//        while ((str = bufferedReader.readLine()) != null){
//            System.out.println(str);
//        }
//
//        // 释放资源
//        bufferedReader.close();

        // 创建字符输出流
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("D:\\a.txt"));
        bufferedWriter.write("水浒传");
        // 换行
        bufferedWriter.newLine();
        // 释放资源
        bufferedWriter.close();
    }

java23种常用设计模式之一:装饰者设计模式

模式：针对某一类问题的统一的处理方法

设计模式：在软件开发中针对遇到的问题所提供的统一的解决方案

装饰设计模式:利用同类对象来构建本类对象，然后对所构建的对象进行功能的改善和增强。

课堂练习:统计工作空间中代码的行数

public static void count(File file) throws IOException {
        if (file.isDirectory()){
            // 查找子目录和子文件
            File[] files = file.listFiles();
            for (File file1 : files) {
                count(file1);
            }
        }else if (file.getName().endsWith(".java")){//判断是否是java文件
            BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
            while (bufferedReader.readLine() != null){
                count++;
            }
            bufferedReader.close();
        }
    }

2.5 字节流

private static void demo2() throws IOException {
        // 创建字节输入流对象
        FileInputStream fileInputStream = new FileInputStream("D:\\西游记.txt");
        // 一次读取一个字节
//        fileInputStream.read();
        // 创建字节缓冲数组
        byte[] bys = new byte[1024];
        int len;
        while ((len = fileInputStream.read(bys)) != -1){
            System.out.print(new String(bys,0,len,"gbk"));
        }
        // 释放资源
        fileInputStream.close();
    }

    private static void demo1() throws IOException {
        // 创建字节输出流对象
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\aaa.txt");

        // 写出数据
        fileOutputStream.write("周杰伦".getBytes("gbk"));

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

拷贝文件

private static void demo3() throws IOException {
        FileInputStream fileInputStream = new FileInputStream("D:\\win2020-2024(一键激活)pro.zip");
        FileOutputStream fileOutputStream = new FileOutputStream("D:\\test\\1010.zip");
//        int len;
//        byte[] bys = new byte[1024];
//        while ((len = fileInputStream.read(bys)) != -1){
//            fileOutputStream.write(bys,0,len);
//        }
        // 读取所有的字节
//        byte[] bytes = fileInputStream.readAllBytes();
//        fileOutputStream.write(bytes);

        // fileInputStream.available() 读取到的最大字节
        byte[] bys = new byte[fileInputStream.available()];
        fileInputStream.read(bys);
        fileOutputStream.write(bys);

        // 关闭资源
        fileOutputStream.close();
        fileInputStream.close();
    }