IO框架（1）

最新推荐文章于 2024-05-03 06:54:54 发布
最新推荐文章于 2024-05-03 06:54:54 发布
阅读量170 收藏
点赞数
分类专栏： 笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LONGSESON/article/details/115871355
版权

IO框架

课程目标

  1. 流的概念
  2. 流的分类
  3. 字节流
  4. 编码方式
  5. 字符流
  6. File流

什么是流

概念：内存与储存设备之间传输数据的通道

流的分类

按方向【重点】：

输入流：将<储存设备>中的内容读入到<内存>中。

输出流：将<内存>的内容写入到<储存设备>中。

按单位：

字节流：以字节为单位，可以读写所有数据。

字符流：以字符为单位，只能读写文本数据。

按功能：

节点流：具有实际传输数据的读写功能。

过滤流：在节点流的基础上增强功能。

字节流

字节流的父类(抽象类)：

InputStream：字节输入流

OutputStream：字节输出流

FileInptuStream的使用

FileInputStream：

public int read (byte[] b) // 从流中读取多个字节，将读到内容输入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回 - 1.

FileOutputStream：

public viod write(byte[] b) //一次写多个字节，将b组的所有字节，写入输入流

package IO.IO1;

import java.io.FileInputStream;

/**
 * 演示FileInputStream的使用
 * 文件字节输入流
 */

public class Demo01 {
    public static void main(String[] args)  throws Exception {
        //1创建FileInputStream，并指定文件路径
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
//        //2读取文件
//        //2.1单个字节读取
//        //fis.read()
//        int data = 0;
//        while((data = fis.read())!=-1){
//            System.out.println((char) data);
//        }

        //2.2一次读取多个字节
//
//        byte[] buf = new byte[3];
//
//        int count = fis.read(buf);
//        System.out.println(new String(buf));
//        System.out.println(count);
//
//        int count2 = fis.read(buf);
//        System.out.println(new String(buf));
//        System.out.println(count2);
//
//        int count3 = fis.read(buf);
//        System.out.println(new String(buf,0,count3));
//        System.out.println(count3);

        byte[] buf = new byte[3];
        int count = 0;
        while((count = fis.read(buf))!=-1){
            System.out.println(new java.lang.String(buf,0,count));
        }
        //3关闭
        fis.close();
        System.out.println("执行完毕");
    }
}

FileOutStream的使用

package IO.IO1;

import java.io.FileOutputStream;

public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1创建文件字节输出流对象
        //FileOutputStream fos = new FileOutputStream("d:\\bbb.txt");
        //会覆盖
        FileOutputStream fos = new FileOutputStream("d:\\bbb.txt",true);
        //不会覆盖
//        //2输入文件
//        fos.write(97);
//        fos.write('b');
//        fos.write('c');

        String string = "helloworld";
        fos.write(string.getBytes());
        //3关闭
        fos.close();
        System.out.println("执行完毕");
    }

}

字节流复制文件

package IO.IO1;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Demo03 {
    public static void main(String[] args) throws Exception {
        //1创建流
        FileInputStream fis = new FileInputStream("d:\\001.jpg");
        //1.2文件字节输出流
        FileOutputStream fos = new FileOutputStream("d:\\002.jpg");
        //2一边读，一边写
        byte[] buf = new byte[1024];//字节数组
        int count = 0;
        while((count = fis.read(buf))!=-1){
            fos.write(buf,0,count);//指定的数组中偏移的个数  指定的数组的下标  存储数据的长度
        }
        //3关闭
        fis.close();
        fos.close();
        System.out.println("执行完毕");
    }
}

字节缓冲流

缓冲流：BufferedInputStream/BufferedOutputStream

提高IO效率，减少访问磁盘的次数;

数据存储在缓冲区中，flush是将缓存区的内容写入文件中，也可以直接close。

BufferedInputStream的使用

package IO.IO1;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

/**
 * 使用字节缓冲流读取
 */

