12_IO流_字节流

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量210 收藏
点赞数 8
分类专栏： # Java中级 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/code_stream/article/details/134686253
版权

前置知识

ASCII

ASCII ( American Standard Code for Information Interchange ) ：美国信息交互标准代码（包括了英文和符号）

标准的 ASCII 使用 1 个字节存储一个字符

1 字节：00000000

GBK

汉字编码字符集，包含了 2 万多个汉字等字符，GBK 中一个中文字符编码成两个字节的形式存储

注意：GBK 兼容了 ASCII 字符集

2 字节：00000000，00000000

Unicode

Unicode 是国际组织制定的，是可以容纳世界上所有文字、符号的字符集

UTF-8：英文字符、数字等只占 1 个字节（兼容标准 ASCII 编码），汉字字符占用 3 个字节

编码与解码
import java.util.Arrays;

public class Test {
    public static void main(String[] args) throws Exception {
        // 1. 编码
        String data = "a我b";
        byte[] bytes = data.getBytes();  // 不填参数，默认按照当前编辑器平台UTF-8进行编码
        System.out.println(Arrays.toString(bytes));

        // 按照指定字符集进行编码
        byte[] bytes1 = data.getBytes("GBK");
        System.out.println(Arrays.toString(bytes1));

        // 2. 解码
        String s1 = new String(bytes);
        System.out.println(s1);

        String s2 = new String(bytes1,"GBK");
        System.out.println(s2);
    }
}

IO 流

体系介绍

IO 流体系

  • 字节流
    • 字节输入流（InputStream）===>（FileInputStream）
    • 字节输出流（OutputStream）===>（FileOutputStream）
  • 字符流
    • 字符输入流（Reader）===>（FileReader）
    • 字符输出流（Writer）===>（FileWriter）

注意！输入流、输出流都是指对 “内存” 的输入和输出，例如：文件输入流 FileInputStream 指的是"文件对内存的输入流"

文件字节输入流
  • 每次读取一个字节
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;

public class Test {
    public static void main(String[] args) throws Exception {
        // 1. 创建文件字节输入流管道，与源文件接通
//        InputStream is = new FileInputStream(new File("E:/Desktop/temp.txt"));
        InputStream is = new FileInputStream("E:/Desktop/temp.txt");  // 简化写法

        // 2. 开始读取文件的字节数据（当前文件里面写有"ab"两个字母）
        // 每次读取一个字节返回，如果没有数据了，返回-1
//        int b1 = is.read();
//        System.out.println(b1);  // 97
//
//        int b2 = is.read();
//        System.out.println((char) b2);  // b
//
//        int b3 = is.read();
//        System.out.println(b3);  // -1

        // 3. 用循环改造上面代码
        int b;
        while ((b = is.read()) != -1) {  // 此方法还是有问题：读取数据性能很差！读取中文字符一定会乱码
            System.out.println((char) b);
        }
        // 运行结果
        // a
        // b

        is.close();  // 一定要记得关闭管道！释放它所占据的系统资源
    }
}
  • 每次读取多个字节
import java.io.FileInputStream;
import java.io.InputStream;

public class Test {
    public static void main(String[] args) throws Exception {
        // 文件中的数据：abc66
        // 1. 创建文件字节输入流管道，与源文件接通
        InputStream is = new FileInputStream("E:/Desktop/temp.txt");

        // 2. 开始读取文件中的字节数据
        byte[] buffer = new byte[3];
        int len = is.read(buffer);  // 每次读取多个字节到字节数组中去，返回读取的字节数量，读取完毕会返回-1
        String res = new String(buffer);
        System.out.println("读取的内容是: " + res);
        System.out.println("当次读取的字节数量: " + len);

        int len2 = is.read(buffer);
        // 注意: 读取多少，倒出多少
        String res2 = new String(buffer, 0, len2);
        System.out.println("读取的内容是: " + res2);
        System.out.println("当次读取的字节数量: " + len2);

        int len3 = is.read(buffer);
        System.out.println(len3);  // -1
        
        is.close();  // 关闭输入流管道

//        运行结果:

//        读取的内容是: abc
//        当次读取的字节数量: 3
//        读取的内容是: 66
//        当次读取的字节数量: 2
//         -1
    }
}

// 上面代码的改造

import java.io.FileInputStream;
import java.io.InputStream;

