AI 助理
文档备案控制台
开发者社区 开发与运维 文章 正文

JAVA之旅（三十）——打印流PrintWriter，合并流，切割文件并且合并，对象的序列化Serializable，管道流，RandomAccessFile，IO其他类，字符编码

2016-07-17 1014
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： JAVA之旅（三十）——打印流PrintWriter，合并流，切割文件并且合并，对象的序列化Serializable，管道流，RandomAccessFile，IO其他类，字符编码 三十篇了，又是一个阳光明媚的周末，一个又一个的周末，周而复始，不断学习，前方的路你可曾看见？随我一起走进技术的世界，流连忘返吧！一.

JAVA之旅（三十）——打印流PrintWriter，合并流，切割文件并且合并，对象的序列化Serializable，管道流，RandomAccessFile，IO其他类，字符编码

三十篇了，又是一个阳光明媚的周末，一个又一个的周末，周而复始，不断学习，前方的路你可曾看见？随我一起走进技术的世界，流连忘返吧！

一.打印流PrintWriter

打印流有PrintWriter和PrintStream,他的特点可以直接操作输入流还有文件

  • 该流提供了打印方法，可以将各种数据类型原样打印
    • file对象 File
    • 字符串路径 String
    • 字节打印流
    • 字符打印流

我们演示一遍大家就对此有所了解了

