黑马程序员--IO流之字节流

最新推荐文章于 2024-07-24 17:27:32 发布
最新推荐文章于 2024-07-24 17:27:32 发布
阅读量316 收藏
点赞数
文章标签： java 黑马程序员 IO 字节流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sa_leon/article/details/47362269
版权

——- android培训、java培训、期待与您交流！ ———-

1.1 字节流体系

JDKAPI介绍如下：

这里写图片描述

注：看红色箭头指向说明该类为抽象类，所以该类不能被实例化，实例化时要参看紫色框里面的子类。下面会详细介绍各个子类的使用

1.2 字节流的使用

1.2.1 FileInputStream

package com.test.blog2;

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

/*
 * 字节流的演示Demo
 * 
 * */
public class TestInputStream {
    public static void main(String[] args) throws FileNotFoundException {
        // 定义读取文件的路径
        String filePath = "d:" + File.separator + "testread.txt";
        // 定义输出文件的路径
        String filePathw = "d:" + File.separator + "testwrite.txt";
        readMethod1(filePath);
        System.out.println();
        readMethod2(filePath);
        writeMethod(filePathw);

    }

    /*
     * 将硬盘上的txt文件中的内同写入到程序中 方法一：一次读取一个字节
     */
    public static void readMethod1(String filePath) {
        FileInputStream is = null;
        try {
            is = new FileInputStream(filePath);
            int ch = 0;
            System.out.print("读取方式一: ");
            while ((ch = is.read()) != -1) {
                System.out.print((char) ch);
            }
        } catch (FileNotFoundException e) {
            System.out.println("文件不存在，请检查文件路径是否正确 : " + filePath);
        } catch (IOException e) {
            System.out.println("读取文件错误: " + e.getMessage());
        } finally {
            if (null != is) {
                try {
                    is.close();
                } catch (IOException e) {
                    System.out.println("is流关闭失败：" + e.getMessage());
                }
            }
        }
    }

    /*
     * 将硬盘上的txt文件中的内同写入到程序中 方法二：按照数组大小来读取
     */
    public static void readMethod2(String filePath) {
        FileInputStream is = null;
        try {
            is = new FileInputStream(filePath);
            // 定义读取量大小的数组
            byte[] buf = new byte[1024];
            int len = 0;
            while ((len = is.read(buf)) != -1) {
                // 因为最后的情况可能不足1024个字节，所以在创建string的时候截取到len大小
                System.out.print("读取方式二: "+new String(buf, 0, len));
            }
        } catch (FileNotFoundException e) {
            System.out.println("文件不存在，请检查文件路径是否正确 : " + filePath);
        } catch (IOException e) {
            System.out.println("读取文件错误: " + e.getMessage());
        } finally {
            if (null != is) {
                try {
                    is.close();
                } catch (IOException e) {
                    System.out.println("is流关闭失败：" + e.getMessage());
                }
            }
        }
    }
}

运行结果:
这里写图片描述

这里写图片描述

1.2.2 FileOutputStream

/*
     * 将程序中的字符串输出到硬盘上的文件中
     */
    public static void writeMethod(String filePath) {
        FileOutputStream os = null;
        try {
            os = new FileOutputStream(filePath);
            os.write("abcdefg".getBytes());
        } catch (FileNotFoundException e) {
            System.out.println("文件不存在，请检查文件路径是否正确 : " + filePath);
        } catch (IOException e) {
            System.out.println("读取文件错误: " + e.getMessage());
        } finally {
            if (null != os) {
                try {
                    os.close();
                } catch (IOException e) {
                    System.out.println("is流关闭失败：" + e.getMessage());
                }
            }
        }
    }

运行结果:
这里写图片描述

1.2.3 键盘输入流 System.in

package com.test.blog2;

import java.io.IOException;
import java.io.InputStream;

/*
 * 获取从键盘输入的数据并打印出来
 * */
public class ReadKey {

    public static void main(String[] args) {
        readKey();
    }

    public static void readKey() {
        InputStream in = System.in;
        int ch;
        try {
            ch = in.read();// 阻塞式方法
            System.out.println((char)ch);
            ch = in.read(); // 阻塞式方法
            System.out.println((char)ch);
            ch = in.read(); // 阻塞式方法
            System.out.println((char)ch);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (null != in) {
                try {
                    in.close();
                } catch (IOException e) {
                    System.out.println("in 关闭失败：" + e.getMessage());
                }
            }
        }
    }
}