public class Test {
    public static void main(String[] args) throws Exception {
        // 文件中的数据：abc66
        // 1. 创建文件字节输入流管道，与源文件接通
        InputStream is = new FileInputStream("E:/Desktop/temp.txt");

        // 2. 读取文件中的字节数据（使用循环的方法）
        byte[] buffer = new byte[3];
        int len;  // 记住读取了多少个字节
        while ((len = is.read(buffer)) != -1) {
            String res = new String(buffer, 0, len);  // 将数组中的 0 ~ len转为字符串输出
            System.out.println(res);
        }
        // 性能得到了明显的提升
        // 但是！这种方案也不能避免读取汉字输出乱码的问题


        is.close();  // 关闭输入流管道
    }
}
  • 一次性读取完全部字节
// 方法一

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;

public class Test {
    public static void main(String[] args) throws Exception {
        // 文件中的数据：abcd我爱你66

        // 一次性读取完文件中的所有字节到数组中去
        // 1.创建文件字节输入流管道，与源文件接通
        InputStream is = new FileInputStream("E:/Desktop/temp.txt");
        // 2.准备一个字节数组，它的大小需要和文件的大小正好一样大
        File f = new File("E:/Desktop/temp.txt");
        long size = f.length();
        byte[] buffer = new byte[(int) size];

        int len = is.read(buffer);
        System.out.println(new String(buffer));
        System.out.println(len);
        System.out.println(size);
        is.close();  // 关闭输入流管道

        // 运行结果
//        abcd我爱你66
//        15
//        15
    }
}

// 方法二

import java.io.FileInputStream;
import java.io.InputStream;

public class Test {
    public static void main(String[] args) throws Exception {
        // 文件中的数据：abcd我爱你66

        // 一次性读取完文件中的所有字节到数组中去

        // 1.创建文件字节输入流管道，与源文件接通
        InputStream is = new FileInputStream("E:/Desktop/temp.txt");

        // 2.使用封装好的功能
        byte[] buffer = is.readAllBytes();
        System.out.println(new String(buffer));  // abcd我爱你66

        is.close();  // 关闭输入流管道
    }
}
文件字节输出流
import java.io.FileOutputStream;
import java.io.OutputStream;

public class Test {
    public static void main(String[] args) throws Exception {
        // 1. 创建一个字节输出流管道与目标文件接通（默认是覆盖原文件内容的）
//        OutputStream ops =  new FileOutputStream("E:/Desktop/a.txt");

        // 如果是想要一个能够追加数据的管道：请将参数append的值设为true
        OutputStream ops = new FileOutputStream("E:/Desktop/a.txt", true);

        // 2. 开始写字节数据出去了
        // write() : 如果直接写内容进去，每次只能写一个字节; 如果用byte[]数组，则不受限制
        ops.write(97);
        ops.write('b');
//        ops.write('王');  // UTF-8字符集下，汉字占3个字节，因此这里开始会乱码

        byte[] bytes = "okok我爱你abc".getBytes();
        ops.write(bytes);

        // 换行符 : 为了不仅在 Windows 上能使用，我们建议写全，即：把 \n 写为 \r\n
        byte[] bytes1 = "\r\n".getBytes();
        ops.write(bytes1);

        ops.close();  // 关闭输出流管道，释放被占用的系统资源
    }
}
文件复制案例
// 以下代码，可以复制一切文件
// 原因：任何文件的底层都是字节，字节流做复制，是一字不漏的转移完全部字节，只要复制后文件格式一致就没问题！

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

public class Test {
    public static void main(String[] args) throws Exception {
        // 复制照片
        // 1. 创建一个字节输入流管道与源文件接通
        InputStream inputStream = new FileInputStream("E:/Desktop/photo.jpg");

        // 2. 创建一个字节输出流管道与目标文件接通
        OutputStream outputStream = new FileOutputStream("E:/Desktop/aaa/photo.jpg");

        // 3. 创建一个字节数组，负责转移字节数据
        byte[] buffer = new byte[1024];  // 1KB

        // 4. 从字节输入流中读取字节数据，写出去到字节输出流中，读多少写多少
        int len;  // 记住每次读取了多少个字节
        while ((len = inputStream.read(buffer)) != -1) {
            outputStream.write(buffer, 0, len);
        }
        outputStream.close();
        inputStream.close();
        System.out.println("Successful!");
    }
}
释放资源
// 方式一 : 手动释放

