JavaI/O流【笔记】

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

I/O流

1、什么是I/O流

​ I:input输入

​ O:output输出

​ 输入/输出流（读写文件/数据）

2、I/O分类

1、按照数据的处理格式
  • 字节流：处理二进制数据（图片/音频/视频/…）
    • InputStream:字节输入流
    • OutputStream：字节输出流
  • 字符流：处理字符（txt/…)
    • Reader:字符输入流
    • Writer:字符输出流
2、按照数据的流向

​ 输入流

​ 输出流

注意：如何判断使用输入流还是输出流？

以程序为参照物，观察数据的流向，如果数据流向程序，使用输入流，如果数据从程序流出，使用输出流

3、字节流

1、字节输入流
  • InputStream :抽象类
    • FileInputStream :操作文件（重点）
    • BufferedInputStream:字节缓冲流（ 了解）
1、InputStream常用方法
  • int read()读一个(效率低)
  • int read(byte[] b)读多个（提高效率）
  • int read(byte[] b,int off,int len)
  • void close()关闭

FileInputStream读文件的步骤

​ 1、找到目标文件（路径）

​ 2、和目标文件建立数据通道（流）

​ 3、读文件 read()

​ 4、关闭通道（释放资源）

BufferedInputStream读文件的步骤

​ 1、找到目标文件（路径）

​ 2、和目标文件建立数据通道（流）

​ 3、建立缓冲流数据通道

​ 4、使用缓冲流读数据

