当前位置： 代码网 > it编程>编程语言>Java > Java中的Stream流与IO流完整实战指南(从零掌握)

Java中的Stream流与IO流完整实战指南(从零掌握)

2025年11月19日 • Java •我要评论
java新手必会：stream流与io流完整实战指南核心观点：掌握java的stream流和io流，就像学会了两把"数据处理神器"——stream流让集合操

java新手必会：stream流与io流完整实战指南

核心观点：掌握java的stream流和io流，就像学会了两把"数据处理神器"——stream流让集合操作变得优雅高效，io流让文件读写不再头疼。本文将用最接地气的方式，带你从零到一掌握这两大核心技能。

1. 什么是stream流和io流？一句话说清楚

stream流（集合流）

一句话理解：把集合中的数据想象成流水线上的产品，stream流就是这条流水线，可以对数据进行筛选、加工、组装。

生活例子：就像奶茶店制作奶茶的过程——原料（集合）→ 筛选茶叶（filter）→ 加糖（map）→ 打包（collect），一气呵成！

io流（输入输出流）

一句话理解：io流是java读写文件、网络传输数据的通道，就像水管输送水一样。

生活例子：你用u盘拷贝文件，io流就是那根"看不见的数据线"，负责把数据从硬盘"运"到u盘。

2. stream流：让集合操作像流水线一样顺畅

2.1 stream流的三大核心优势

  1. 代码简洁：一行代码搞定原本需要好几个for循环的操作
  2. 链式调用：filter、map、sorted一气呵成，逻辑清晰
  3. 延迟执行：只有调用终止操作（如collect）时才真正执行，性能更优

2.2 核心api实战

案例1：筛选出成绩大于60分的学生
import java.util.arraylist;
import java.util.list;
import java.util.stream.collectors;
public class streamdemo1 {
    public static void main(string[] args) {
        // 学生成绩列表
        list<integer> scores = new arraylist<>();
        scores.add(85);
        scores.add(45);
        scores.add(92);
        scores.add(58);
        scores.add(73);
        // 使用stream流筛选及格的成绩
        list<integer> passedscores = scores.stream()
                .filter(score -> score >= 60)  // 筛选：保留>=60的成绩
                .collect(collectors.tolist()); // 收集结果
        system.out.println("及格成绩：" + passedscores);
        // 输出：及格成绩：[85, 92, 73]
    }
}

代码讲解：

  • stream()：将集合转换为流
  • filter()：过滤数据，参数是lambda表达式
  • collect(collectors.tolist())：将流收集回list
案例2：将所有学生姓名转为大写
import java.util.arrays;
import java.util.list;
import java.util.stream.collectors;
public class streamdemo2 {
    public static void main(string[] args) {
        list<string> names = arrays.aslist("zhangsan", "lisi", "wangwu");
        // 将姓名转为大写
        list<string> uppernames = names.stream()
                .map(string::touppercase)  // 转换：每个元素调用touppercase()
                .collect(collectors.tolist());
        system.out.println("大写姓名：" + uppernames);
        // 输出：大写姓名：[zhangsan, lisi, wangwu]
    }
}

代码讲解：

  • map()：转换操作，将每个元素映射成新的值
  • string::touppercase：方法引用，等价于 name -> name.touppercase()
案例3：统计平均分
import java.util.arrays;
import java.util.list;
public class streamdemo3 {
    public static void main(string[] args) {
        list<integer> scores = arrays.aslist(85, 92, 78, 90, 88);
        // 计算平均分
        double average = scores.stream()
                .maptoint(integer::intvalue)  // 转换为intstream
                .average()                     // 求平均值
                .orelse(0.0);                 // 如果流为空，返回0.0
        system.out.println("平均分：" + average);
        // 输出：平均分：86.6
    }
}

代码讲解：

  • maptoint()：将stream转为intstream，可以使用数值操作
  • average()：返回optionaldouble，避免空指针
  • orelse()：提供默认值
案例4：去重并排序
import java.util.arrays;
import java.util.list;
import java.util.stream.collectors;
public class streamdemo4 {
    public static void main(string[] args) {
        list<integer> numbers = arrays.aslist(5, 2, 8, 2, 9, 1, 5, 8);
        // 去重、排序、收集
        list<integer> result = numbers.stream()
                .distinct()                    // 去重
                .sorted()                      // 排序（默认升序）
                .collect(collectors.tolist());
        system.out.println("去重排序后：" + result);
        // 输出：去重排序后：[1, 2, 5, 8, 9]
    }
}

3. 字节流 vs 字符流：该用哪个？看这里就够了

3.1 核心区别一览表

对比项字节流字符流
处理单位字节（byte，8位）字符（char，16位）
适用场景图片、视频、音频等二进制文件文本文件（.txt、.java等）
核心类inputstream / outputstreamreader / writer
是否有缓冲无（需手动包装）无（需手动包装）

3.2 字节流实战：复制图片

