关注

Java IO流的核心概念与应用实践

九、Java IO流的核心概念与应用实践

在这里插入图片描述

9.1 学习目标与重点提示

学习目标：掌握Java IO流的核心概念，包括IO流的分类、常用类的使用方法，学会在实际开发中处理文件和网络数据。
重点：IO流的分类（字节流与字符流）、字节流的常用类（InputStream与OutputStream）、字符流的常用类（Reader与Writer）、文件操作（File类的使用）、缓冲流与转换流的应用、对象序列化与反序列化。

9.2 IO流概述

Java IO流是用于处理输入输出数据的机制。

9.2.1 IO流的定义

定义：IO流是用于处理输入输出数据的机制。
作用：

  • 读取文件内容。
  • 写入文件内容。
  • 处理网络数据。
  • 处理输入输出设备数据。

✅ 结论：IO流是用于处理输入输出数据的机制，作用是读取文件内容、写入文件内容、处理网络数据和处理输入输出设备数据。

9.2.2 IO流的分类

定义：IO流的分类是指Java中IO流类的分类方法。
分类：

  • 字节流：处理字节数据的流。
  • 字符流：处理字符数据的流。
  • 输入流：从数据源读取数据的流。
  • 输出流：向数据源写入数据的流。

✅ 结论：IO流的分类包括字节流与字符流、输入流与输出流。

9.3 字节流的常用类

字节流是处理字节数据的流。

9.3.1 InputStream的定义与使用

定义：InputStream是字节输入流的根接口。
常用子类：

  • FileInputStream：从文件读取字节数据的流。
  • BufferedInputStream：缓冲字节输入流。
  • DataInputStream：数据字节输入流。

示例：

import java.io.FileInputStream;
import java.io.IOException;

public class InputStreamExample {
    public static void main(String[] args) {
        FileInputStream fis = null;
        
        try {
            // 创建FileInputStream对象
            fis = new FileInputStream("test.txt");
            
            // 读取字节数据
            int data = 0;
            while ((data = fis.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            System.out.println("读取文件异常：" + e.getMessage());
        } finally {
            // 关闭流
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    System.out.println("关闭流异常：" + e.getMessage());
                }
            }
        }
    }
}

输出结果：

Hello, World!

✅ 结论：InputStream是字节输入流的根接口，常用子类包括FileInputStream、BufferedInputStream、DataInputStream。

9.3.2 OutputStream的定义与使用

定义：OutputStream是字节输出流的根接口。
常用子类：

  • FileOutputStream：向文件写入字节数据的流。
  • BufferedOutputStream：缓冲字节输出流。
  • DataOutputStream：数据字节输出流。

示例：

import java.io.FileOutputStream;
import java.io.IOException;

public class OutputStreamExample {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        
        try {
            // 创建FileOutputStream对象
            fos = new FileOutputStream("test.txt");
            
            // 写入字节数据
            String content = "Hello, World!";
            byte[] bytes = content.getBytes();
            fos.write(bytes);
            System.out.println("文件写入成功！");
        } catch (IOException e) {
            System.out.println("写入文件异常：" + e.getMessage());
        } finally {
            // 关闭流
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    System.out.println("关闭流异常：" + e.getMessage());
                }
            }
        }
    }
}

输出结果：

文件写入成功！

✅ 结论：OutputStream是字节输出流的根接口，常用子类包括FileOutputStream、BufferedOutputStream、DataOutputStream。

9.4 字符流的常用类

字符流是处理字符数据的流。

9.4.1 Reader的定义与使用

定义：Reader是字符输入流的根接口。
常用子类：

  • FileReader：从文件读取字符数据的流。
  • BufferedReader：缓冲字符输入流。
  • InputStreamReader：字节流到字符流的转换流。

示例：

import java.io.FileReader;
import java.io.IOException;

public class ReaderExample {
    public static void main(String[] args) {
        FileReader fr = null;
        
        try {
            // 创建FileReader对象
            fr = new FileReader("test.txt");
            
            // 读取字符数据
            int data = 0;
            while ((data = fr.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            System.out.println("读取文件异常：" + e.getMessage());
        } finally {
            // 关闭流
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    System.out.println("关闭流异常：" + e.getMessage());
                }
            }
        }
    }
}

输出结果：

Hello, World!

✅ 结论：Reader是字符输入流的根接口，常用子类包括FileReader、BufferedReader、InputStreamReader。

9.4.2 Writer的定义与使用

定义：Writer是字符输出流的根接口。
常用子类：

  • FileWriter：向文件写入字符数据的流。
  • BufferedWriter：缓冲字符输出流。
  • OutputStreamWriter：字节流到字符流的转换流。

示例：

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

public class WriterExample {
    public static void main(String[] args) {
        FileWriter fw = null;
        
        try {
            // 创建FileWriter对象
            fw = new FileWriter("test.txt");
            
            // 写入字符数据
            String content = "Hello, World!";
            fw.write(content);
            System.out.println("文件写入成功！");
        } catch (IOException e) {
            System.out.println("写入文件异常：" + e.getMessage());
        } finally {
            // 关闭流
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    System.out.println("关闭流异常：" + e.getMessage());
                }
            }
        }
    }
}

