IO流

最新推荐文章于 2024-11-04 22:26:34 发布
最新推荐文章于 2024-11-04 22:26:34 发布
阅读量94 收藏
点赞数
分类专栏： java 学习 文章标签： java 后端 stream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46361249/article/details/115681085
版权

文章目录

概念：

i: input输入
o: out输出
流：数据（字符，字节）
在这里插入图片描述

字节输出流

outputStream字节输出流
fileoutputstream 文件字节输出流
Fileoutputstream(String name) //文件路径 指定文件写入输出文件流
Fileoutputstream(File file)//目的文件 创建一个指定file对象表示的文件中写入数据的文件输出

构造方法作用：

  1. 创建一个Fileoutputstream对象，
    2**.根据传递的文件路径 创建一个空的文件**
    3.把Fileoutputstream对象指向创建好的文件

写入数据的原理（内存–>硬盘）
java–> jvm -->os（操作系统）–>os调用写数据的方法–>把数据写入文件夹

字节输出流的使用步骤

1.创建一个Fileoutputstream对象，构造方法中传递写入数据目的地
2.调用Fileoutputstream对象中的writre，把数据写入文件夹
3.释放资源（清理内存）

基本原理

在这里插入图片描述

eg1(一个字节）:
在这里插入图片描述
eg2（多个字节）：
规则

实例
结果

eg3：字符串
1.转换为字符数组
2.写入字符数组
在这里插入图片描述
结果
eg:追加写/续写
append:追加写开关 true–不覆盖原文件；false–创建新文件覆盖原文件
在这里插入图片描述
在这里插入图片描述

字节输入流

子类方法：
int read()从输入中读取下一个字节
int read(byte[] b)读取字节数组
void close()关输入
作用：把硬盘数据读取到内存中

构造方法参数：
FileIntputstream(String name) //文件路径
FileIntputstream(File file)//目的文件

构造方法作用：

  1. 创建一个FileIntputstream对象，
    2.把FileIntputstream对象指向要读取的文件

使用步骤
1.创建FileIntputstream对象，读取数据源
2.使用FileIntputstream对象中的方法read,读取文件
3.释放资源
eg1:单个读取，
读取文件
重复的过程，使用循环优化，当读取到-1的时候结束循环
在这里插入图片描述
eg2：多个字节读取
在这里插入图片描述
demo文件复制:
1.创建字节输入流，
2.创建一个字节输出流
3.用字节输入流对象read读取文件
4.使用字节输出流的write，输出到文件夹
5.释放资源

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

public class demotext {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream(".//d.txt");
        FileOutputStream fos=new FileOutputStream(".//c.txt");
      /*单个字节
          int len=0;
      while ((len=fis.read())!=-1)
        {
            fos.write(len);
        }*/
       //多个字节
        byte[] bytes =new byte[1024];
        int len=0;
        while ((len=fis.read(bytes))!=-1)
        {
            fos.write(bytes,0,len);
        }
        //释放资源
     fis.close();
        fos.close();
    }
}

字符输入流

字节流：每次读取一个字节 ，gbk 2个字节，utf-8 3个字节，每次读中文 就会只读取1/3中文 就会报乱码
字符流：可以一次读取一个字符包括中文
子类方法：
int read()从输入中读取下一个字节
int read(char[] cbuf)读取字节数组
void close()关输入
作用：把硬盘数据读取到内存中

构造方法参数：
FileReader(String name) //文件路径
FileReader(File file)//目的文件

构造方法作用：

  1. 创建一个FileReader对象，
    2.把FileReader对象指向要读取的文件

使用步骤
1.创建FileReader对象，读取数据源
2.使用FileReader对象中的方法read,读取文件
3.释放资源

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;

public class demotext {
    public static void main(String[] args) throws IOException {
        FileReader fr=new FileReader(".//d.txt");

    /*
    单个字符
    int len=0;
      while ((len=fr.read())!=-1)
        {
            System.out.println((char)len);
        }
      */
    //多个字符
        char[] cs =new char[1024];
        int len=0;
        while ((len=fr.read(cs))!=-1)
        {
            System.out.println(new String(cs,0,len));
        }
        fr.close();
    }
}

字符输出流

使用步骤
1.创建FileWriter对象，读取数据源
2.writer方法,把数据写到内存中（字符转换为字节）
3.flush方法，把缓存区的数据刷新到文件夹中
4.释放资源。（也会刷新缓冲区，释放资源，但是流对象不能再使用）


