Java IO 基础

最新推荐文章于 2024-07-17 16:15:07 发布
最新推荐文章于 2024-07-17 16:15:07 发布
阅读量241 收藏 1
点赞数
分类专栏： IO 文章标签： IO File类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zcq_1234/article/details/60484026
版权

一、File 类

java.io.File 类：文件和目录路径名的抽象表示形式。
通过File对象可以访问文件的属性、访问空文件或目录。

分隔符：

路径分割符：File.pathSeparator
名称分割符：File.separator

路径的表示方式：

path = “E:\test\2.jpg”;
path = “E:” + File.separator + “test” + File.separator + “2.jpg”;
path = “E:/test/2.jpg”;
第二种可以跨平台，推荐第三种

相对路径和绝对路径构造File对象：

相对路径：
File file = new File(parentPath,name);
File file = new FIle(new File(parentPath),name);
System.out.println(file.getName);
System.out.println(file.getPath);

绝对路径：
File file = new FIle(E:/02.jpg);
注意：没有盘符时，以 user.dir 构建

File的相关方法:
1. 文件名

getName() 文件名、路径名
getPath() 路径名
getAbsoluteFile() 绝对路径锁对应的File对象
getAbsolutePath() 绝对路径名
getParent() 父目录，相对路径的父目录，可能为null
renameTo(File newName) 重命名

2. 判断信息

exists()
canWrite()
canReader()
isFile()
isDirectory() 是否是文件夹（不是真实存在的默认为文件夹）
isAbsolute() 是否为绝对路径。消除平台差异，ie以盘符开头，其他的以/开头

3. 长度

length（）：返回字节数。

4. 创建、删除

createNewFil() 不存在创建新文件
delete() 删除文件
static createTempFile(前缀3个字节长，后缀默认.temp) 默认临时空间
static createTempFile(前缀3个字节长，后缀默认.temp,目录)
deleteOnExit() 退出虚拟机时删除，常用于删除临时文件

5. 操作目录

mkdir() 必须确保父目录存在，不存在则创建失败
mkdirs() 如果目录链不存在，一同创建
list() 文件|目录的名称
listFiles() 文件|目录的Flile对象
static listRoots() 根路径

示例
public static void main(String[] args) throws IOException {
  String path = "C:/User/zcq12/";
  File file = new File(path);
  // file.mkdirs();
  if (file.isDirectory()) { // 存在并且为目录
   System.out.println("=============子目录||文件的名称=============");
   String[] subNames = file.list();
   // 遍历出目标文件夹下的文件以及文件夹
   for (String temp : subNames) {
    System.out.println(temp);
   }
   System.out.println("=============子目录||文件的File对象==========");
   File[] subFiles = file.listFiles();
   for (File temp : subFiles) {
    System.out.println(temp.getAbsolutePath());
   }
   System.out.println("=============子文件.java对象=================");
   // 命令设计模式
   subFiles = file.listFiles(new FilenameFilter() {
    // dir:代表src
    @Override
    public boolean accept(File dir, String name) {
     // System.out.println(dir.getName());
     // 遍历dir文件夹下所有的以 .java结尾 并且 不是文件夹的 .java结尾文件
     return name.endsWith(".java") && !(new File(dir, name).isDirectory());
    }
   });
   for (File temp : subFiles) {
    System.out.println(temp.getAbsolutePath());
   }
  }
  System.out.println("============递归输出 孙级目录|文件的绝对路径名称=============");
  getAllFiles();
 }

 /**
  * 输出子孙级目录|文件的绝对路径名称 1. listFiles() 2. 递归  可以做文件搜索
  */
 public static void getAllFiles() {
  String path = "C:/User";
  File parent = new File(path);
  printName(parent);
 }

 private static void printName(File file) {
  if (file == null || !file.exists()) {
   return;
  }
  System.out.println(file.getAbsolutePath());
  if (file.isDirectory()) {
   for (File sub : file.listFiles()) {
    printName(sub);
   }
  }
 }

IO 流

一、流的概念

流：流动流向。从一段到另一端，源头与目的地。

程序 与 文件|数组|网络连接|数据库。以程序为中心(即输出还是输出都是相对于程序来说的)。

二、IO 流分类

  • 1、流向：
    • 输入流
    • 输出流
  • 2、数据：
    • 节流：二进制，可以是一切文件，包括纯文本、doc、音频、视频、图片
    • 字符流：纯文本文件
  • 3、功能
    • 节点流：包裹源头
    • 处理流：增强功能，提供性能

三、字节流与字符流（重点）与文件