public class Demo04  {
    public static void main(String[] args) throws Exception{
        //1创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        //2读取
//        int data = 0;
//        while((data = bis.read())!=-1){
//            System.out.println((char)data);
//        }
        //2.1自创缓冲区
        byte[] buf = new byte[1024];
        int count = 0;
        while((count = bis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //3关闭
        bis.close();
    }
}

BufferedOutputStream的使用

package IO.IO1;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

public class Demo05 {
    public static void main(String[] args) throws Exception{
        //1创建字节输出缓冲流
        FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
        BufferedOutputStream bos =new BufferedOutputStream(fos);
        //2写入文件
        for(int i = 0;i<10;i++){
            bos.write("helloworld\n".getBytes());//先写入缓冲区，大小8k
            bos.flush();//刷新到硬盘
        }
        //3关闭(内部调用flush方法)
        bos.close();
        System.out.println("执行完毕");
    }
}

对象流

对象流：ObjectOutputStream/ObjectInputStream

增强了缓冲区功能

增强了读写8种基本类型和字符串功能

增强了读写对象的功能：

readObject() 从流中读取一个对象

writeObject(Object obj) 向流中写入一个对象

使用流传输对象的过程成为序列化，反序列化。

序列化

package IO.IO1;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

/**
 * 使用ObjectOutputStream实现对象的序列化
 */
public class Demo06 {
    public static void main(String[] args) throws Exception{
        //1创建对象六
        FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //2序列化(写入操作)
        Student zhangsan = new Student("张三",20);
        oos.writeObject(zhangsan);
        //3关闭
        oos.close();
        System.out.println("序列化完毕");

    }

}

异常：

NotSerializableException

学生类无法实例化

可以通过

implements Serializable

继承Serializable使学生类可以实例化

反序列化

package IO.IO1;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
/**
 * 使用ObjectInputStream实现啊反序列化(读取重构成对象)
 */
public class Demo07 {
    public static void main(String[] args) throws Exception{
        //1创建对象流
        FileInputStream fis = new FileInputStream("d:\\stu.bin");
        ObjectInputStream ois = new ObjectInputStream(fis);
        //2读取文件(反序列化)
        Student s = (Student)ois.readObject();
        //3关闭
        ois.close();
        System.out.println("执行完毕");
        System.out.println(s.toString());
    }
}

序列化和反序列化注意事项

注意事项：
(1)序列化类必须要实现Serializable接口

(2)序列化类中对象属性也要实现Serializable接口

(3)序列化版本号ID，保证序列化的类和反序列化的类使同一个类

private static final long serialVersionUID = 1021110L;

异常：

InvalidClassException

类的版本号不同

UID改为异常提示的

IO.IO1.Student; local class incompatible: stream classdesc serialVersionUID = -2773328724821145463

private static final long serialVersionUID = -2773328724821145463L;

(4)使用transient(瞬间的)修饰属性，这个属性不能序列化

transient private int age;

(5)静态属性不能序列化

(6)序列化多个对象

序列化(写入操作)
Student zhangsan = new Student("张三",20);
Student lisi = new Student("李四",20);
oos.writeObject(zhangsan);
oos.writeObject(lisi);

反序列化
Student s = (Student)ois.readObject();
Student s2 = (Student)ois.readObject();

ois.close();
System.out.println("执行完毕");
System.out.println(s.toString());
System.out.println(s2.toString());

这样比较麻烦

改进

序列化
Student zhangsan = new Student("张三",20);
Student lisi = new Student("李四",20);

ArrayList<Student> list = new ArrayList<>();
list.add(zhangsan);
list.add(lisi);

反序列化
ArrayList<Student> list =(ArrayList<Student>)ois.readObject();

ois.close();
System.out.println("执行完毕");
System.out.println(list.toString());

字符编码

ISO-8859-1 收录除ASCII外，还包括修，希腊语，台语，阿拉伯语，希伯来语对应的文字符号

UTF-8 针对Unicode码表的可变长度字符编码

GB2312 简体中文

GBK 简体中文，扩充

BIG5 台湾，繁体中文

当编码方式和解码方式不一致时，会出现乱码。

字符流抽象类

字符流的父类（抽象类）：

Reader：字符输入流

public int read(){}

public int read(char[] c){}

public int read(char[] b,int off,int len){}

Writer：字符输出流

public void write(int n){}

public void write(String str){}

public void write(char[] c){}

//UTF-8  12个字节4个汉字3个字节一个汉字，而这里是一个字节一个字节读，所以会乱码

文件字符流

FileReader：

public int read(char[] c)

从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数；如果达到文件的尾部，则返回 - 1。

FileWriter：

public void write(String str)

一次写多个字符，将b数组中所有字符，写入输出流。

package IO.IO2;

import java.io.FileReader;

public class Demo02 {
    public static void main(String[] args) throws Exception{
        //1创建FileReader 文件字符输入流
        FileReader fr = new FileReader("d:\\hello.txt");
        //2读取
        //2.1单个字符读取
//        int data = 0;
//        while((data = fr.read())!=-1){//读取一个字符
//            System.out.print((char)data);
//        }
        char[] buf = new char[1024];
        int count = 0;
        while((count = fr.read(buf))!=-1){
            System.out.println(new java.lang.String(buf,0,count));
        }
        //3关闭
        fr.close();
    }
}

FileWriter的使用

package IO.IO2;

import java.io.FileWriter;

public class Demo03 {
    public static void main(String[] args) throws Exception{
        //1.创建FileWriter对象
        FileWriter fw = new FileWriter("d:\\write.txt");
        //2.写入
        for (int i = 0;i<10;i++){
            fw.write("java是世界上最好的语言\r\n");
            fw.flush();
        }
        fw.close();
        System.out.println("执行完毕");
    }
}

字符流复制文件

使用FileReader和FileWriter复制文本文件，不能复制图片或二进制文件

因为FileReader是读取字符，会把二进制(1011011)数读成乱码

package IO.IO2;

import java.io.FileReader;
import java.io.FileWriter;

/**
 * 使用FileReader和FileWriter复制文本文件，不能复制图片或二进制文件
 */

public class Demo04 {
    public static void main(String[] args) throws Exception{
        //1创建FileReader FileWriter
        FileReader fr = new FileReader("d:\\write.txt");
        FileWriter fw = new FileWriter("d:\\write2.txt");
        //2读写
        int data = 0;
        while((data = fr.read())!=-1){
            fw.write(data);//fr读取write，fw写进write2
            fw.flush();
        }
        //3关闭
        fr.close();
        fw.close();
        System.out.println("复制完毕");

    }
}
请撑住我
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一文了解IO框架，从此对IO不再发怵，积累总结
m0_65146205的博客
12-16 413
//字节输入流 FileInputStream fileInputStream1 = new FileInputStream(“d:\aaa.txt”); //创建缓冲流，将fileInputStream1当作参数，对其进行包裹并添加行为方法 BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream1); //通过read()方法一个字节一个字节读取 int data1 = 0; while((data
使用imba.io框架得到比 vue 快50倍的性能基准
10-16
【imba.io框架详解】 imba.io框架是一个新兴的编程框架，它的设计目标是提供一种新的编程语言，能够编译成高性能的JavaScript代码，适用于Web前端和服务端开发。相较于传统的JavaScript框架，如Vue，imba声称能提供...
IO流框架介绍
m0_56307146的博客
07-10 158
FileUtils.moveDirectory(File srcDir, File destDir) // 文件夹在内的所有文件都将移动FileUtils.moveDirectoryToDirectory(File src, File destDir, boolean createDestDir) // 以子文件夹的形式移动到另外一个文件下。FileUtils.copyURLToFile(URL source, File destination) // 把URL 里面内容复制到文件(可以下载文件)
I/O框架
m0_61766887的博客
07-05 172
i/o框架的介绍
Java知识点总结——IO流框架(1)
最新发布
2401_84091321的博客
05-03 531
针对最近很多人都在面试，我这边也整理了相当多的面试专题资料，也有其他大厂的面经。希望可以帮助到大家。上述的面试题答案都整理成文档笔记。也还整理了一些面试资料&最新2021收集的一些大厂的面试真题（都整理成文档，小部分截图）以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门，即可获取！;if(!// 只能单级目录。
I/O框架知识
m0_71773863的博客
06-05 620
概念：内存与存储设备之间传输数据的通道。
IO框架（学习笔记）
weixin_56555958的博客
02-07 135
BufferedInputStream(字写缓冲输入流)[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x4IMkF12-1675761904790)(C:\Users\昭昭\AppData\Roaming\Typora\typora-user-images\image-20220928172249211.png)]BufferedOutputStream(字写缓冲输出流)
异步IO框架 Cindy
06-02
异步IO框架Cindy是一种高效、灵活的编程模型，它为开发者提供了处理高并发和低延迟场景的能力。在现代计算环境中，特别是在网络服务和大数据处理领域，异步IO已经成为一个关键的技术工具。Cindy框架的设计目标是简化...
Io框架与类图
01-06
本文将深入探讨IO框架，并通过类图解析其内部结构和主要组件，以帮助理解如何在实际应用中有效地使用IO流。 首先，IO框架分为两大类别：字符流（Character Stream）和字节流（Byte Stream）。字符流主要用于处理...
lark-io:IO框架
06-17
lark-io是一个轻量级的 IO 服务框架（受 koa.io 启发）。 lark-io重点关注以下功能 轻的 灵活性 安装 使用 npm 安装lark-io npm install lark-io 开始 为任何 tcp 连接启动服务器： var io = require('lark-io')...
IO框架.md
03-22
IO框架.md
java-IO框架图
03-25
java-IO框架图
Java进阶 - IO框架
luxd1994的博客
03-15 151
作为当前最流行的NIO框架，Netty在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用，一些业界著名的开源组件也基于Netty构建，比如RPC框架、zookeeper等。新的输入/输出 (NIO) 库是在 JDK 1.4 中引入的，弥补了原来的 I/O 的不足，提供了高速的、面向块的 I/O。本文主要介绍Java IO常见类的使用，包括：磁盘操作，字节操作，字符操作，对象操作和网络操作。本文主要对IO多路复用，Ractor模型以及Java NIO对其的支持。
高性能网络IO框架研究一：三种模式
Rocky的技术博客
08-29 840
IoT平台要求能够接入大规模的终端数据，因此对于底层的IO通信系统的性能和稳定性要求非常高。于是我对高性能IO框架进行了一些深入的研究。并将研究的内容总结出来，以供大家交流学习。
IO框架概述
矛盾完善着的博客
07-29 163
个人学习笔记
二、JAVA IO流 框架体系
shiyu_951的博客
07-25 594
一、JAVA　IO流框架体系 （java.io）
【无标题】
flightfish的博客
07-04 266
I/O 模型简单理解为：就是使用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能。Java 支持 3 种网络编程模型：BIO、NIO、AIO。Java BIO：（传统阻塞型），服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不作任何事情会造成不必要的线程开销。Java NIO：，服务器实现模式为一个线程处理多个请求(连接)，即客户端发送的连接请求会被注册到多路复用器上，多路复用器轮询到有 I/O 请求就会进行处理。Java AIO：，AI
Java IO
YKWNDY的博客
01-16 142
出处：https://blog.csdn.net/qq_25184739/article/details/51205186 Java IO概览   在整个Java.io包中最重要的就是5个类和一个接口。5个类指的是File、OutputStream、InputStream、Writer、Reader；一个接口指的是Serializable.掌握了这些IO的核心操作那么对于Java中的IO体...
15-JavaIO框架
gjb760662328的博客
02-22 100
15-JavaIO框架
Ccharp IO设备操作框架
04-05
C# IO设备操作框架是用来处理输入输出设备的开发框架。它包括了各种类和方法，用于读取和写入文件，网络操作，串口通信和其他设备操作。 该框架中包含了以下类： 1. FileStream：用于读取和写入文件，支持随机访问...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值