/*
//文件的复制
1.创建字节输入流，
2.创建一个字节输出流
3.用字节输入流对象read读取文件
4.使用字节输出流的write，输出到文件夹
5.释放资源
*/
import java.io.*;

public class demotext {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter(".//k.txt",true); //1.创建对象，  //续写，不覆盖
   /*
    //单个个字符
       fw.write(97); //2.写资源
       fw.flush();//3.刷新缓冲区
        fw.close(); //4.关的时候也会刷新缓冲区
   */

   
    /*
    //多个字符
        char[] cs ={'松','哥','6','6'};
        fw.write(cs);
        // fw.write(cs,1,3); //写1-3位的字符
         fw.flush();
        fw.close();
        */

    
        //字符串
        fw.write("松哥666"+"\n");
        fw.flush();
        fw.close();
    }
}

Properties集

Properties类持久的属性集，可保存在流中或从流中加载
Properties唯一和IO流结合的集合
properties是双列集合，key和value都是String
store方法，集合数据存入硬盘
load方法，读取数据到集合

Property集合存储遍历

setProperty(String key,String value)调用hashtable的put方法
Setset=prop.stringPropertyNames(); 返回属性的健集，其中健值对应的是字符串
prop.getProperty(key);通过key找到value值

使用步骤
1.创建Properties对象
2.使用setProperty往集合添加数据
3.返回属性的健集，
4.获取健值

import java.util.Properties;
import java.util.Set;

public class demo6 {


    public static void main(String[] args) {
        //1.创建Properties对象
        Properties prop=new Properties();
        //2.使用setProperty往集合添加数据
        prop.setProperty("松哥","666");
        prop.setProperty("龙哥","777");
        prop.setProperty("谦哥","888");

        // Set<String> .stringPropertyNames() 3.返回属性的健集，
        Set<String>set=prop.stringPropertyNames();

        for (String key: set) {
            //4.获取健值
            String value=prop.getProperty(key);
            System.out.println(value);
        }
    }
}
store方法

void store(OutputStream out,String comments) 字节输出流
void store(Writer writer,String comments) 字符输出流
comments：注释，不能采用中文，默认unicode

使用步骤：
1.创建Properties对象
2.创建字节/字符输出流对象，绑定输出地
3.使用properties的strore方法,把数据写入硬盘

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.Properties;
import java.util.Set;

public class demo6 {


    public static void main(String[] args) throws IOException {
        //1.创建Properties对象
        Properties prop=new Properties();

        //2.使用setProperty往集合添加数据
        prop.setProperty("松哥","666");
        prop.setProperty("龙哥","777");
        prop.setProperty("谦哥","888");

        //3.创建输出流
        FileWriter writer=new FileWriter(".//e.txt");

        //4.用Properties方法中的store方法写入硬盘
        prop.store(writer,"data");

        writer.close();
    }
}
load方法

void load(InputStream in) 字节输入流
void load(Reader reader) 字符输入流

注
1.健与值默认=，空格，
2.可以使用#注释
3.健值默认字符串，不需要加引号
使用步骤
1.创建Properties对象
2.创建输入流
3.用load方法保存健值对的文件
4.遍历集合
5.关流

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.Properties;
import java.util.Set;

public class demo6 {

    public static void main(String[] args) throws IOException {
        //1.创建Properties对象
        Properties prop=new Properties();

        //2.创建输入流
        FileReader Reader=new  FileReader(".//e.txt");

        //3.读取输入流的健值对文件
          prop.load(Reader);

        //4.遍历
        Set<String> set =prop.stringPropertyNames();

        for (String key:set) {
            String value=prop.getProperty(key);
            System.out.println(value);
        }
      //5.关流
        Reader.close();
    }
}

缓冲流

不用缓存 一个一个a,传完了传b
用缓存 ，a，c,b,d放入缓存区，然后一下发给用户
在这里插入图片描述

字节输出缓冲流

构造方法：
BufferedOutputStream(Outputstream out)
BufferedOutputStream(Outputstream out,int size)
Outputstream:字节输出流
size缓存区大小
使用步骤
1.创建字节输出流
2.创建缓存流对象
3.调用write方法写数据
4.释放资源

import java.io.*;