​ 5、关闭缓冲通道（释放资源）

 public static void main(String[] args) {
        //1、读取文件
        //（1）找到目标文件
        String path = "C:\\Users\\贺天\\Desktop\\a.txt";
        FileInputStream in = null;//in是局部变量，局部是没有初始值，必须要给初始值

        try {
            //(2)和目标文件建立输入流通道
            in = new FileInputStream(path);
            //(3)读取文件内容
            //1、read():读一个，读取的内容是-1，代表读完了
            
            int content=0;//定义变量，保存赢取内容
            //循环
            //（content=inread()）:读取一个字节，保存到变量content中
            while((content = in.read())!=-1){//如果读取的内容不是-1
                //没有读完
                System.out.print((char)content);//打印读取内容
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                //（4）关闭通道
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

FileNotFundException:找不到文件异常

字节流去读取字符：有可能出现乱码

//read(byte b)
//读取文件内容
String path = "C:\\Users\\贺天\\Desktop\\a.txt";
        FileInputStream in = null;//in是局部变量，局部是没有初始值，必须要给初始值
try {
            //(2)和目标文件建立输入流通道
            in = new FileInputStream(path);
//缓冲数组
byte[] buf = new byte[1024*8];//默认8字节
int length = 0;//定义变量，保存读取长度
//循环
//(length = in.read(buf)):读取内容保存到缓冲数buf中，length代码读取长度
while((length = in.read(buf))!=-1){//如果读取的长度为-1，读完了
    //没有读完
    System.out.println(Arrays.toString(buf));
}
    catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                //（4）关闭通道
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

//读文件：缓冲字节输入流(仅做了解，实际用不上)
//注意：缓冲流不具备读写能力，要依赖具备读写能力的流
public static void main(String[] args){
    long startTime = System.currentTimeMillis();
    //(1)找目标文件 
    String path ="\\\";
    //(2)建立数据通道
        fileInputStream in = null;
    try{
        in = new FileInputStream(path);   
    //(3)创建缓冲流通道    
    BufferedInputStream bufIn = new  BufferedInputStream(in);
    //(4)使用缓冲流读数据
         byte[] buf = new byte[1024 * 8];
        int length = 0;//定义变量，保存读取长度
        while((length = bufIn.read(buf))!=-1){
            System.out.println(Arrays.toString(buf));
        }
         }catch(Exception e){
        e.printStackTrace();
    }finally{
        //(5)释放资源
        in.close();
    }
    
}
2、字节输出流
  • OutputStream :抽象类
    • FileOutputStream :
1、FileOutputStream常用方法

write(int b):写一个

write(byte[] b):写多个

write(byte[] b,int off,int len)

close():关闭

2、写数据步骤：

1、找到目标文件

2、建立数据通道

3、使用通道写数据

4、关闭通道

//写数据 write(int b)
public static void test1(){
    //(1)找到目标文件 
    String path = "C:\Users\贺天\Desktop\b.txt";
    try{
        //(2)建立数据通道
    FileOutputStream out = new FileOutputStream(path,true);//true:拼接；加false：覆盖（默认）
    //(3)使用通道写数据
    out.write("hello world".getBytes());//字符串转字节数组
    }catch(Exception e){
        e.printStackTrace();
    }finally{
        //(4)关闭通道
        out.close();
    }
    
    
    
}
注意：stream:字节/二进制

​ input：输入

​ output：输出

​ Buffered：缓冲

3、拷贝图片：边读边写
write(byte b[] ,int off,int len)
    b:要写的数组
        off:偏移量，从数组那个位置开始写（一般是0）
            len:要读取的长度

注意：使用字节流去写字符要手动进行编码，然后再写

4、字符流

读写字符

字符流：字节流+编码/解码（字符流：直接去写字符）

编码：把能看懂的字符转换成看不懂的二进制数据

解码：把看不懂的二进制数据转换成能看懂的字符

1、读数据
  • Reader
    • FileReader
    • BufferedReader
      • String readLine() 每次读一行，注意：不会读取换行操作
public static void main(String[])throws Exception{
    //1、找到目标文件，建立数据通道
    FileReader reader = new FileReader("\\");
    //2、读取数据
    //定义变量，保存读取内容
    int content = 0;
    //循环：不停地去读
    while((content = reader.read())!=-1){
        System.out.println((char)content);
    }
        //3关闭通道
        reader.close();
}

使用缓冲数组(效率高)

public static void main(String[])throws Exception{
    //1、找到目标文件，建立数据通道
    FileReader reader = new FileReader("\\");
    //2、读取数据
    //定义缓冲数组
    char[] buf = nwe char[1024*8];
    //定义变量，保存每次读取长度
    int length = 0;
    //循环：不停地去读
    while((length = reader.read())!=-1){
        System.out.println(new String(buf,0,length);
    }
        //3关闭通道
        reader.close();
}

//读数据，使用缓冲类
//注意：使用缓冲类不能直接读写数据
public static void main(String[] args)throws Exception{
    //1、找到目标文件，建立数据通道
     FileReader reader = new FileReader("\\");
    //2、创建缓冲类
    BufferedReader bufReader = new BufferedReader(reader);
    //3、使用bufferedReader读取数据
    //定义字符串，保存每次读取内容
    String content = "";
    //循环读取
    while((content = bufReader.readLine())!=null){
        System.out.print(content+"\r\n");//content:每次读取一行的数据，不再换行，需要手动加上换行
        
    }
    //4、关闭缓冲类，关闭数据通道
    bufReader.close();
    reader.close();
}
2、写数据
  • Writer
    • FileWriter
    • BufferedWriter
//不用缓冲类写数据
public static void main(String[])throws Exception{
    //1、找到目标文件，建立数据通道
    FileWriter reader = new FileWriter("\\");
    //2、使用通道写数据
    writer.write("hello world,你好！");
    //3关闭通道
    reader.close();
}

//使用缓冲类写数据
public static void main(String[] args)throws Exception{
    //1、找到目标文件，建立数据通道
    FileWriter writer = new FileWriter("\\");
    //2、创建缓冲类通道
        BufferedWriter buf = new BufferedWriter(writer);
    //3、使用通道写数据
    bufferedWriter.write("hello world,你好！");
    //4、关闭通道
    bufferedWriter.close();
}
3、拷贝文件
public static void main(String[] args)throws Exception{
    //1、找到目标文件，建立数据通道、创建缓冲通道
    BufferedReader bufReader = new BufferedReader(new FileReader("\\"));
    //2、和目标文件建立通道：输出
    BufferedWriter bufWriter = new BufferedWriter(new FileWriter("\\"));
    //3、循环
    //定义变量保存读取内容
    Sting consent = "";
    while((consent =bufReader.readLine())!=null){
        bufWriter.writer(consent+"\r\n");//换行方案一
        //bufWriter.write(consent);
        //bufWriter.newLine();//方案二
    }
    //4、关闭通道
    bufReader.close();
    bufWriter.close();
}

5、转换流

把字节流转换成字符流

（1）输入字节流转成字符流
public static void main(String[] args)throws Exception{
    //(1)字节流
    FileInputStream in = new FileInputStream("\\");
    //(2)转字符流
    InputStreamReader reader = new InputStreamReader(in);
    //创建缓冲数组
    char[] buf = new char[1024*8];
    //定义变量保存每次读取长度
    int length = 0 ;
    //循环
    while((length= reader.read(buf))!=null){
        System.out.println(new String(buf,0,length));
    }
    reader.close();
}
（2）输出字节流转成字符流
public static void main(String[] args)throws Exception{
    //(1)字节流
    FileOutputStream out = new FileOutputStream("\\");
    //(2)转字符流
    InputStreamWriter writer = new OutputStreamReader(out);
    writer.write("hello world");
    //(3)关闭通道
    writer.close();
}

6、对象流

读写java对象()

序列化：把java对象

反序列化：

public void Student() implements Serializable{
    private int xh;
    private String name;
    private String sex;
    
}
1、把java对象写到文件中

序列化（活化）

public static void main(String[] args)throws Exception{
    Student student = new Student();
    student.setXh(120);
    student.setName("小明");
    student.setSex("男");
    //写
    	//1、找到目标文件 ，建立通道
    FileOutputStream out = FileOutputStream("student.txt");
    //2、创建对象流
    ObjectOutputStream objOut = new ObjectOutputStream(out);
    //3写数据
    objOut.writeObject(student);
    //4、关闭数据通道
    objOut,close();
}
2、从文件中读取java对象

反序列化（钝化）

public static void test2(){
    //1、找到目标文件，建立数据通道
    FileInputStream in = new FileInputStream("student.txt");
    //2、创建对象流
    ObjectInputStream objIn = new ObjectInputStream(in);
    //3、读数据
    Student student = (Student)objIn.readObject(student);
    //4、关闭通道
    objIn.close();
    
}

注意：创建对象会调用对应的构造函数？

​ 反序列化时没有调用构造函数

问题：修改类中的成员后，反序列化失败：

​ serialVersionUID:根据类，属性方法…计算得来的值

​ 通过对象流序列化对象时，会把UID写入到文件中

​ 修改类中的属性uid的值就会发生改变

解决：1、重新序列化

​ 2、在实体类中把serialVersionUID写死

private static final long serialVersionUID = 1L;

7、File类

File类：文件（文档/目录）类（封装文件 ）

1、构造函数

File(String pathname)

public static void test1(){
    //(1)File(String pathname):直接传文件路径
    File file = new File("\\");
}

File (String parent,String child)

public static void test1(){
    //(1)File (String parent,String child)
    //parent:父路径   child:文件名
    File file = new File("\\","b.txt");
}

File(File parent,String child)

public static void test1(){
    //(1)File(File parent,String child)
    //parent:父路径对应的File对象   child:文件名
    File file = new File(new File("\\"),"b.txt");
}
2、常用方法

1、boolean exists()，判断文件是否存在

File file1 = new File("\\c.txt");
//判断文件是否存在file1.exists()
System.out.println("file存在吗？"+file1.exists());
//判断是不是文件isFile()
System.out.println("file是文件吗"+file1.isFile());
//判断是不是文件夹isDirectory()
System.out.println("file是文件夹吗？"+file1.isDirectory())
if(!file1.exists()){//判断文件是否存在
    if(file1.isFile()){
        //创建文件
        file1.createNewFile();
    }
    //获取操作
    String name = file1.getName();//获取文件路径
    System.out.println("name ="+name);
    String parent = file1.getParent();//获取文件名
    System.out.println("Parent="+parent);
    String path = file1.getPath();//获取完整的文件路径
    System.out.println("path="+path);
}
//创建文件夹
public static void test3(){
    //创建file对象
    File file1 = new File("\\a");
    //判断：是否存在
    if(!file1.exists()){//如果不存在
        //创建文件夹 mkdir():只能创建单级目录
        file1.mkdir();
    }
    File file2 = new File("\\a\\b");
    if(!file1.exists()){//如果不存在
        //创建多级目录 mkdirs()
        file1.mkdirs();
    }
}

获取所有文件

String[] list()

public static void test3(){
    //创建File对象
    File file1 = new File("\\");
    //获取目录中的所有文件String[] list()
    String[] list = file.list();
    for(String name :list){
        System.out.println(name);
    }
}

File[] listFiles()获取目录中所有文件对象

//获取目录中所有文件对象：File[] listFiles()
File[] files = file.listFiles();
for(File file1 : files){
    System.out.println(file1);
}

String[] list(FilenameFilter filter)获取目录中过滤后的文件

//获取目录中过滤后的所有文件String[] list(FilenameFilter filter)
//FilenameFilter filter：文件名过滤器
String[] list1 = file.list(new filenameFilter({
    public boolean accept(File dir,String name){
        //过滤代码:只要java源文件（以.java结尾的文件）
        //name:
        if(name.endsWith(".java")){//判断是不是java源文件
            //是
            return true;//要
        }
        return false;//不要
    }
}));

File[] listFiles(FilenameFilter filter)获取目录中过滤后的文件对象

File[] list2 = file.listFiles(new FilenameFilter(){
    public boolean accept(File dir,String name){
        //只要图片
        if(name.endWith(".png")||name.endsWith(".jpg")){
            return true;//要
        }
        return false;//不要
    }
});

删除

public static void test5(){
    //创建File对象
    File file = new File("\\a.txt");
  	//删除文件
    file.delete();//删除文件或空的文件夹
    //删除文件夹
    File file2 = new("\\a");
    file2.delete();
  
}

使用File对象进行I/O流操作

public static void test6(){
    //1 找到目标对象
    File file = new File("\\a.txt");
    //2、建立数据通道
    FileReader reader = new FileReader(file);
    //3、读数据
    char[] buf = new char[1024*8];
    int length = 0;
    while((length = reader.read(buf))!=-1){
        System.out.println(new String(buf,0,length));
    }
    //4、关闭通道
    reader.close();
}
HT丶请叫我滚去学习
关注
  • 9
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java_I/O流的教程
11-18
本教程详细讲解了这些知识点，并配以代码示例和笔记，旨在帮助学习者逐步掌握Java I/O流的使用，无论你是初学者还是有一定经验的开发者，都能从中受益。通过深入学习和实践，你将能够熟练地处理各种数据输入输出场景...
跟汤老师学Java（第15季）：I/O输入输出流
06-13
本课程从零开始，以通俗易懂的方式讲解Java技术，手把手教你掌握每一个知识点。 真正做到零基础入门学习，适合初学者的教程！ 课程内容包括： 1.File类 2.IO流简介 3.流的分类  输入流、输出流  字节流、字符...
【Java】I/O流之字节流
weixin_53972936的博客
03-16 917
电脑中存储的文件都是以二进制以字节为单位的形式保存，在传输时也是按字节传输。所以说，字节流可以读取以及传输任意格式的文件数据。
Java-----I/O(字节流)流详解
weixin_51287725的博客
03-10 445
IO:流在Java中指的是计算中流动的缓冲区； 从外部设备流向中央处理器的数据流称为：“输入流”； 从中央处理器流向外部设备的数据称为:"输出流"； 字符流与字节流的区别：
Java之I/O流（最详细的I/O流总结）
熊凯瑞的博客
05-15 6348
I/O流I/O流1、定义2、分类2.1 字节流和字符流2.2 输入流和输出流2.3 节点流和处理流3、结构4、字节流4.1 定义4.2 说明4.3 字节流概述4.4 InputStream的常用方法4.5 OutputStream的常用方法5、字节流读写文件5.1 说明5.2 注意5.3 字节输入流——相关代码5.4 字节输出流——相关代码6、文件的拷贝6.1 需求6.2 分析6.3 注意6.4 快捷键6.5 相关代码7、字节流的缓冲区7. 相关代码8、字节缓冲流8.1 说明8.2 特点8.3 相关代码8.
Java I/O字节流
lucas的博客
08-11 148
I/O流 一、IO产生的原因 在操作系统中，一切数据都以文件的形式存储。需要长久保存的文件数据，存储在外部设备。 程序运行时，所有的数据都需要在内存中，同时，内存的大小有限，因此常常需要在内存和外设之间交换数据，即I/O、 在Java语言中主要通过输入流和输出流，完成I/O的功能，从而实现和外设的数据交互 二、IO流 IO流用来处理JVM内存和外部设备之间的数据传输。在Java中，我们通过流（Stream）的方式完成对数据进行输入、输出的操作。 1. IO流的分类 根据数据的流动方向： 输入流（对数据
JAVA I/O读书笔记
nvnnv的博客
04-11 403
关键字：流，字节，字符，通道，缓冲区，持久化，序列化，交互，标准I/O，压缩旧I/O包字节流读写，字符流读写（请先分清字节与字符的差别）。 区别：后者更快，但某些东西只能用字节读写（大概取决于它的数据存储方式） 区分：Reader、Wirter结尾是字符流，Stream是字节流。JAVA针对各种类型读写做有专用类，例如：File~ String~ Buffer~ 注意带缓冲的往往读写效率更快一些
java中I/O流学习笔记
蜗牛的专栏
05-22 985
对于I/O流一直有种云里雾里的ga
Java I/O流详解
热门推荐
Window_mouse的博客
04-10 1万+
Java I/O流 1、Java I/O流概述 IO就是输入、输出。Java IO类库基于抽象基础类InputStream和OutputStream构建了一套I/O体系，主要解决从数据源读入数据和将数据写入到目的端的问题。我们可以将数据源和目的地理解为IO流的两端。 从一种数据源中通过InputStream流对象读入数据到程序内存中流程如图 1-1所示； 从程序内存中通过OutputStream流对象写入到目的地的流程图如图 1-2所示。 图 1-1 图 1-2 然后，除了面向字节流的InputSt
Java--I/O流
weixin_68489989的博客
07-03 1264
Java--I/O流笔记
Java之I/O 流学习笔记
MRS_jianai的博客
11-30 57
java I/O流学习笔记
JAVA I/0流学习笔记
GYFsix的博客
04-18 2622
File类 创建File对象 需要导包：import java.io.File; 常见File对象的构造方法 方法声明 功能描述 File(String pathname) 通过指定的文件类型创建对象 File(String parent, String Child) 根据指定的父路径和字符串类型的子路径创建对象 File(File parent, String Child) 根据指定的File类父路径和字符串类型的子路径创建对象 若只处理一个目录或文件并知道路径使用第一个比
java高级特性 - io流笔记
05-30
Java 1.4引入了NIO（New I/O），提供了更高效、非阻塞的数据读写方式，如`Channels`、`Buffers`和`Selectors`。 以上就是Java IO流的一些主要知识点，通过理解和熟练运用这些特性，开发者可以有效地处理程序中的...
java超强笔记
12-03
文件I/O操作是任何编程语言都不可或缺的部分，Java也不例外。笔记会讲解如何在Java中读写文件，理解流的概念，以及文件的复制、追加等操作。 在面向对象高级特性的部分，笔记可能包含抽象类、接口、内部类、匿名类...
java_I\O学习笔记
10-19
java_I\O学习笔记 主要讲的是字节流以及缓冲流的操作
谷粒商城实战笔记-38-前端基础-Vue-指令-单向绑定&双向绑定
epitomizelu的专栏
07-20 994
安全性v-text更安全，因为它总是将数据作为纯文本插入，不解析 HTML。v-html则可能引发安全问题，因为它会解析并渲染 HTML 标签。用途v-text适用于插入文本数据，而v-html适用于插入需要被解析为实际 HTML 的数据。处理 HTML 标签v-text忽略 HTML 标签，将其视为普通文本；v-html则会解析并显示 HTML 标签。二者都是单向绑定，元素绑定model，model不绑定元素，元素值改变时model值不会更新。
OpenGL笔记十四之GLM数学库的配置与使用
小勇博客
07-20 382
— 2024-07-20 中午。
谷粒商城实战笔记-39-前端基础-Vue-指令-v-on、v-for、v-if
最新发布
epitomizelu的专栏
07-20 973
v-on 是 Vue.js 中的一个指令，用于在 DOM 元素上监听用户事件，并在事件触发时执行相应的 JavaScript 函数。它提供了一种将 Vue 实例中的方法与 DOM 事件关联起来的方式，使得你可以轻松地对用户交互做出响应。v-on 指令的基本语法是在元素上添加 v-on:event-name=“method”，其中 event-name 是你要监听的 DOM 事件类型（如 click、mouseover、keydown 等），method 则是 Vue 实例中定义的方法名。
江科大/江协科技 STM32学习笔记P6
sususu_2001的博客
07-19 306
AHB(Advanced High-performance Bus), 高速总线，用来接高速外设的。APB (Advanced Peripheral Bus) 低速总线，用来接低速外设的。APB2一般是和AHB同频率，都是72MHz，APB1一般是36MHz。APB2连接的一般是外设中稍微重要的部分，比如GPIO端口，还有一些外设的一号，比如USART1、SPI1、TIM1、TIM8，还接ADC、EXTI、AFIO。其他的2、3、4…外设和DAC、PWR、BKP等次要点的外设都放到APB1。
Java/JavaEE学习笔记精华版
笔记深入到CoreJava的学习，这是Java的基础，包括了JAVA前言、标识符、关键字、类型、表达式与流控制、数组、对象和类、高级语言特性（如封装、继承、多态）、异常处理、GUI编程、事件处理模型、线程、标准I/O流与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值