1、字节流
- 输入流
- inputStream
- read(byte[] b)
- read(byte[] b, int off, int len)
- close()
- 实现类：FIleInputStream()
- 输出流
- outPutStream
- write(byte[] b)
- wirte(byte[] b, int off, int len)
- flush()
- close()
- 实现类：FileOutputStream()

2、字符流
- 输入流
- reader
- read(char[] cbuf)
- read(char[] cbuf, int off, int len)
- close()
- 实现类：FileReader()
- 输出流
- writer
- write(char[] cbuf)
- write(char[] cbuf, int off, int len)
- flush()
- close()
- 实现类：FileWritre()

四、操作

1、举例 —> 读取文件

（1）关联房子 —> 建立与文件联系

（2）选择搬家公司 —> 选择对应的流

（3）搬家 —> 读取|写出

  1. 卡车大小 —> 数组大小

  2. 运输 —> 读取、写出

（4）打发走over —> 释放资源

2、操作

  1. 建立联系
  2. 选择流
  3. 操作
    1. 数组大小
    2. read、write
  4. 释放资源

实例代码

1. 字节流

输入文件
public class Demo03_inputStream {
    public static void main(String[] args) {
        // 1. 建立联系
        File file = new File("D:/test/a.txt");
        // 2. 选择流
        InputStream is = null;
        try {
            is = new FileInputStream(file);
            byte[] car = new byte[1024];
            int len = 0; // 接收实际读取大小
            // 循环读取
            try {
                // 3. 操作
                while (-1 != (len = is.read(car))) {
                    // 输出 字节数组转化成字符串
                    String info = new String(car, 0, len);
                    System.out.println(info);
                }
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("读取文件失败");
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件不存在");
        } finally {
            if (null != is) {
                try {
                    // 4. 释放资源
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                    System.out.println("关闭输入流失败");
                }}}}}
写出文件
public class Demo04_outputStream {
    public static void main(String[] args) {
        // 1. 建立联系
        File file = new File("D:/test/a.txt");
        // 2. 选择流
        OutputStream os = null;
        try {
            // 为true时，以追加形式写出文件；为false时，覆盖
            os = new FileOutputStream(file, true);
            String str = "this is a str \r\n";
            // 字符串转字节数组
            byte[] data = str.getBytes();
            os.write(data, 0, data.length);
            os.flush(); // 强制刷新数据
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("文件没有找到");
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("文件写出失败");
        } finally {
            if (null != os) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                    System.out.println("关闭输出流失败");
                }}}}}
文件拷贝
public  void copyFile(File src, File dest) throws IOException {
        if (!src.isFile()) {
            System.out.println("只能copy文件");
            throw new IOException("只能copy文件");
        }

        if (dest.isDirectory()) {
            System.out.println("不能建立与文件夹同名的文件");
            throw new IOException(dest.getAbsolutePath() + "不能建立与文件夹同名的文件");
        }

        InputStream is = null;
        OutputStream os = null;
        byte[] data = new byte[1024];
        int len = 0;
        is = new FileInputStream(src);
        os = new FileOutputStream(dest);
        while (-1 != (len = is.read(data))) {
            os.write(data, 0, len);
        }
        os.flush();
        // 先开的后关闭
        os.close();
        is.close();
    }