public class demo7{


    public static void main(String[] args) throws IOException {
        //1.创建字节输出流
        FileOutputStream fs=new FileOutputStream(".//f.txt");
        //2.创建缓存流对象
       BufferedOutputStream bos=new BufferedOutputStream(fs);
       //3.调用write方法写数据
       bos.write("松哥666".getBytes());
        //4.释放资源
        bos.close();

}

}

字节输入缓存流

构造方法：
BufferedInputStream(Inputstream In)
BufferedInputStream(Inputstream In,int size)
Inputstream:字节输出流
size缓存区大小
1.创建字节输入流
2.创建缓存流对象
3.调用read方法读数据
4.释放资源

import java.io.*;

public class demo7{


    public static void main(String[] args) throws IOException {
        //1.创建字节输出流
        FileInputStream fis=new FileInputStream(".//f.txt");
        //2.创建缓存流对象
       BufferedInputStream bis=new BufferedInputStream(fis);
        //3.调用read方法读数据
        byte[] bytes=new byte[1024];
       int len=0;
       while((len= bis.read(bytes))!=-1)
       {
           System.out.println(new String(bytes,0,len));
       }
        //4.释放资源
        bis.close();

}
}

字符输出缓冲流

构造方法：
BufferedWriter(Writer out)
BufferedWriter(Writer out,int size)
Outputstream:字节输出流
size缓存区大小
void newline()行的分隔符
使用步骤
1.创建字符输出流，创建缓冲流对象
2.调用write方法写数据
3.刷新缓存区
4.释放资源

import java.io.*;

public class demo7{


    public static void main(String[] args) throws IOException {
        //1.创建字节输出流
        FileWriter fw=new FileWriter(".//f.txt");
        //2.创建缓存流对象
       BufferedWriter bw=new BufferedWriter(fw);
        //3.调用read方法读数据
        for (int i = 0; i < 10; i++) {
                bw.write("松哥666");
                bw.newLine();
        }
        //4.释放资源
        bw.flush();
        bw.close();

}

}

字符缓冲输入流

构造方法：
BufferedReader(Reader out)
BufferedReader(Reader out,int size)
Reader:字节输入流
size缓存区大小
void readLine()行的分隔符
使用步骤
1.创建字符输入流，创建缓冲流对象
2.调用read方法写数据
3.刷新缓存区
4.释放资源

import javax.annotation.processing.Filer;
import java.io.*;

public class demo7{


    public static void main(String[] args) throws IOException {
        //1.创建字节输出流
        FileReader fr=new FileReader(".//f.txt");
        //2.创建缓存流对象
       BufferedReader br=new BufferedReader(fr);
        //3.调用read方法读数据
        String line;
        while ((line=br.readLine())!=null)
        {
            System.out.println(line);
        }
        //4.释放资源
        br.close();
}

}

demo对文本排序

1.创建一个HashMap集合，存 序号-文本
2.创建字符缓冲输入流，字符缓冲输出流
3.字符缓冲输入流读取每行文本
4.把文本进行切割-properties集
5.切割好的排序
6.获得每个键值对遍历集合
7.把键值对拼接为文本
8.字符缓冲输出流输出到页面
9.释放资源

import javax.annotation.processing.Filer;
import java.io.*;
import java.util.HashMap;

public class demo7{


    public static void main(String[] args) throws IOException {

        //1.创建hashmap
        HashMap<String,String>map=new HashMap<>();

        //2.创建字节输出流
      FileReader fr=new FileReader(".//f.txt");
      BufferedReader br=new BufferedReader(fr);
      FileWriter fw=new FileWriter(".//f.txt");
      BufferedWriter bw=new BufferedWriter(fw);
        //3.字符缓冲输入流读取每行文本
        String line;
        while ((line=br.readLine())!=null)
        {
            //4.把文本进行切割-properties集
            String []arr=line.split("\\.");
            //5.切割好的排序
           map.put(arr[0],arr[1]);
        }

        //6.获得每个键值对遍历集合
        for (String key:map.keySet()
             ) {
            String value=map.get(key);
           // 7.把键值对拼接为文本
            line=key+"."+value;
            //8.字符缓冲输出流输出到页面
            bw.write(line);
            bw.newLine();
        }

        //4.释放资源
        br.close();
        bw.close();
}

}

转换流