package com.lgl.hellojava;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class HelloJJAVA {
    public static void main(String[] args) {

        try {
            BufferedReader bufr = new BufferedReader(new InputStreamReader(
                    System.in));

            PrintWriter oWriter = new PrintWriter(System.out, true);
            String line = null;
            while ((line = bufr.readLine()) != null) {
                if (line.equals("over")) {
                    break;
                }
                oWriter.write(line);
            }
            oWriter.close();
            bufr.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

要想存到文件里，也是可以直接把文件给放进去的

二.合并流

我们来看看什么是合并流，在API文档上说，他可以串联流

package com.lgl.hellojava;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

public class HelloJJAVA {
    public static void main(String[] args) {
        try {
            Vector<FileInputStream> v = new Vector<FileInputStream>();
            v.add(new FileInputStream("1.txt"));
            v.add(new FileInputStream("2.txt"));
            Enumeration<FileInputStream> elements = v.elements();
            SequenceInputStream sis = new SequenceInputStream(elements);

            FileOutputStream fos = new FileOutputStream("3.txt");

            byte[] buf = new byte[1024];
            int len = 0;
            while ((len = sis.read(buf)) != -1) {
                fos.write(buf, 0, len);
            }   

            fos.close();
            sis.close();

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

把1.txt和2.txt乃至add更多的内容合并到3.txt文件中，这就是流的合并

三.切割文件

合并文件可以，那肯定可以切割了，我们来看下具体是怎么去制作的

// 切割文件
    public static void splitFile() {
        try {
            FileInputStream fis = new FileInputStream("1.jpg");
            FileOutputStream fos = null;
            byte[] buf = new byte[1024 * 1024];

            int len = 0;
            int count = 1;
            while ((len = fis.read(buf)) != -1) {
                fos = new FileOutputStream((count++) + ".patch");
                fos.write(buf, 0, len);
                fos.close();
            }

            fis.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

当运行结束之后，我们可以看到

这里写图片描述

已经成功切割了

切割完我们可以合并了

// 合并文件
    public static void merge() {
        ArrayList<FileInputStream> al = new ArrayList<>();
        for (int i = 1; i <= 2; i++) {
            try {
                al.add(new FileInputStream(i + ".patch"));
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        Iterator<FileInputStream> iterator = al.iterator();
        Enumeration<FileInputStream> en = new Enumeration<FileInputStream>() {

            @Override
            public boolean hasMoreElements() {
                // TODO Auto-generated method stub
                return iterator.hasNext();
            }

            @Override
            public FileInputStream nextElement() {
                // TODO Auto-generated method stub
                return iterator.next();
            }

        };
        try {
            SequenceInputStream seq = new SequenceInputStream(en);
            FileOutputStream fos = new FileOutputStream("2.jpg");

            byte[] buf = new byte[1024];

            int len = 0;

            while ((len = seq.read(buf)) != -1) {
                fos.write(buf, 0, len);
            }

            fos.close();
            seq.close();

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

这样我们就把图片拷贝出来了，可以看到

这里写图片描述

这段代码是非常帮的，我们一定会用到的，希望能用的上

四.对象的序列化Serializable

其实就是可以直接操作对象的流，他会实现一个Serializable（）接口，我们用代码来看下他是怎么用的，我们直接写读取对象的类了

package com.lgl.hellojava;

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

public class HelloJJAVA {
    public static void main(String[] args) {
        // writeObj();
        readObj();
    }

    private static void readObj() {
        try {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
                    "obj.txt"));
            Person p = (Person) ois.readObject();
            System.out.println(p);
            ois.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    private static void writeObj() {
        try {
            ObjectOutputStream oos = new ObjectOutputStream(
                    new FileOutputStream("obj.txt"));
            oos.writeObject(new Person("zhangsan", 20));
            oos.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

class Person implements Serializable {

    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

}

OK,自己去验证一下

五.管道流

输入输出可以直接进行连接，通常结合线程使用

这里写图片描述

package com.lgl.hellojava;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class HelloJJAVA {
    public static void main(String[] args) {

        PipedInputStream pi = new PipedInputStream();
        PipedOutputStream po = new PipedOutputStream();

        try {
            pi.connect(po);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        Read read = new Read(pi);
        Write write = new Write(po);

        new Thread(read).start();
        new Thread(write).start();
    }
}

class Read implements Runnable {

    private PipedInputStream in;

    public Read(PipedInputStream in) {
        this.in = in;
    }

    @Override
    public void run() {
        try {
            byte[] buf = new byte[1024];
            int len = in.read(buf);
            String s = new String(buf, 0, len);
            System.out.println(s);
            in.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}

class Write implements Runnable {

    private PipedOutputStream out;

    public Write(PipedOutputStream out) {
        this.out = out;
    }

    @Override
    public void run() {
        try {
            out.write("yes".getBytes());
            out.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

现在就可以联通了

六.RandomAccessFile

这是一个很特别的家伙，他继承的是Object

这里写图片描述

  • 该类不是IO体系中的子类
  • 但是他是IO包中的成员，他同时具备读写功能
  • 内部封装了一个数组，而且通过指针对数组中的元素进行操作
  • 可以通过getFilePointer或者指针位置同时可以通过seek改变指针的位置

其实完成读写的原理就是内部封装了字节输入，输出流，通过构造函数可以看出该类具备操作文件的能力，而且操作文件还有模式

package com.lgl.hellojava;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class HelloJJAVA {
    public static void main(String[] args) {
            writeFile();
    }

    public static void writeFile() {
        try {
            RandomAccessFile raf = new RandomAccessFile("1.txt", "rw");
            raf.write("zhangssan".getBytes());
            raf.writeInt(99);

            raf.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

这只是一个写的过程，我们的特性还没有体现出来，我们来看下他是怎么读的

private static void ReadFile() {
        try {
            RandomAccessFile raf = new RandomAccessFile("1.txt", "r");

            // 调整对象指针
            raf.seek(8 * 0);

            byte[] buf = new byte[1024];

            raf.read(buf);

            String s = new String(buf);

            System.out.println(s);

            raf.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

如果操作的文件不存在，就会自动创建，如果存在，直接覆盖

七.IO其他类

IO其他包里，还有一些其他的使用

  • 操作基本数据类型
  • 字节数组
  • 字符数组

1.基本数据类型

我们先来看下基本数据类型的，我直接读写都写出来


    public static void readData() {
        try {
            DataInputStream dis = new DataInputStream(new FileInputStream(
                    "data.txt"));
            int num = dis.readInt();
            boolean d = dis.readBoolean();

            System.out.println(num + "" + d + "");

            dis.close();

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    // 基本数据类型
    public static void writeDatea() {
        try {
            DataOutputStream dos = new DataOutputStream(new FileOutputStream(
                    "data.txt"));

            dos.writeInt(55);
            dos.writeBoolean(true);

            dos.close();

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

读取基本数据类型

二.字节数组

这个偶尔用下，但是我们还是要去学习一下的

  • ByteArrayInputStream： 在构造的时候，需要接收数据源，而且数据源是一个字节数组

  • ByteArrayOutputStream：在构造的时候，不用定义数据的目的，因为该对象中已经内部封装了可变程度的字节数组

因为这两个流的对象都操作的数组，并且没有使用系统资源，所以，不用进行close关闭！

package com.lgl.hellojava;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

public class HelloJJAVA {
    public static void main(String[] args) {

        // 数据源
        ByteArrayInputStream bis = new ByteArrayInputStream("123".getBytes());
        // 数据目的
        ByteArrayOutputStream bos = new ByteArrayOutputStream();

        int ch = 0;

        while ((ch = bis.read()) != -1) {
            bos.write(ch);
        }

        System.out.println(bos.size());
        System.out.println(bos.toString());

    }
}

是不是比较简单，字符流我就不说了，和字节流是类似的，但是他会衍生出一个新的内容就是字符编码

八.字符编码

这些乱七八糟的编码说真的，东西还是挺多的，但是我并不想讲那么多，因为本身我也不是很清楚，其次这玩意大致的知道一点就可以了（个人觉得），什么ASCLL,GBK，UTF-8之类的

        String s = "hello java";
        byte [] b1 = s.getBytes();
        System.out.println(Arrays.toString(b1));

他得到的是什么？

这里写图片描述

现在我换一个编码

byte [] b1 = s.getBytes("GBK");

我设置成GBK，他的值是一样的，说明默认的是GBK

九.练习

写完这个练习，我们的I/O流就GG了，感慨颇多，写I/O写了很多篇，但是仍然晕乎乎的，应该继续加深印象的，我们来看下需求

  • 有五个学生，每个学生有三门课程，从键盘输入以下数据（包括姓名，三门课成绩），输入的格式，如zhangsan,30,60,96计算出总成绩，并把学生的信息和计算出的总分数高低顺序存入文件student.txt中去；

好了，开始撸代码了

package com.lgl.hellojava;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Set;
import java.util.TreeSet;

public class HelloJJAVA {
    public static void main(String[] args) {

        /**
         * 逻辑： 
         * 1.通过获取键盘录入一行数据，然后取出数据封装成学生对象 
         * 2.需要从高到低排列，需要排序，使用集合TreeSet就可以了
         * 3.写入文件
         */

        try {
            Set<Student> stus = StudentInfoTool.getStudents();
            StudentInfoTool.writeFile(stus);

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

// 比较数据，Comparable接口
class Student implements Comparable<Student> {

    // 姓名
    private String name;
    // 三科分数
    private int n1, n2, n3;
    // 总分
    private int sum;

    // 构造函数
    public Student(String name, int n1, int n2, int n3) {
        this.name = name;
        this.n1 = n1;
        this.n2 = n2;
        this.n3 = n3;
        sum = n1 + n2 + n3;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getSum() {
        return sum;
    }

    public void setSum(int sum) {
        this.sum = sum;
    }

    @Override
    public int compareTo(Student o) {
        int num = new Integer(this.sum).compareTo(new Integer(o.sum));
        if (num == 0) {
            return this.name.compareTo(o.name);
        }
        return num;
    }

    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return name.hashCode() + sum * 78;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Student)) {
            throw new ClassCastException("Type Error");
        }
        Student s = (Student) obj;
        return this.name.equals(s.name) && this.sum == s.sum;
    }

}

// 工具类
class StudentInfoTool {
    public static Set<Student> getStudents() throws IOException {
        BufferedReader bufr = new BufferedReader(new InputStreamReader(
                System.in));
        String line = null;
        // 集合
        Set<Student> stus = new TreeSet<>();

        while ((line = bufr.readLine()) != null) {
            if (line.equals("over")) {
                break;
            }
            String[] info = line.split(",");
            Student student = new Student(info[0], Integer.parseInt(info[1]),
                    Integer.parseInt(info[2]), Integer.parseInt(info[3]));
            stus.add(student);
        }
        bufr.close();
        return stus;
    }

    // 写入文件
    public static void writeFile(Set<Student> stus) {
        try {
            BufferedWriter bufw = new BufferedWriter(new FileWriter(
                    "student.txt"));
            for (Student stu : stus) {
                bufw.write(stu.getName());
                bufw.write(stu.getSum() + "");
                bufw.newLine();
                bufw.flush();
            }

            bufw.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

输出的结果，可以看到

这里写图片描述

总数，从小到大，如果你想从高到低的话，自己去实现下排序，看看你们学的怎么样了

好的，我们本篇到这里就结束了，这篇也是憋了挺久的才别出来的，终于把IO写完了

有兴趣的可以加群：555974449

文章标签：
Java
API
关键词：
Java对象
Java类
Java序列化
Java文件
文件io
刘桂林
目录
相关文章
啦啦啦191
|
12月前
|
监控 Java API
现代 Java IO 高性能实践从原理到落地的高效实现路径与实战指南
本文深入解析现代Java高性能IO实践，涵盖异步非阻塞IO、操作系统优化、大文件处理、响应式网络编程与数据库访问，结合Netty、Reactor等技术落地高并发应用，助力构建高效可扩展的IO系统。
啦啦啦191
350 0
凉凉心.
|
9月前
|
Java Unix Go
【Java】（8）Stream流、文件File相关操作，IO的含义与运用
Java 为 I/O 提供了强大的而灵活的支持，使其更广泛地应用到文件传输和网络编程中。！但本节讲述最基本的和流与 I/O 相关的功能。我们将通过一个个例子来学习这些功能。
凉凉心.
341 1
艾伦~耶格尔
|
11月前
|
Java 测试技术 API
Java IO流（二）：文件操作与NIO入门
本文详解Java NIO与传统IO的区别与优势，涵盖Path、Files类、Channel、Buffer、Selector等核心概念，深入讲解文件操作、目录遍历、NIO实战及性能优化技巧，适合处理大文件与高并发场景，助力高效IO编程与面试准备。
艾伦~耶格尔
436 1
啦啦啦191
|
12月前
|
存储 Java Linux
操作系统层面视角下 Java IO 的演进路径及核心技术变革解析
本文从操作系统层面深入解析Java IO的演进历程，涵盖BIO、NIO、多路复用器及Netty等核心技术。分析各阶段IO模型的原理、优缺点及系统调用机制，探讨Java如何通过底层优化提升并发性能与数据处理效率，全面呈现IO技术的变革路径与发展趋势。
啦啦啦191
249 3
艾伦~耶格尔
|
11月前
|
SQL Java 数据库连接
Java IO流（一）：字节流与字符流基础
本文全面解析Java IO流，涵盖字节流、字符流及其使用场景，帮助开发者理解IO流分类与用途，掌握文件读写、编码转换、异常处理等核心技术，通过实战案例提升IO编程能力。
艾伦~耶格尔
440 0
Bluening
|
存储 网络协议 安全
Java网络编程，多线程，IO流综合小项目一一ChatBoxes
**项目介绍**：本项目实现了一个基于TCP协议的C/S架构控制台聊天室，支持局域网内多客户端同时聊天。用户需注册并登录，用户名唯一，密码格式为字母开头加纯数字。登录后可实时聊天，服务端负责验证用户信息并转发消息。 **项目亮点**： - **C/S架构**：客户端与服务端通过TCP连接通信。 - **多线程**：采用多线程处理多个客户端的并发请求，确保实时交互。 - **IO流**：使用BufferedReader和BufferedWriter进行数据传输，确保高效稳定的通信。 - **线程安全**：通过同步代码块和锁机制保证共享数据的安全性。
Bluening
681 23
Java开发者
|
Java
java 中 IO 流
Java中的IO流是用于处理输入输出操作的机制，主要包括字节流和字符流两大类。字节流以8位字节为单位处理数据，如FileInputStream和FileOutputStream；字符流以16位Unicode字符为单位，如FileReader和FileWriter。这些流提供了读写文件、网络传输等基本功能。
Java开发者
374 10
运营研究坊
|
缓存 网络协议 Java
JAVA网络IO之NIO/BIO
本文介绍了Java网络编程的基础与历史演进，重点阐述了IO和Socket的概念。Java的IO分为设备和接口两部分，通过流、字节、字符等方式实现与外部的交互。
运营研究坊
569 0
游客moiomvrp3vyac2
|
存储 安全 Java
Java编程中的对象序列化与反序列化
【10月更文挑战第22天】在Java的世界里，对象序列化和反序列化是数据持久化和网络传输的关键技术。本文将带你了解如何在Java中实现对象的序列化与反序列化，并探讨其背后的原理。通过实际代码示例，我们将一步步展示如何将复杂数据结构转换为字节流，以及如何将这些字节流还原为Java对象。文章还将讨论在使用序列化时应注意的安全性问题，以确保你的应用程序既高效又安全。
游客moiomvrp3vyac2
242 4
软件求生
|
存储 缓存 NoSQL
一篇搞懂！Java对象序列化与反序列化的底层逻辑
本文介绍了Java中的序列化与反序列化，包括基本概念、应用场景、实现方式及注意事项。序列化是将对象转换为字节流，便于存储和传输；反序列化则是将字节流还原为对象。文中详细讲解了实现序列化的步骤，以及常见的反序列化失败原因和最佳实践。通过实例和代码示例，帮助读者更好地理解和应用这一重要技术。
软件求生
984 0

热门文章

最新文章

  • 1
    java系列知识之~SimpleDateFormat日期格式化
  • 2
    Java 8 新特性：Java 类库的新特性之 Optional类
  • 3
    Java NIO（六）Channel 之间的转换(传输)
  • 4
    Java网络编程从入门到精通（31）：非阻塞I/O简介
  • 5
    Java线程：线程的交互
  • 6
    Java开发Maven环境配置和介绍
  • 7
    java web项目里ehcache.xml的参数说明
  • 8
    【Java高手必备】揭秘！如何优雅地对List进行排序？掌握这几种技巧，让你的代码瞬间高大上！
  • 9
    java工厂模式
  • 10
    java-基础-变长参数
  • 1
    【Java】（8）Stream流、文件File相关操作，IO的含义与运用
    341
  • 2
    IO模型
    350
  • 3
    02理解网络IO：实现服务与客户端通信
    635
  • 4
    Go语言中的文件与IO：JSON、CSV、XML处理
    279
  • 5
    Go语言中的文件与IO：bufio 和 scanner
    287
  • 6
    Go语言中的文件与IO：文件读写
    270
  • 7
    Linux的基础IO内容补充-FILE
    402
  • 8
    掌握并发模型：深度揭露网络IO复用并发模型的原理。
    366
  • 9
    【YashanDB知识库】个别数据库用户无法登录数据库，报错 io fail:IO.EOF
    286
  • 10
    【YashanDB知识库】YashanDB JDBC驱动查询时抛出io fail：Read timed out异常
    358

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0
    • 下一篇
    一条命令迁移，帮你实现 OpenClaw 与 Hermes Agent 记忆互通！