文件夹的拷贝
/**
     * 文件夹的copy 1、文件：复制 copyFile 2、文件夹：创建 mkdirs() 3、递归查找子孙级
     */
    public static void copyDir(String srcPath, String destPath) {
        File src = new File(srcPath);
        File dest = new File(destPath);
        if (src.isDirectory()) {
            dest = new File(destPath, src.getName());
        }
        copyDieDetails(src, dest);
    }

    private static void copyDieDetails(File src, File dest) {
        if (src.isFile()) {
            try {
                copyFile(src, dest);// 调用上面文件拷贝的方法
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else if (src.isDirectory()) {
            dest.mkdirs();
            for (File sub : src.listFiles()) {
                copyDieDetails(sub, new File(dest, sub.getName()));
            }
        }
    }

2. 字符流

只能处理纯文本，全部为可见字符。.txt、.html
对应的节点流:
- Reader –> FileReader
- Writer –> FileWriter

使用方式和字节流相似:
- 建立联系
- 选择流: FileReadre、FileWriter
- 读取 char[] flush = new char[1024]
- 关闭

3. 处理流

  • 缓冲流
    • 字节缓冲流
      • BufferedInputStream
      • BufferedOutputStream
    • 字符缓冲流
      • BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流。
      • BufferedReader(Reader in, int sz) 创建一个使用指定大小输入缓冲区的缓冲字符输入流。
        • readLine() 读取一个文本行。
      • BufferedWriter(Writer out)
      • BufferedWriter(Writer out, int sz)
        • newLine() 写入一个行分隔符
字符缓冲流 实现文件拷贝
public class Demo07_bufferedChar {
    public static void main(String[] args) {
        File src = new File("D:/test/a.txt");
        File dest = new File("D:/test/b.txt");

        BufferedReader reader = null;
        BufferedWriter writer = null;
        try {
            reader = new BufferedReader(new FileReader(src));
            writer = new BufferedWriter(new FileWriter(dest));
            // 旧的读取方法
            /*
             * char[] flush = new char[1024]; int len = 0;
             * while(-1!=(reader.read(flush))){ writer.write(flush, 0, len); }
             */

            // 新增方法的操作
            String line = null;
            while (null != (line = (reader.readLine()))) {
                writer.write(line);
                // writer.append("\r\n");
                writer.newLine();// 换行符号
            }
            writer.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
}}}

4. 转换流

字节流转为字符流，设计处理乱码问题。
1. 编码与解码概念
1. 编码: 字符 —编码字符集–>二进制
2. 解码: 二进制 —解码字符集–>字符
2. 乱码
1. 编码与解码的字符集不统一
2. 字节缺少，长度丢失

转换流
- 输入流 InputStreamReader (解码)
- 输出流 OutputStreamWriter (编码)

5. 其他流

字节流
  • 字节数组 节点流
    • 输入流: ByteArrayInputStream read(byte[] b, int off, int len) + close();(close可用可不用
    • 输出流: ByteArrayOutputStream write(byte[] b, int off, int len) + toByteArray() (不要使用多态)
处理流
  • 数据类型处理流(基本类型+String)
    • 输入流:DataInputStream readXxx
      • read(byte[] b)
      • read(byte[] b, int off, int len)
      • readBoolean()
      • readByte()
      • readByte()
      • readDouble()
      • readFloat()
      • readFully
    • 输出流:DataOutputstream WriteXxx
      • 。。。同上
  • 引用类型(对象) 保留数据+类型
    • 反序列化 ObjectOutputStream readObject()
    • 序列化 ObjectInputStream wirteObject()
    • 注意:
      • 先序列化后反序列化。反序列化顺序必须和序列化顺序一致
      • 不是所有的对象都可以序列化，必须实现java.io.Serilizable接口。
      • 不是所有的属性都序列化，不需要序列化的属性用transient

注意:
- java.io.EOFException:没有读取到相关的内容
- 读取顺序可能存在数据问题

ByteArrayInputstream 和 ByteArrayOutputStream

public static void main(String[] args) throws IOException {
        byte[] data = getBytesFromFile("D:/test/a.txt");
        toFileFromByteArray(data, "D:/test/c.txt");
    }

    /**
     * 文件 --> 程序--> 字节数组
     * 
     * @throws IOException
     */
    public static byte[] getBytesFromFile(String path) throws IOException {
        File file = new File(path);
        byte[] dest = null;
        InputStream is = new BufferedInputStream(new FileInputStream(file));
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        byte[] flush = new byte[1024];
        int len = 0;
        while (-1 != (len = is.read(flush))) {
            bos.write(flush, 0, len);
        }
        bos.flush();
        dest = bos.toByteArray();
        // 先开后关
        bos.close();
        is.close();
        return dest;
    }

    /**
     * 字节数组 --> 程序 --> 文件
     * 
     * @throws IOException
     */
    public static void toFileFromByteArray(byte[] src, String dest) throws IOException {
        File file = new File(dest);
        InputStream is = new BufferedInputStream(new ByteArrayInputStream(src));
        OutputStream os = new BufferedOutputStream(new FileOutputStream(file));
        byte[] flush = new byte[1024];
        int len = 0;
        while (-1 != (len = is.read(flush))) {
            os.write(flush, 0, len);
        }
        os.flush();
        os.close();
        is.close();
    }

对象通过流实现序列化和反序列化

Object:

/**
 * 空接口只是一个标识，说明可以序列化
 * 不需要序列化的属性加  transient
 */
public class Employee implements java.io.Serializable {
    private static final long serialVersionUID = 1L;
    private transient String name;
    private double salary;
    ...

ObjectInputStream 和 ObjectOutputStream

public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        seri("D:/test/seri.txt");
        read("D:/test/seri.txt");
    }

    // 序列化
    public static void seri(String destPath) throws FileNotFoundException, IOException {
        Employee emp = new Employee("张三", 5000);
        int[] arr = { 1, 2, 3, 54 };
        File dest = new File(destPath);
        ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(dest)));
        oos.writeObject(emp);
        oos.writeObject(arr);
        oos.flush();
        oos.close();
    }

    // 反序列化
    public static void read(String destPath) throws FileNotFoundException, IOException, ClassNotFoundException {
        File dest = new File(destPath);
        ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream(dest)));
        Object obj = ois.readObject();
        if (obj instanceof Employee) {
            Employee emp = (Employee) obj;
            System.out.println(emp.getName());
            System.out.println(emp.getSalary());
        }
        int[] arr = (int[]) ois.readObject();
        System.out.println(Arrays.toString(arr));
        ois.close();
    }