可以查询指定码表
原因：FileReader只能读取utf-8不能读取gbk码表

在这里插入图片描述

OutputStreamWriter
OutputStreamWriter(OutputStream out) //默认编码
OutputStreamWriter(OutputStream out，String charsetname) //指定编码

InputStreamReader
InputStreamReader(InputStream In) //默认编码
InputStreamReader(InputStream In，String charsetname) //指定编码

转码demo
1.创建InputStreamReader对象传入GBK
2.创建OutputStreamWriter对象UTF-8
3.InputStreamReader对象读取文件
4.OutputStreamWriter对象写入文件
5.释放资源

import java.io.*;

public class demo8 {

    public static void main(String[] args) throws IOException {

        InputStreamReader isr=new InputStreamReader(new FileInputStream(".//g.txt"),"GBK");
        OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream(".//h.txt"),"Utf-8");
   int len=0;
   while ((len=isr.read())!=-1)
   {
       osw.write(len);
   }
   osw.close();
   isr.close();

    }
}

序列化流

把对象以流的方式写入硬盘
类object要实现标记行接口 Serializable
在这里插入图片描述
ObjectOutputStream流
步骤：
//1.创建序列流
//2.用writeobject方法
//3.释放资源


public class person  implements Serializable {
    private String name;
    private int age;

    public person() {
    }

    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;
    }
}


import java.io.*;

public class demo8 {

    public static void main(String[] args) throws IOException {
       //1.创建序列流
        ObjectOutputStream  oos =new ObjectOutputStream(new FileOutputStream(".//k.txt"));
       //2.用writeobject方法
        oos.writeObject(new person("松哥",18));
        //3.释放资源
        oos.close();

    }
}

ObjectInputStream流
反序列的前提
1.类必须实现 Serializable接口
2.必须存在对应的class文件
步骤：
//1.创建序列流
//2.用readobject方法
//3.释放资源
//4.打印对象

import java.io.*;

public class demo8 {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
       //1.创建序列流
        ObjectInputStream  ois =new ObjectInputStream(new FileInputStream(".//k.txt"));
       //2.用readobject方法
        Object o=ois.readObject();
        //3.释放资源
        ois.close();
        //打印对象
        System.out.println(o);
        person p=(person)o;
        System.out.println(p.getName()+p.getAge());

    }
}

瞬态关键字