输出结果：

文件写入成功！

✅ 结论：Writer是字符输出流的根接口，常用子类包括FileWriter、BufferedWriter、OutputStreamWriter。

9.5 文件操作

File类是Java中用于处理文件和目录的类。

9.5.1 File类的定义与使用

定义：File类是Java中用于处理文件和目录的类。
常用方法：

  • exists()：判断文件或目录是否存在。
  • isFile()：判断是否是文件。
  • isDirectory()：判断是否是目录。
  • createNewFile()：创建新文件。
  • mkdir()：创建新目录。
  • list()：列出目录中的文件和目录。
  • delete()：删除文件或目录。

示例：

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

public class FileExample {
    public static void main(String[] args) {
        // 创建File对象
        File file = new File("test.txt");
        
        // 判断文件是否存在
        if (file.exists()) {
            System.out.println("文件存在");
        } else {
            System.out.println("文件不存在");
            
            // 创建新文件
            try {
                file.createNewFile();
                System.out.println("文件创建成功");
            } catch (IOException e) {
                System.out.println("文件创建失败：" + e.getMessage());
            }
        }
        
        // 判断是否是文件
        if (file.isFile()) {
            System.out.println("是文件");
        } else {
            System.out.println("不是文件");
        }
        
        // 判断是否是目录
        if (file.isDirectory()) {
            System.out.println("是目录");
        } else {
            System.out.println("不是目录");
        }
        
        // 获取文件名
        System.out.println("文件名：" + file.getName());
        
        // 获取文件路径
        System.out.println("文件路径：" + file.getAbsolutePath());
        
        // 获取文件大小
        System.out.println("文件大小：" + file.length() + "字节");
        
        // 删除文件
        // file.delete();
        // System.out.println("文件删除成功");
    }
}

输出结果：

文件存在
是文件
不是目录
文件名：test.txt
文件路径：C:\Users\user\Desktop\test.txt
文件大小：13字节

✅ 结论：File类是Java中用于处理文件和目录的类，常用方法包括exists()、isFile()、isDirectory()、createNewFile()、mkdir()、list()、delete()。

9.6 缓冲流与转换流的应用

缓冲流与转换流是Java IO流中常用的流类型。

9.6.1 缓冲流的定义与使用

定义：缓冲流是用于提高IO效率的流类型。
常用子类：

  • BufferedInputStream：缓冲字节输入流。
  • BufferedOutputStream：缓冲字节输出流。
  • BufferedReader：缓冲字符输入流。
  • BufferedWriter：缓冲字符输出流。

示例：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderExample {
    public static void main(String[] args) {
        BufferedReader br = null;
        
        try {
            // 创建BufferedReader对象
            br = new BufferedReader(new FileReader("test.txt"));
            
            // 读取字符数据
            String line = null;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.out.println("读取文件异常：" + e.getMessage());
        } finally {
            // 关闭流
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    System.out.println("关闭流异常：" + e.getMessage());
                }
            }
        }
    }
}

输出结果：

Hello, World!

✅ 结论：缓冲流是用于提高IO效率的流类型，常用子类包括BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter。

9.6.2 转换流的定义与使用

定义：转换流是用于在字节流和字符流之间转换的流类型。
常用子类：

  • InputStreamReader：字节流到字符流的转换流。
  • OutputStreamWriter：字节流到字符流的转换流。