6. 关闭流方法

public class Demo11_FileUtil {
    /**
     * 关闭流 可变参数 ...: 代表参数随意指定。只能放在形参的最后一个位置，处理方式与数组一致
     * 使用：Demo11_FileUtil.close(is, os, oos)
     */
    public static void close(Closeable... io) {
        for (Closeable temp : io) {
            if (null != temp) {
                try {
                    temp.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }}}}

    /**
     * 使用泛型
     */
    public static <T extends Closeable> void closeAll(Closeable... io) {
        for (Closeable temp : io) {
            if (null != temp) {
                try {
                    temp.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }}}}}
七弦桐
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【JAVA核心知识】6.1: JAVA IO基础
积
11-24 1713
阻塞IO与非阻塞IO 无论阻塞IO还是非阻塞IO在数据准备就绪的情况下都是一样的，即将就绪数据拷贝至用户线程。不同的是阻塞IO与非阻塞IO在数据未准备就绪时的应对情况。 阻塞IO在数据未准备就绪时用户线程处于阻塞状态:当用户线程发起IO请求时，内核会查看数据是否准备就绪，如果未准备就绪就会等待数据准备就绪，在这个期间线程处于阻塞状态，用户线程交出CPU，在数据准备就绪后，内核将数据拷贝到用户线程，用户线程解除阻塞状态，对数据进行处理。 非阻塞IO在数据未准备就绪是会直接返回未就绪标识：当用户线程发起IO请求
Java基础知识——JavaIO
热门推荐
weixin_45680007的博客
02-01 1万+
Java io IO的基本分类 同步和异步的区别：同步是线程去查看是否完成，异步是完成的数据去提醒线程已经完成 参考资料 data = socket.read();socket本意为套接字，为ip+端口，我理解为一个数据载体 (BIO)阻塞io：未请求到数据即让出cpu (NIO not block io)非阻塞io：在 while 循环中不断地去询问内核数据是否就绪，这样会导致 CPU 占用率非...
java基础（IO流）
CodeSheep1的博客
08-20 275
java中常见的IO流1.流的概念2. 流的分类3 .流的结构4.字节流4.1 概述4.2 控制台三级目录 1.流的概念 在计算机中，流是个抽象的概念，是对输入输出设备的抽象。在Java程序中，对于数据的输入/输 出操作，都是以"流"的方式进行 数据以二进制的形式在程序与设备之间流动传输，就像水在管道里流动一样，所以就把这种数据传输的 方式称之为输入流、输出流。这里描述的设备，可以是文件、网络、内存等 流具有方向性，可以分为输入和输出。 以java程序本身作为参照点，如果数据是从程序“流向”文件，那么这
【Java】IO基础
weixin_46437504的博客
08-01 168
初步了解输入输出(IO)和流的基本概念 掌握常见的字节流和字符流的基本使用 理解和使用文件与目录管理 掌握文件的随机读写
Java IO基础
qq_41590178的博客
06-19 2849
1、IO对文件与文件夹的增删查基本操作。（改文件/夹的名/内容留着后面分析） 在Java中使用File类表示文件本身，可以直接使用此类完成文件的各种操作，如创建、删除等。 File类的常用方法和常量讲解： 构造方法方法或常量 类型 描述 public static final String pathSeparator 常量 与系统相关的路径分隔符字符，为方便表示字符串 publ...
java IO基础
06-17
以上就是Java IO基础的一些关键知识点，通过深入理解和熟练掌握这些内容，可以有效地处理程序与外部世界的交互，实现数据的高效读写和传输。提供的资料“java_javase201_day01.pdf”、“java_javase201_day02.pdf”...
Java进阶教程之IO基础
09-04
Java IO基础是Java编程中非常重要的一个领域，它涉及到如何在程序中进行数据的输入和输出操作。在Java中，IO系统比其他一些语言更为复杂，但也因此提供了更高的灵活性和控制性，允许开发者根据需求定制适合的输入...
java io基础
04-24
01_IO初步_java基础_www.gougu.net_文件流
java基础 IO流
09-05
此文档属于本人当初学习java基础之IO流，所整理的文档。里面有字节流与字符流的比较，也有总结使用不同方式读取文档的demo。希望对你的学习有帮助，谢谢！
Java IO 基础操作（文件读写和移动）
06-25
除了基础流，Java NIO（New IO）提供了一种更高效、非阻塞的IO模型。`java.nio`包下的`FileChannel`和`Files`类提供了更高级的文件操作，如映射内存到文件（MMap），以及异步文件操作。 例如，使用`Files`类移动...
JavaIO基础
studyNote-jiehuifang
10-25 210
JavaIO基础在java程序中，对于数据的输入/输出操作以“流”(stream)方式进行：J2SDK提供了各种各样的“流”类，用以获取不同种类的数据：程序中通过标准的方法输入或输出数据。java.io包中定义了多个流类型(类或抽象类)来实现输入/输出功能 按数据流的方向不同可以分为输入流和输出流,输入流和输出流的说法都是站在该程序的角度上看的。 按处理数据单位不同可以分为字节流和字符流。字节流是最
IO的基础认识
不做程序员的博客
11-15 2030
一、IO的定义 IO 即IN“”和“OUT”的组合，IO流用来处理设备之间的数据传输，Java程序中，对于数据的输入/输出操作 都是以“流”的方式进行的。java.io包下提供了各种“流”类的接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。 比如我们常用的System.out.print（）就是io的应用 二、IO汇总 按照流的方向（输出输入都是站在程序所在内存的角度划分的）： 输入...
Java基础：IO基础
QQhelphelp的博客
02-26 5918
示例代码： 字节流：处理字节的输入和输出：InputStream 和OutputStream顶端的两个抽象类 //读取控制台输入 import java.io.*;    //导入java,io包   class ReadBytes{     public static void main(String[] args)throws IOException{         byte[...
JAVA学习之IO基础
weixin_64771061的博客
08-01 416
是一种同步阻塞的通信模式，是一个比较传统的通信方式，模式简单、使用方便，但并发处理能力低，通信耗时，依赖网速。按流向分为输入流和输出流，可以从输入流读取数据但不能写，要从输入流读取数据，则必须有一。优点装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模。，它的主要用途在于给一个对象动态的添加一些额外的职责。即同步非阻塞，一个线程不断的轮询每个输入输出的状态改变，如果有状态发生了改变，则进。同步非阻塞的工作模式是指来到厨房，开始烧水，这次不在水壶旁等着，回到客厅看电视，...
Java IO流基础
Alaunitas的博客
03-04 196
       流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。IO流分为字符流和字节流。字节流和字符流的区别1.字节流读取的时候，读到一个字节就返回一个字节； 字符流使用了字节流读到一个或多个字节（中文对应的字节数是两个，在UTF-8码表中是3个字节）时。先去查指定的编...