static ：静态 --不能被序列化的(不能被修改，写入的）
transient: 瞬态关键字 --也是不能被序列化的(不能被修改，写入的）

不爱跑步的肥狗
关注
专栏目录
Java IO流（超详细！）
一只小菜鸡
05-07 6万+
一、什么是IO流 I : Input O : Output 通过IO可以完成硬盘文件的读和写。 二、IO流的分类 按照 流的方向 进行分类： 以内存作为参照物： 往内存中去：叫做输入(Input)。或者叫做读(Read)。 从内存中出来：叫做输出(Output)。或者叫做写(Write)。 按照 读取数据方式 不同进行分类： 按照 字节 的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。 这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文
Java-Io流，练习
07-06
Java的IO流是Java编程语言中的重要组成部分，它主要用于数据的输入和输出操作。在Java中，IO流被设计为处理任何类型的数据，包括字符、字节甚至对象。本练习旨在帮助初学者理解和掌握Java IO流的基础知识。 一、IO...
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
java IO流
D大调奏鸣曲_第七序章_de博客
11-11 8万+
目录 序 一、IO流开篇 1、概念 2、流的分类 3、IO流的作用 4、IO流的使用场景 二、字节流 1、字节流抽象基类 2、字节流写数据 （1）基本步骤 （2）三种方式 （3）两个问题 （4）异常处理 3、字节缓冲流 （1）基本分类&概述 （2）构造方法 （3）代码演示 三、字符流 1、概念 2、分类 （1）字符流体系图 （2）字符输入流（Reader） （3）字符输出流（Writer） 3、字符缓冲流 （1）概念 （2）构造方法 （3）...
javaIO流详解
weixin_46676497的博客
01-27 2853
java常用io流介绍
io流
qq_40977337的博客
05-09 3157
IO流 java.io包 1.什么是流？ io流就是java中运输数据的一种载体 它能够把数据从一个地方运输到另一个地方 2.流的分类 a 根据流运输数据的方向<以内存为参考物> 输入流 输出流 b 根据数据传输时转换的类型 字节流 byte 字符流 char ...
Java中的IO流-最全最基础的IO流概述和简介
是程序喵呀
08-23 2651
Java中的IO流是用于处理数据输入和输出的核心机制。通过应用IO流可以使Java程序能够与外部世界（如磁盘文件、网络、硬件设备等）进行数据交互。IO流的全称为输入/输出流（Input/Output Stream），它是Java编程语言中用于数据传输的一种抽象模型。流可以被想象为数据的连续流动，就像水通过管道一样，数据通过流从一个地方流向另一个地方。文件流是用来连接我们的程序与文件之间的"管道",用来读写文件中的数据。
Java io流 详解
m0_68987535的博客
06-11 4833
"IO流"（Input/Output stream）指的是Java中用于处理输入输出（I/O）数据的机制。在Java中，所有的输入和输出都被抽象为“流”对象，并通过输入流读取数据、输出流写入数据。Java的I/O包提供了丰富的类和方法来支持不同类型的流，输入流和输出流之间可以自由地进行转换。它们分别主要包括字节流和字符流两种类型。其中，字节流是操作二进制数据的流，可以处理任何类型的数据，常见的例如InputStream和OutputStream；
JavaIO流详解
itqcyyl的博客
08-09 2万+
转载：https://www.cnblogs.com/LittleHann/p/3678685.html Java输入、输入、IO流 类层次关系梳理 本文主要关注在Java编程中涉及到的IO相关的类库、方法。以及对各个层次(抽线、接口继承)的流之间的关系进行梳理   相关学习资料 http://baike.baidu.com/view/1007958.htm?noadapt=1 h...
IO流的分类
小白学编程
05-11 1万+
IO流的分类可以分为以下三种： 第一种：输入流和输出流 按照流的流向来分，可以分为输入流和输出流。输入，输出都是从程序运行所在内存的角度来划分的。 输入流：只能从中读取数据，而不能向其写入数据，由InputStream和Reader作为基类。 输出流：只能向其写入数据，而不能从中读取数据。由OutputStream和Writer作为基类 第二种：字节流和字符流 字节流和字符流的用法几乎完全一样，区...
IO流概述
m0_70905607的博客
07-16 3068
Ooutput，是内存程序的数据从内存到写出到硬盘文件的过程，称之输出、负责写。Iinput，是数据从硬盘文件读入到内存的过程，称之为输入，负责读。以内存为基准，把磁盘文件中的数据以字符的形式读取到内存中。定义一个与文件一样大的数组，一次性读取完文件的全部字节。读取中文字符不会出现乱码（如果文件和代码的编码一致）（3）文件字符输入流（FileReader）的作用。（4）直接把文件数据全部读取到一个字节数组怎样？字节流适合做一切文件数据的拷贝（音视频、文本）（5）字节输出流如何实现写出去的数据能换行？...
Java中文件IO流.pdf
07-11
Java 中文件 IO 流 Java 中文件 IO 流是指 Java 语言中对文件的输入输出操作，通过定义文件流来实现文件的读写操作。文件流是指在程序中用于文件输入输出的对象， Java 中提供了多种文件流类型，包括 InputStream ...
JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar
11-30
2、常用21个IO流：FileWriter、FileReader、CharArrayReader、CharArrayWriter、CharSequence、OutputStreamWriter、FileOutputStream、InputStreamReader、PrintWriter、BufferedReader、InputStream、...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 717
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
spring循环依赖解决方式
qq_36400213的博客
11-04 870
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
【Java知识】Java基础-对象排序的实现
最新发布
wendao76的专栏
11-04 330
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
信息学科平台系统开发：基于Spring Boot的最佳实践
2401_85761762的博客
11-02 1037
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。本系统具有易操作、易管理、交互性好的特点，在操作上是非常简单的，因此在操作上具有很高的可行性。（2）该完整内容全面，管理方便可以及时的全面的处理各种错误，异常，这样避免了很多因用户的马虎操作而出现的失误，其操作方便，用户界面友好，能够上网的人都可以很好的进行操作。
深入理解Java IO流
"深入理解Java的IO流系统，包括字节流和字符流的各类实现" 在Java编程中，IO（Input/Output）流是处理数据输入和输出的关键机制。Java的IO流系统提供了丰富的类库，使开发者能够方便地进行文件读写、网络通信以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值