java基础之文件与字节流字符流

焱宣

已于 2022-02-17 22:20:04 修改

阅读量868

点赞数

分类专栏： java基础文章标签： java 开发语言后端

于 2022-02-17 22:19:12 首次发布

本文链接：https://blog.csdn.net/qq_22256259/article/details/122974148

版权

java基础专栏收录该内容

21 篇文章 0 订阅

订阅专栏

第一章 File类

1.1 File类作用

1.2 File类的常用构造方法

1.3 File类文件属性方法

1.1 file 类的作用：
在java程序中，对磁盘文件进行描述的类。文件和目录路径名的抽象表示形式。
1.2 File类的常用构造方法
在这里插入图片描述
1.3 File类文件属性方法
属性：

static String pathSeparator：与系统有关的路径分隔符，为了方便，它被表示为一个字符串（;）。
static char pathSeparatorChar： 
static String Separator：与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串（\）。 
static char SeparatorChar：

在这里插入图片描述
方法：

代码一：

代码二：

代码三：

public class FileUsageDemo {

    public static void main(String[] args) {
        String analysisPath = "d:";
        listSubPath(analysisPath);
        findALLJavaTypeFile(analysisPath);
    }

    public static void listSubPath(String path) {
        File file = new File(path);
        if (!file.exists()) {
            System.out.println("该文件不存在，请检查输入路径");
            return;
        }
        if (file.isFile()) {
            System.out.println("输入的路径是文件路径，请检查输入路径");
            return;
        }
        String[] list = file.list();
        System.out.println("该文件夹路径的子文件路径如下：-------------");
        for (String filePath : list) {
            System.out.println(filePath);
        }
    }

    public static void findALLJavaTypeFile(String path) {
        File file = new File(path);
        if (!file.exists()) {
            System.out.println("该文件不存在，请检查输入路径");
            return;
        }
        if (file.isFile()) {
            System.out.println("输入的路径是文件路径，请检查输入路径");
            return;
        }
        File[] files = file.listFiles();
        classJavaTypeFile(files);
    }


    public static void classJavaTypeFile(File[] files) {
        for (File file : files) {
            if (file.isFile()) {
                if (file.getName().endsWith(".java")) {
                    System.out.println("找到了一个java 文件，该文件的路径为" + file.getPath());
                }
            } else {
                File[] subFiles = file.listFiles();
                classJavaTypeFile(subFiles);
            }
        }
    }
}

第二章 IO流

2.1 什么是IO流

2.2 流的作用和原理

2.3 IO流的种类

2.4 字节输入流

2.5 字节输入流

2.6 字符输入流

2.7 字符输出流

2.1 什么是IO 流：
在工作中，经常会去操作磁盘上的资源，这个过程中实现了数据的输入和输出操作，磁盘上的文件和内存进行交互，数据的交互需要有一个媒介或者管道，把这个媒介或者管道称为IO 流，也被称为输入和输出流【I:Input O:Output】
2.2 流的作用和原理：
流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象，即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输将流抽象为各种类，方便更直观的进行数据操作。
2.3 IO 流的种类：
2.3.1 按照流的流向分：输入流，输出流
输入流：表示将数据输入java 程序中（内存）中使用的流
输出流：表示从java 程序（内存）向外传输使用的流
2.3.2 按照数据单位分：字符流，字节流
字节流：一次性传输一个字节数据，将数据以字节的形式传输
字符流：一次性传输一个字符数据，将数据以字符形式传输
2.3.3 按照层次分：节点流，处理流
节点流：可以从或向一个特定的地方（节点）读写数据
处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据的读写
2.4 字节输入流
2.4.1 InputStream 是一个抽象类，不能实例化对象
在这里插入图片描述 2.4.2 文件输入流FileInputStream
代码一：

package com.huawei.stream;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class DemoFileInputStream {

    public static void main(String[] args) {
        // 创建被操作文件：此文件必须存在，否则读取时，抛出文件找不到异常
        File file = new File("d:\\a\\hello.txt");
        //声明流，不初试化
        FileInputStream fileInuptStream = null;

        try {
            fileInuptStream = new FileInputStream(file);
            // 准备数组用来存储数据
            byte[] b = new byte[3];
            // 先定义一个变量，初试值是-1
            int i = -1;
            // 定义一个计数循环的变量
            int count = 0;
            // while 循环读取
            while ((i = fileInuptStream.read(b)) != -1) {
                count++;
                for (int j = 0; j < i; j++) {
                    System.out.println((char) b[j]);
                }
            }
            System.out.println(count);  // 计数：计算循环读取的次数
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.5 字节输出流：
2.5.1 OutputStream类的常用方法
OutputStream是抽象类，不能实例化对象。
在这里插入图片描述

package com.huawei.stream;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class DemoFileOutputStream {
    public static void main(String[] args) {
        //向文件中写入数据
        //设计程序，向d:\\a\\hello.txt中写入hello world
        // 第一步：创建被操作文件对象
        // 当向一个文件中写入数据时，若文件不存在，程序会自动创建
        File file = new File("d:\\a\\.hello.txt");
        FileOutputStream fos = null;
        try {
            // 第二步，创建流对象
            fos = new FileOutputStream(file);
            // 第三步，准备数据
            String str = "hello world";
            byte[] b = str.getBytes();
            System.out.println(b.length);
            // 第四步，使用流写入
            fos.write(b);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    // 第五步，刷新流，关闭流
                    fos.flush();
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.6 字符输入流
Reader类
Reader：是所有字符输入流的父类，为一个抽象类，不能实例化对象，使用它的子类FileReader类

package com.huawei.stream;

import java.io.*;

public class DemoFileReader {
    public static void main(String[] args) {
        //1. 将文件的路径转换为File 对象
        File file = new File("d:\\a\\hello.txt");
        Reader reader = null;
        try {
            // 2. 实例化一个FileReader 对象
            reader = new FileReader(file);
            // 3.定义一个数组
            char[] arr = new char[8];
            // 4. 定义一个int 变量
            int hasRead = 0;
            // 5.循环读取
            while ((hasRead = reader.read(arr)) != -1) {
                String result = new String(arr, 0, hasRead);
                System.out.println(result);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (reader!=null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Writer类:
Writer：是所有字符输出流的父类，为一个抽象类，不能实例化对象，使用它的子类FileWriter类

package com.huawei.stream;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class DemoFileWriter {
    public static void main(String[] args) {
        File file=new File("d:\\a\\hello.txt");
        FileWriter fileWriter=null;
        try {
            fileWriter =new FileWriter(file);
            // 写入，区别于字节流可以直接传字符
            fileWriter.write("hello world");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (fileWriter!=null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

焱宣

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
java基础之文件与字节流字符流

第一章 File类1.1 File类作用1.2 File类的常用构造方法1.3 File类文件属性方法1.1 file 类的作用：在java程序中，对磁盘文件进行描述的类。文件和目录路径名的抽象表示形式。1.2 File类的常用构造方法1.3 File类文件属性方法属性：static String pathSeparator：与系统有关的路径分隔符，为了方便，它被表示为一个字符串（;）。static char pathSeparatorChar： static String Sepa
复制链接

扫一扫