Java基础-IO
weixin_52535099的博客
07-25 97
文件：文件就是储存数据的地方文件流：文件在程序中是以流的形式来操作的输入流：把文件的数据读入到内存中输出流：把内存中的程序写到文件中。
Java基础之IO
最新发布
THEFAKERS的博客
07-17 560
常见io流，以及socket网络编程
JAVA IO基础知识整理
DonnieYeh的博客
09-13 309
简述 说到IO，就充斥着各种 stream、reader、writer、buffer，搞的人昏头转向，那么这些名词所描述的对象，到底有什么区别，它们各自的作用又是什么，下面将会简单阐述下我的理解。 IO操作分为两种，分别是输入操作和输出操作。像 inputStream、reader这种，很明显就是输入操作，而outputStream、writer这种就是输出操作。 何为输入输出？ 刚刚...
Java基础（IO流)
冰月灵狐
07-26 479
一、字节输出流 1.OutputStream中定义的方法： 2.FileOutputStream类 OutputStream有很多子类，其中子类FileOutputStream可用来写入数据到文件。FileOutputStream类，即文件输出流，是用于将数据写入 File的输出流。 示例： import java.io.FileOutputStream...
java io 基础
07-28
Java IO（Input/Output）是Java编程语言中用于处理输入和输出的基础库。它提供了一种方便的方式来读取和写入数据，从而与外部世界进行交互。 Java IO库包含多个类和接口，用于在不同的场景下处理输入和输出。这些类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值