import java.io.fileinputstream;
import java.io.fileoutputstream;
import java.io.ioexception;
public class bytestreamdemo {
    public static void main(string[] args) {
        // 使用 try-with-resources 自动关闭资源
        try (
            fileinputstream fis = new fileinputstream("source.jpg");
            fileoutputstream fos = new fileoutputstream("target.jpg")
        ) {
            byte[] buffer = new byte[1024];  // 缓冲区
            int len;
            // 循环读取并写入
            while ((len = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
            }
            system.out.println("图片复制成功！");
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }
}

代码讲解：

  • fileinputstream：文件字节输入流，用于读取
  • fileoutputstream：文件字节输出流，用于写入
  • read(buffer)：一次读取最多buffer.length个字节，返回实际读取的字节数
  • -1表示读到文件末尾
  • try-with-resources：jdk7新特性，自动关闭资源

3.3 字符流实战：读写文本文件

import java.io.filereader;
import java.io.filewriter;
import java.io.ioexception;
public class charstreamdemo {
    public static void main(string[] args) {
        // 写入文本
        try (filewriter fw = new filewriter("hello.txt")) {
            fw.write("你好，java io流！\n");
            fw.write("这是第二行内容。");
            system.out.println("文件写入成功！");
        } catch (ioexception e) {
            e.printstacktrace();
        }
        // 读取文本
        try (filereader fr = new filereader("hello.txt")) {
            int ch;
            while ((ch = fr.read()) != -1) {
                system.out.print((char) ch);
            }
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }
}

代码讲解：

  • filewriter：字符输出流，适合写文本
  • filereader：字符输入流，适合读文本
  • read()：一次读一个字符，返回int（-1表示结束）

4. 缓冲流：性能提升10倍的秘密武器

4.1 为什么需要缓冲流？

问题：每次读写都直接访问硬盘，就像你去超市买菜，买一根葱就跑一趟，效率极低！

解决方案：缓冲流内置一个缓冲区（默认8kb），相当于带个购物车，攒够一车再去收银台，大大减少io次数。

4.2 缓冲字节流实战

import java.io.*;
public class bufferedbytestreamdemo {
    public static void main(string[] args) {
        long starttime = system.currenttimemillis();
        try (
            bufferedinputstream bis = new bufferedinputstream(
                new fileinputstream("large_file.zip")
            );
            bufferedoutputstream bos = new bufferedoutputstream(
                new fileoutputstream("large_file_copy.zip")
            )
        ) {
            byte[] buffer = new byte[8192];  // 8kb缓冲区
            int len;
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
            }
            long endtime = system.currenttimemillis();
            system.out.println("复制完成，耗时：" + (endtime - starttime) + "ms");
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }
}

性能对比：

  • 普通字节流：1000ms
  • 缓冲字节流：100ms（提升10倍）

4.3 缓冲字符流实战：按行读写

import java.io.*;
public class bufferedcharstreamdemo {
    public static void main(string[] args) {
        // 按行写入
        try (bufferedwriter bw = new bufferedwriter(
                new filewriter("students.txt")
        )) {
            bw.write("张三,85");
            bw.newline();  // 写入换行符（跨平台）
            bw.write("李四,92");
            bw.newline();
            bw.write("王五,78");
            system.out.println("学生信息写入成功！");
        } catch (ioexception e) {
            e.printstacktrace();
        }
        // 按行读取
        try (bufferedreader br = new bufferedreader(
                new filereader("students.txt")
        )) {
            string line;
            while ((line = br.readline()) != null) {  // 按行读取
                system.out.println(line);
            }
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }
}

代码讲解：

  • bufferedwriter.newline()：写入换行符，自动适配不同操作系统
  • bufferedreader.readline()：按行读取，读到末尾返回null

5. 资源释放：不注意这点会出大问题 ⚠️

5.1 为什么必须关闭流？

后果：

  1. 内存泄漏：流对象一直占用内存
  2. 文件锁定：文件被占用，无法删除或重命名
  3. 数据丢失：缓冲区数据可能未写入文件

5.2 正确的资源释放方式

❌ 错误示范（jdk7之前）
fileinputstream fis = null;
try {
    fis = new fileinputstream("data.txt");
    // 读取操作...
} catch (ioexception e) {
    e.printstacktrace();
} finally {
    if (fis != null) {
        try {
            fis.close();  // 繁琐！
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }
}
✅ 正确示范（jdk7+）
try (fileinputstream fis = new fileinputstream("data.txt")) {
    // 读取操作...
} catch (ioexception e) {
    e.printstacktrace();
}
// 无需手动关闭，try-with-resources自动处理

原理：实现了autocloseable接口的类，在try代码块结束时会自动调用close()方法。

6. 实战案例与常见避坑指南

案例1：读取配置文件并过滤有效配置

import java.io.*;
import java.util.list;
import java.util.stream.collectors;
public class configreaderdemo {
    public static void main(string[] args) {
        try (bufferedreader br = new bufferedreader(
                new filereader("config.properties")
        )) {
            // 使用stream流过滤空行和注释行
            list<string> validconfigs = br.lines()  // 将所有行转为stream
                    .map(string::trim)               // 去除首尾空格
                    .filter(line -> !line.isempty()) // 过滤空行
                    .filter(line -> !line.startswith("#")) // 过滤注释
                    .collect(collectors.tolist());
            system.out.println("有效配置：");
            validconfigs.foreach(system.out::println);
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }
}

亮点：将io流和stream流结合，代码简洁优雅！

案例2：统计文本文件中每个单词的出现次数

import java.io.*;
import java.util.*;
import java.util.stream.collectors;
public class wordcountdemo {
    public static void main(string[] args) {
        try (bufferedreader br = new bufferedreader(
                new filereader("article.txt")
        )) {
            map<string, long> wordcount = br.lines()
                    .flatmap(line -> arrays.stream(line.split("\\s+"))) // 按空格分词
                    .map(string::tolowercase)  // 转小写
                    .filter(word -> !word.isempty())  // 过滤空字符串
                    .collect(collectors.groupingby(
                            word -> word,           // 按单词分组
                            collectors.counting()   // 统计数量
                    ));
            // 打印词频前10的单词
            wordcount.entryset().stream()
                    .sorted(map.entry.<string, long>comparingbyvalue().reversed())
                    .limit(10)
                    .foreach(entry -> 
                        system.out.println(entry.getkey() + ": " + entry.getvalue())
                    );
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }
}

知识点整合：

  • bufferedreader读取文件
  • stream流的flatmap、filter、map
  • collectors的高级用法（分组、计数）

常见避坑指南 🚨

坑1：忘记关闭流导致文件锁定

现象：程序运行后无法删除文件，提示"文件正在使用"

解决：始终使用try-with-resources

坑2：字节流读取文本出现乱码

原因：字节流不处理字符编码

解决：

// ❌ 错误：用字节流读中文
fileinputstream fis = new fileinputstream("中文.txt");
// ✅ 正确：用字符流或指定编码
bufferedreader br = new bufferedreader(
    new inputstreamreader(new fileinputstream("中文.txt"), "utf-8")
);
坑3：缓冲流未flush导致数据丢失
bufferedwriter bw = new bufferedwriter(new filewriter("data.txt"));
bw.write("重要数据");
// 如果程序崩溃，数据可能丢失！
// 解决：手动flush或关闭流
bw.flush();  // 强制刷新缓冲区
坑4：stream流多次消费
stream<string> stream = list.stream();
stream.foreach(system.out::println);  // 第一次消费
stream.foreach(system.out::println);  // ❌ 报错：stream已被消费

解决：stream只能消费一次，需要重新创建。

7. 核心要点总结 📝

stream流（集合流）核心要点

✅ 记住这三步：创建流 → 中间操作（filter/map/sorted）→ 终止操作（collect）

✅ 常用api速查：

  • filter()：筛选
  • map()：转换
  • distinct()：去重
  • sorted()：排序
  • limit()：限制数量
  • collect()：收集结果

✅ 注意事项：stream只能消费一次，链式调用更高效

io流核心要点

✅ 选择流的黄金法则：

  • 文本文件 → 字符流（reader/writer）
  • 二进制文件 → 字节流（inputstream/outputstream）
  • 需要高性能 → 加buffered包装

✅ 四大核心类记忆：

场景输入输出
字节流fileinputstreamfileoutputstream
字符流filereaderfilewriter
缓冲字节流bufferedinputstreambufferedoutputstream
缓冲字符流bufferedreaderbufferedwriter

✅ 资源管理铁律：永远使用try-with-resources，避免内存泄漏

实践建议

  1. 读写文本优先用缓冲字符流，性能好且支持按行操作
  2. 复制文件优先用缓冲字节流，通用性强
  3. 处理集合数据优先用stream流，代码简洁
  4. 记得指定字符编码，避免中文乱码（推荐utf-8）
  5. 大文件分块读取，避免内存溢出

结语

掌握stream流和io流，你就解锁了java开发的两大核心技能：

  • stream流让你的集合操作代码像诗一样优雅
  • io流让你的文件处理能力如虎添翼

记住：多动手实践，把本文的代码全部运行一遍，你会发现原来流的世界如此简单！

到此这篇关于java中的stream流与io流完整实战指南(从零掌握)的文章就介绍到这了,更多相关java stream流与io流内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

赞 (0)

相关文章:

版权声明：本文内容由互联网用户贡献，该文观点仅代表作者本人。本站仅提供信息存储服务，不拥有所有权，不承担相关法律责任。 如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 2386932994@qq.com 举报，一经查实将立刻删除。

发表评论

验证码：
最近更新的文章
推荐阅读
大家感兴趣的文章
Copyright © 2017-2026  代码网 保留所有权利. 粤ICP备2024248653号
站长QQ:2386932994 | 联系邮箱：2386932994@qq.com