import java.io.*;

public class Test {
    public static void main(String[] args) {
        InputStream inputStream = null;
        OutputStream outputStream = null;
        try {
            System.out.println(10 / 0);  // 错误代码（测试用）
            // 1. 创建一个字节输入流管道与源文件接通
            inputStream = new FileInputStream("E:/Desktop/photo.jpg");

            // 2. 创建一个字节输出流管道与目标文件接通
            outputStream = new FileOutputStream("E:/Desktop/aaa/photo.jpg");

            // 3. 创建一个字节数组，负责转移字节数据
            byte[] buffer = new byte[1024];  // 1KB

            // 4. 从字节输入流中读取字节数据，写出去到字节输出流中，读多少写多少
            int len;  // 记住每次读取了多少个字节
            while ((len = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, len);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            // 释放资源的操作
            try {
                if (outputStream != null) outputStream.close();
                if (inputStream != null) inputStream.close();
                System.out.println("Successful!");
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

// 方式二 : 自动释放

import java.io.*;

public class Test {
    public static void main(String[] args) {
        try (
                // 注意: 小括号这里面只能放置资源对象（流对象）

                // 1. 创建一个字节输入流管道与源文件接通
                InputStream inputStream = new FileInputStream("E:/Desktop/photo.jpg");
                // 2. 创建一个字节输出流管道与目标文件接通
                OutputStream outputStream = new FileOutputStream("E:/Desktop/aaa/photo.jpg");

        ) {
//            System.out.println(10 / 0);  // 错误代码（测试用）

            // 3. 创建一个字节数组，负责转移字节数据
            byte[] buffer = new byte[1024];  // 1KB

            // 4. 从字节输入流中读取字节数据，写出去到字节输出流中，读多少写多少
            int len;  // 记住每次读取了多少个字节
            while ((len = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, len);
            }
            System.out.println("Successful!");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }
}
code_stream
关注
  • 8
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python字节流和字符流_字符流与字节流
weixin_39548787的博客
12-04 2299
[一]写在前面简单总结一下分别用(一直混淆的)字节流or字符流读写文件。[二]字节流2.1 字节流介绍程序中的输入输出都是以流的形式保存的(输入流or输出流),流中保存的实际上全都是字节(一个字节等于一个Byte占8个bit)文件。Java提供了OutputStream、InputStream两个专门操作字节流的类。知识补充1：计算机能存储的唯一东西就是 bytes,为了在计算机中存储东西,我们首...
day12_IO流01.zip
09-12
"day12_IO流01.zip"这个压缩包文件可能包含了一系列有关Java IO流的教程或示例代码，用于帮助学习者深入理解这一重要概念。下面，我们将详细探讨Java IO流的各个方面。 Java IO流分为四大类：字节流（Byte Stream）...
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
java io 缓冲流_Java字节缓冲流
weixin_34672536的博客
02-12 912
在IO包中提供两个带缓冲的字节流，分别是BufferedInputStream和BufferdOutputStream，这两个流都使用了装饰设计模式。它们的构造方法中分别接收InputStream 和OutputStream 类型的参数作为被包装对象，在读写数据时提供缓冲功能。应用程序、缓冲流和底层字节流之间的关系如图所示。从图中可以看出应用程序是通过缓冲流来完成数据读写的，而缓冲流又是通过底层被...
Java_IO流
qq_52215881的博客
09-20 2040
JavaIO
Java_IO流(精讲)包含练习题及答案
红目香薰
11-28 2348
1、Java Io流的概念 流：代表任何有能力产出数据的数据源对象或者是有能力接受数据的接收端对象。 流的本质:数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。 作用：为数据源和目的地建立一个输送通道 Java IO所采用的模型 Java的IO模型设计非常优秀，它使用Decorator[ˈdekəreɪtə(r)](装饰者)模式，按功能划分Stream[striːm]英[striːm]美，您可以动态装配这些Stream，以便获得您需要的功能。 例如，您需要一个具有缓冲的
linux IO_FILE 利用
sky123博客
03-29 4万+
基本结构 _IO_FILE_plus 定义如下： struct _IO_FILE_plus { FILE file; const struct _IO_jump_t *vtable; }; 包括一个结构体 file 和一个指针 vtable 。 其中 vtable 指向一个函数指针表，很多 IO_FILE 的攻击都是围绕它展开的。 _IO_FILE_plus 类型的结构有 _IO_2_1_stdin_ 、 _IO_2_1_stdout_ 和 _IO_2_1_stderr_ 。另外有头指针 _IO_
java字节流读取文件_字节流读取文件 java的几种IO流读取文件方式
weixin_42551028的博客
02-21 2398
java字节流怎么读取数据字节流读取数据例子如下： import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;/** * 复制文件 * @author young ...
好好说话之IO_FILE利用（1）：利用_IO_2_1_stdout泄露libc
hollk’s blog
02-19 5404
前言 这道题是wiki上tcache attack部分的第二道例题，原题在wiki那个题包里，需要自己找一下，忘记在哪了。。。。。其实个人感觉这道题的考点并不是tcache attack，而是在于IO_FILE的利用。因为这道题与以往所见并不太相同，并没有输出函数，也就意味着无法通过往常的方式利用程序自身的输出函数进行泄露内存地址，所以这时候就需要利用IO_FILE的方式进行输出（我也是第一次遇到，肝了好几天）。这篇文章主要分为两个部分，前半部分主要讲解IO_FILE泄露libc的方式，后半部分是HITCO
Java IO 流：字节流、字符流、接口、实现类与阻塞方法
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！这里是我记录技术心得、分享经验的地方。✨
07-14 6483
在 Java 中，IO（Input/Output）流是处理数据输入输出的重要部分。无论是从文件、网络还是其他数据源读取数据，或是将数据写入到这些位置，Java 都提供了丰富的流类库来支持这些操作。下面我们将详细介绍 Java IO 流中的字节流、字符流、常见的接口、实现类以及阻塞方法。
IO流：字节流、字符流、缓冲流、转换流、数据流、序列化流 --Java学习笔记
m0_71386740的博客
04-04 1109
在try-catch-finally中无论代码是否报错，它都会在结束之前执行finally里面的语句，除非在其它地方使用System.exit()关闭了jvm，所以使用try-catch-finally方式是肯定会释放资源执行close的。即使每次读取三个字节，依旧无法避免乱码的可能，因为若读取的字符串排列为前面俩个英文接一个中文，就会读取到前面俩个英文的（英文数字在utf-8中占一个字节）字节和中文的其中一个字节。自带8K(8192)的字符缓冲池，可以提高字符输入流读取字符数据的性能。
javaIO流基础.zip_IO流 上传 下载文件_io流 上传_io流下载_下载
09-20
`TestBufferedInputStream.java`和`TestBufferedOutputStream.java`涉及到缓冲字节流(BufferedInputStream和BufferedOutputStream)，它们与缓冲字符流相似，但处理的是字节流。这些类可以提高对原始字节输入/输出流...
Java_IO.rar_IO流 java_java io流
09-21
在Java中，IO流可以分为两类：字节流（处理单个字节）和字符流（处理Unicode字符）。此外，它们又可以分为四大类：输入流（用于读取数据）、输出流（用于写入数据）、节点流（与特定数据源或目的地关联）和过滤流...
ioliu.rar_IO流 java_Java Reader Writer_java IO_stream
09-20
* io流 运用 * 注意：只要子类 包含以下类名字的，就是该流的继承 * InputStream－－－－－ 输入字节流 * Reader－－－－－－－－ 输入字符流 * OutputStream－－－－－输出字节流 * Writer －－－－－－－－...
commons-io-1.4.jar.zip_io流jar
09-23
Java IO流体系结构分为四类：字节流（Byte Stream）、字符流（Character Stream）、对象流（Object Stream）和套接字流（Socket Stream）。字节流处理单个8位的字节，而字符流基于Unicode编码，处理16位的字符。对象...
spring事务详细讲解-深入浅出
小电玩
09-08 420
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1424
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1350
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 352
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
JAVA IO流详解：字节流与字符流的区别
"JAVA_IO流学习" 在Java编程中，IO（Input/Output）流是处理数据传输的核心概念，它允许程序与外部设备之间进行数据交互，如硬盘、内存、键盘输入等。Java IO流的引入主要是为了解决数据的读写问题，并提供了丰富的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值