示例：

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class InputStreamReaderExample {
    public static void main(String[] args) {
        InputStreamReader isr = null;
        
        try {
            // 创建InputStreamReader对象
            isr = new InputStreamReader(new FileInputStream("test.txt"), "UTF-8");
            
            // 读取字符数据
            int data = 0;
            while ((data = isr.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            System.out.println("读取文件异常：" + e.getMessage());
        } finally {
            // 关闭流
            if (isr != null) {
                try {
                    isr.close();
                } catch (IOException e) {
                    System.out.println("关闭流异常：" + e.getMessage());
                }
            }
        }
    }
}

输出结果：

Hello, World!

✅ 结论：转换流是用于在字节流和字符流之间转换的流类型，常用子类包括InputStreamReader、OutputStreamWriter。

9.7 对象序列化与反序列化

对象序列化与反序列化是Java IO流中用于将对象转换为字节流和将字节流转换为对象的机制。

9.7.1 对象序列化的定义与使用

定义：对象序列化是指将对象转换为字节流的过程。
语法：

public class 类名 implements Serializable {
    // 类体
}

示例：

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

// 可序列化的类
public class User implements Serializable {
    private String name;
    private int age;
    private String email;
    
    public User(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    public String getEmail() {
        return email;
    }
}

// 测试类
public class ObjectOutputStreamExample {
    public static void main(String[] args) {
        ObjectOutputStream oos = null;
        
        try {
            // 创建ObjectOutputStream对象
            oos = new ObjectOutputStream(new FileOutputStream("user.dat"));
            
            // 创建User对象
            User user = new User("张三", 25, "[email protected]");
            
            // 序列化对象
            oos.writeObject(user);
            System.out.println("对象序列化成功！");
        } catch (IOException e) {
            System.out.println("对象序列化异常：" + e.getMessage());
        } finally {
            // 关闭流
            if (oos != null) {
                try {
                    oos.close();
                } catch (IOException e) {
                    System.out.println("关闭流异常：" + e.getMessage());
                }
            }
        }
    }
}

输出结果：

对象序列化成功！

✅ 结论：对象序列化是指将对象转换为字节流的过程，需要实现Serializable接口。

9.7.2 对象反序列化的定义与使用

定义：对象反序列化是指将字节流转换为对象的过程。
语法：

public class 类名 implements Serializable {
    // 类体
}

示例：

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

// 可序列化的类
public class User implements Serializable {
    private String name;
    private int age;
    private String email;
    
    public User(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
    
    public String getEmail() {
        return email;
    }
}

// 测试类
public class ObjectInputStreamExample {
    public static void main(String[] args) {
        ObjectInputStream ois = null;
        
        try {
            // 创建ObjectInputStream对象
            ois = new ObjectInputStream(new FileInputStream("user.dat"));
            
            // 反序列化对象
            User user = (User) ois.readObject();
            
            // 输出用户信息
            System.out.println("用户信息：");
            System.out.println("姓名：" + user.getName());
            System.out.println("年龄：" + user.getAge());
            System.out.println("邮箱：" + user.getEmail());
        } catch (IOException e) {
            System.out.println("对象反序列化异常：" + e.getMessage());
        } catch (ClassNotFoundException e) {
            System.out.println("类未找到异常：" + e.getMessage());
        } finally {
            // 关闭流
            if (ois != null) {
                try {
                    ois.close();
                } catch (IOException e) {
                    System.out.println("关闭流异常：" + e.getMessage());
                }
            }
        }
    }
}

输出结果：

用户信息：
姓名：张三
年龄：25
邮箱：[email protected]

✅ 结论：对象反序列化是指将字节流转换为对象的过程，需要实现Serializable接口。

9.8 实际开发中的应用场景

在实际开发中，IO流的应用场景非常广泛，如：

  • 文件操作。
  • 网络操作。
  • 数据库操作。
  • 输入输出操作。

示例：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

// 产品类
public class Product {
    private String productId;
    private String productName;
    private double price;
    
    public Product(String productId, String productName, double price) {
        this.productId = productId;
        this.productName = productName;
        this.price = price;
    }
    
    public String getProductId() {
        return productId;
    }
    
    public String getProductName() {
        return productName;
    }
    
    public double getPrice() {
        return price;
    }
}

// 测试类
public class IOStreamApplication {
    public static void main(String[] args) {
        BufferedReader br = null;
        List<Product> products = new ArrayList<>();
        
        try {
            // 创建BufferedReader对象
            br = new BufferedReader(new FileReader("products.txt"));
            
            // 读取文件内容
            String line = null;
            while ((line = br.readLine()) != null) {
                // 分割字符串
                String[] parts = line.split(",");
                String productId = parts[0];
                String productName = parts[1];
                double price = Double.parseDouble(parts[2]);
                
                // 创建Product对象
                Product product = new Product(productId, productName, price);
                products.add(product);
            }
            
            // 输出产品信息
            System.out.println("产品信息：");
            for (Product product : products) {
                System.out.println("产品ID：" + product.getProductId());
                System.out.println("产品名称：" + product.getProductName());
                System.out.println("价格：" + product.getPrice());
                System.out.println("------------------------");
            }
        } catch (IOException e) {
            System.out.println("读取文件异常：" + e.getMessage());
        } finally {
            // 关闭流
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    System.out.println("关闭流异常：" + e.getMessage());
                }
            }
        }
    }
}

输出结果：

产品信息：
产品ID：P001
产品名称：手机
价格：1000.0
------------------------
产品ID：P002
产品名称：电脑
价格：2000.0
------------------------
产品ID：P003
产品名称：平板
价格：1500.0
------------------------

✅ 结论：在实际开发中，IO流的应用场景非常广泛，需要根据实际问题选择合适的IO流类型。

总结

本章我们学习了Java IO流的核心概念与应用实践，包括IO流的分类、常用类的使用方法，学会了在实际开发中处理文件和网络数据。其中，IO流的分类（字节流与字符流）、字节流的常用类（InputStream与OutputStream）、字符流的常用类（Reader与Writer）、文件操作（File类的使用）、缓冲流与转换流的应用、对象序列化与反序列化是本章的重点内容。从下一章开始，我们将学习Java的多线程、集合框架等内容。

转载自CSDN-专业IT技术社区

原文链接：https://blog.csdn.net/COLLINSXU/article/details/157438430

评论

赞0

评论列表

微信小程序
QQ小程序

关于作者

点赞数：0
关注数：0
粉丝：0
文章：0
关注标签：0
加入于：--