运行结果:

这里写图片描述

1.2.4 对象化序列流

 ObjectInputStream与ObjectOutputStream
 P.S.
 被操作的对象需要实现序列化。实现序列化就是要实现java.io.Serializable接口.

例子： 定义一个Person类，包含名字和年龄属性，实现序列化

package com.test.blog3;

import java.io.Serializable;

/*
 * 人员类
 * 有名字和年龄属性
 * 实现序列化
 * */
public class Person implements Serializable {

    private static final long serialVersionUID = 1L;
    private String name;// 名字
    private int age;// 年龄

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

    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

测试对象读写:

package com.test.blog3;

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

/*
 * 对象序列化流的读和写演示
 */
public class ObjectStreamDemo {

    public static void main(String[] args) {
        writeTest();
        readTest();
    }

    // 写演示，对象：ObjectOutputStream ,将对象写入到文件中
    public static void writeTest() {
        Person p = new Person("张三", 27);
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("d:\\obj.object"));
            oos.writeObject(p);// 将整个对象写入

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (null != oos) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 读演示，对象：ObjectInputStream,从文件中读取对象信息
    public static void readTest() {
        ObjectInputStream oos = null;
        try {
            oos = new ObjectInputStream(new FileInputStream("d:\\obj.object"));
            Person p = (Person) oos.readObject();// 读取整个对象信息
            System.out.println("名字：" + p.getName() + " 年龄: " + p.getAge());

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (null != oos) {
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行结果: 看到生成obj.object文件
这里写图片描述

运行readTest()方法后的结果：可以正常读取存入信息
这里写图片描述

P.S. 如果序列化类中没有 private static final long serialVersionUID = 1L;这句话那么属性被 public修饰会报错。因为Serializable：用于给被序列化的类加入ID号，用于判断类和对象是否是同一个版本。

总结：一般给实现序列化接口的类定义序列化ID，并要保证这个ID的唯一性

1. 2.5 数组字节流

ByteArrayInputStream与ByteArrayOutputStream
例子：

package com.test.blog3;

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

public class ByteArrayStreamDemo {

    /**
     * @Description: 字节数据流的读写演示
     * @param @param null
     * @return void null
     * @throws
     */

    public static void main(String[] args) {
        //定义读入流，读入字节数组数据
        ByteArrayInputStream bis = new ByteArrayInputStream("abc字母123".getBytes());
        //定义输出流，打印出读到的数据
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        int ch = 0;
        while ((ch = bis.read()) != -1) {
            bos.write(ch);
        }
        System.out.println(bos.toString());
    }

}

运行结果:
这里写图片描述

1.2.6 管道流

PipedInputStream和PipedOutputStream，通常用于多线程中

P.S. 两个线程并发执行，在这个过程中，线程之间需要进行数据通信，需要使用管道流，两方都连接到这个管道，一方写入数据另一个方就可以得到数据了

例子：

package com.test.blog3;

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

public class PipedStream {

    /**
     * @Description: 两个线程之间数据通信，管道流的演示
     * @param @param null
     * @return void null
     * @throws
     */

    public static void main(String[] args) {
        PipedInputStream pis = new PipedInputStream();
        PipedOutputStream pos = new PipedOutputStream();
        try {
            // 重要的步骤，将两个管道流连接起来
            pis.connect(pos);
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 启动两个线程，一个写数据，一个读出数据
        new Thread(new PipedInStream(pis)).start();
        new Thread(new PipedOutStream(pos)).start();

    }
}

/*
 * 用于写出数据的管道流
 */
class PipedOutStream implements Runnable {
    private PipedOutputStream pos;

    public PipedOutStream(PipedOutputStream pos) {
        this.pos = pos;
    }

    @Override
    public void run() {
        try {
            // 写出数据
            pos.write((Thread.currentThread().getName() + "管道流的输出数据测试")
                    .getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭流
            if (null != pos) {
                try {
                    pos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

/*
 * 用于读入数据的管道流
 */
class PipedInStream implements Runnable {
    private PipedInputStream pis;

    public PipedInStream(PipedInputStream pis) {
        this.pis = pis;
    }

    @Override
    public void run() {
        try {
            // 读数据
            byte[] buf = new byte[1024];
            int len = 0;
            while ((len = pis.read(buf)) != -1) {
                System.out.println(Thread.currentThread().getName()
                        + "管道流读入到的数据: " + new String(buf, 0, len));

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭流
            if (null != pis) {
                try {
                    pis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

运行结果:
这里写图片描述

可以看到 线程名称为Thread-0的读到的线程名称为Thread-1 的线程写入的数据信息

1.3 注意

  • 流的关闭 建议放到finally代码块中，保证流关闭操作的执行
  • 读数据的时候定义字节数组缓冲区 这样可以提高效率，但是缓冲区的大小不宜过大，否则容易造成内存溢出
  • 序列化的对象类定义序列化ID，并且唯一
sa_leon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
黑马程序员---IO流
u011045065的专栏
06-30 1178
---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ---------------------- 12、IO流 12.1、IO（Input Output）流    ·IO流用来处理设备之间的数据传输    ·java对数据的操作是通过流的方式    ·java用于操作流的对象都是在IO包中
黑马程序员---IO流一
Ws11352369的专栏
12-05 999
IO流一 ----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------ 1.    File类 1.1概述 1.1.1 File类出现的必要性 存储在变量、数组和对象中的数据是暂时的，当程序终止他们时就会丢失，为了能够永久地保存程序中创建的数据，需要将他们存储到硬盘或光盘的文件，这些文件可以移动，传送，亦可以被
Java字节输入流2
yoyochina的专栏
12-30 125
      昨天晚上研究了一点Java的字节输入流，但输出的都是一个个的数字，那怎么把其输出为原来的样子呢？今天试了一下，如下面的代码。   import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.FileInputStream; import java.io.FileNot...
IO流的总结
weixin_46443325的博客
04-07 729
1：IO流的原理 IO是Input/Output的缩写，用于处理设备之间的数据传输，如读写文件、网络通讯 Java程序中，对于数据的输入/输出操作以“流”的方式进行 java.io包下提供了各种流的接口和类，通过标准的方法输入或输出数据 2：流的分类 2.1：节点流和处理流的区别 处理流需要包装在节点流上 2.2：IO的体系 2.3：InputStream & Reader 的介绍 2.3.1：InputStream的方法 2.3.2：Reade...
Java-IO流高级-例题 & 例题源码 & PPT教学文档（黑马程序员详细版）.rar
07-24
本资料包“Java-IO流高级-例题 & 例题源码 & PPT教学文档（黑马程序员详细版）.rar”提供了一个深入学习Java IO流的全面资源，包含实例题目、源代码以及PPT教学材料，适合对Java IO有进阶需求的开发者。 1. **Java ...
Java-IO流基础例题 & 例题源码 & PPT教学文档（黑马程序员详细版）.rar
07-24
Java IO流分为字节流和字符流两大类，字节流处理的是8位的字节数据，而字符流处理的是16位的Unicode字符。字节流又分为输入流（InputStream）和输出流（OutputStream），字符流则有Reader和Writer。Java IO流还分为...
IO-黑马程序员Java学习笔记.rar
07-24
这个文件很可能是Markdown格式的学习笔记，里面可能详细讲解了Java IO的基础概念，如流的概念、分类（如字节流和字符流）、以及各种流的使用方法。可能会涵盖InputStream、OutputStream、Reader、Writer类族，还...
黑马程序员_毕向东_Java基础视频教程第18天-12-IO流(文本文件读取练习).zip
04-07
在这个“黑马程序员_毕向东_Java基础视频教程第18天-12-IO流(文本文件读取练习)”中，毕向东老师将深入讲解如何使用Java IO流来读取文本文件。Java IO流提供了多种类和方法，使得开发者可以灵活高效地处理输入和输出...
黑马程序员_毕向东_Java基础视频教程第18天-13-IO流(拷贝文本文件).zip
04-07
本教程《黑马程序员_毕向东_Java基础视频教程第18天-13-IO流(拷贝文本文件)》专注于讲解如何利用IO流来实现文本文件的复制操作。这个过程涉及到了对文件读取、数据缓冲以及写入等基础知识，对于初学者来说是理解和...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1141
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 408
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 446
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java内存模型
weixin_44267758的博客
07-19 789
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 774
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 144
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
java算法day19
TOMOT77的博客
07-20 328
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1891
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 974
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
Java IO流详解：字节流与字符流的区别
"Java IO流的学习总结文档，涵盖了流的概念、字节流与字符流的区别以及IO体系的基本功能，特别提到了Reader和Writer类及其常用方法，并举例了FileReader和FileWriter的使用。 一、流的概念 Java中的流是处理数据的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值