IO流

Posted 2023-05-13 lengbo

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了IO流相关的知识，希望对你有一定的参考价值。

一，什么是IO？

　　　　I：Input

　　　　O：Output

是内存与硬盘之间的关系；

二，IO流如何分类呢？

　　有两种分法：

　　　　　　第一种：按照流的方向进行分类：

　　　　　　　　　　去内存里，叫做输入，（Input），或者叫做\'读\'；

　　　　　　　　　　从内存中出来，叫做输出（Output），也可以叫做‘写’；

　　　　　　第二种：按照读取数据方式不同进行分类；

　　　　　　　　（1）按照字节的方式读取数据，一次读取一个字节byte（==8个二进制），这种流是万能的，图像，声音，文本文件都可以读取。

　　　　　　　　　　Eg：

　　　　　　　　　　　　“冷薄的KD”

　　　　　　　　　　　　第一次读取半个‘冷’，中文占2个字节

　　　　　　　　　　　　K占一个字节

　　　　　　　　（2）　按照字符的方式读取数据，一次读取一个字符，这种流为了方便读取文本TXT，而存在的，除了TXT格式以外的都不能读取，包括Word文档。

　　　　　　　　　　Eg：

　　　　　　　　　　　　“冷薄的KD”

　　　　　　　　　　　　第一次读取的就是‘冷’字符；

　　　　　　　　　　　　第二次读取的就是‘薄’字符；

总结：

　　　　IO流分为：

　　　　　　　　输入流、输出流；

　　　　　　　　字节流、字符流；

’

　　　　　　　　需要掌握：JAVA中的IO流有哪些？分别有什么特点？存在的意义是什么？

三，JAVA IO流四大家族：

　　　　　　　　leader：(都是抽象类 abstract class）

　　　　　　　　　　　　java.io.Inputstream 字节输入流

　　　　　　　　　　　 java.io.outputstream 字节输出流

　　　　　　　　　　　　java.io.Reader 字符输入流

　　　　　　　　　　　　java.io.Writer 字符输出流

Close（）和flush（）

　　　　　　　　所有流都实现了 java.io.Closeable 接口，都是可关闭的，都有close（）方法

　　　　　　　　　　　　流是内存与硬盘之间的管道，用完一定要关闭，否则会占用资源！！

　　　　　　　　所有输出流都实现了java.io.Flushable接口，都是可刷新的，都有flush方法

　　　　　　　　　　　　养成输出流输出完毕后使用flush的好习惯，flush意味着将管道里所有数据强行输出完（清空管道）

　　　　　　　　　　　　刷新的作用就是清空管道

　　　　　　　　　　　　PS：只要是stream结尾的都是字节流，Reader或Writer结尾是字符流

　　　　　　　　　　　　　　如果没有flush（）可能会导致数据丢失

四：16个java.io需要掌握的流

4.1：java.io.FileInputStream（文档输入流）

FileInputStream fil=new FileInputStream("D:\\\\java\\\\javatext\\\\out\\\\production\\\\javatext\\\\text.txt");//创建一个输入流对象（对象是文本）

　　需掌握方法：

　　　　fil.read();//读取一个字节，每次使用该方法时会自动跳到下一个字节。

　　　　fil.close（）；//关闭流，一般在finally使用；

　　　　fil.available(); //查看剩下多少字节没读可以与byte数组连用：

　　　　　　　　　　　　　　byte [ ] bytes =new byte[fil.available()];

　　　　但是不适合太大文件因为byte数组有限，并且很难在堆中找到连续的大空间　　

　　　　fil.skip（）；//跳过几个字节不读取

package IOtext;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputstreamtext02 
    public static void main(String[] args) 
        FileInputStream fil=null;
        try 
            fil=new FileInputStream("D:\\\\java\\\\javatext\\\\out\\\\production\\\\javatext\\\\text.txt");
            byte []bytes=new byte[4];
            int a=0;
            while ((a=fil.read(bytes))!=-1)//改进，使用byte数组来输入字节，效率更高效。
            
                //这里bytes读了多少个就转了多少个字节
                System.out.println(new String(bytes,0,a));
            
         catch (IOException e) 
            throw new RuntimeException(e);
        finally 
            try 
                if (fil != null) 
                    fil.close();
                
             catch (IOException e) 
                throw new RuntimeException(e);

　　4.2 java.io.FileOutputstream(文档输出流）//o流与I流不同的点，try，写后最后要加个fil.flush（）；

　　创建对象　　　　FileOutputStream　　file =new FileOutputStream("myfile.txt",true);//append是追加的意思，不会将文档里的内容覆盖

　　　　需要掌握什么方法？

　　　　fil.write()//录入一个字节，同样，支持byte数组录入

package IOtext;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputstreamtext01 
    public static void main(String[] args) 
        FileOutputStream fileOutputStream=null;
        try 
            fileOutputStream=new FileOutputStream("myfile.txt",true);//append是追加的意思，不会将文档里的内容覆盖
            String a="今天天气真好！！";
            byte[]b=a.getBytes();//将String转成byte数组
            fileOutputStream.write(b);
            fileOutputStream.flush();
         catch (IOException e) 
            throw new RuntimeException(e);
        finally 
            try 
                if (fileOutputStream != null) 
                    fileOutputStream.close();
                
             catch (IOException e) 
                throw new RuntimeException(e);

　　文档拷贝（大体内容差不多，I流输入，O流输出，while循环拷贝）

　　字节形式：IO

package IOtext;

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

public class FileOutputstreamtext02 
    public static void main(String[] args) 
        FileOutputStream fol=null;
        FileInputStream fil=null;
        try 

            fil=new FileInputStream("C:\\\\Users\\\\lengbo\\\\Desktop\\\\text.txt");
            fol=new FileOutputStream("D:\\\\text.txt",true);
            byte []a=new byte[1024*1024];
            int reread=0;
            
            while ((reread=fil.read(a))!=-1)//循环拷贝
            
                fol.write(a,0,reread);

            
            fil.read(a);
            fol.flush();
         catch (IOException e) 
            throw new RuntimeException(e);
        finally 
            if (fil != null) 
                try 
                    fil.close();
                 catch (IOException e) 
                    throw new RuntimeException(e);
                
            
            if (fol != null) 
                try 
                    fol.close();
                 catch (IOException e) 
                    throw new RuntimeException(e);

　　　　字符形式：Reader与Writer

package IOtext;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileWritertext02 
    public static void main(String[] args) 
        FileReader in=null;
        FileWriter out=null;
        try 
            in=new FileReader("text.txt");
            out=new FileWriter("C:\\\\text.txt");//加复制的文件名！！！
            int arrtemp=0;
            char []a=new char[4];
            while ((arrtemp=in.read(a))!=-1)
            
                out.write(a,0,arrtemp);
            
            out.flush();
         catch (IOException e) 
            throw new RuntimeException(e);
        finally 
            if (in != null) 
                try 
                    in.close();
                 catch (IOException e) 
                    throw new RuntimeException(e);
                
            
            if (out != null) 
                try 
                    out.close();
                 catch (IOException e) 
                    throw new RuntimeException(e);

4.3 　java.io.FileReader(文档字符输入流）//Reader和Writer只能读取txt，其他的不行！！

　　　　与Input差不多，唯一区别就是，字节需要的输入数组是byte，而字符用的是char！可能更快一点吧~

package IOtext;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileReadertext01 
    public static void main(String[] args) 
        FileReader fileReader=null;
        try 
            fileReader=new FileReader("text.txt");
            char []a=new char[4];//char[]!!!!!区别
            int reread=0;
            while ((reread=fileReader.read(a))!=-1)
            
                System.out.println(new String(a,0,reread));
            

         catch (IOException e) 
            throw new RuntimeException(e);
        finally 
            try 
                if (fileReader != null) 
                    fileReader.close();
                
             catch (IOException e) 
                throw new RuntimeException(e);

　　　　4.4 java.io.FileWriter（文档输出流）//同4.3Reader

　　　　　　没啥好说的，fil.Writer（）；可以在里面写字符串“xxx”；

---------------------------------File文档就到这里了----------总结-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

　　file类型，无论是Intput还是Output，无论是Reader还是Writer，都是固定格式，只是本质上有些区别！！一个是字节输入，一个是字符输入，在拷贝文件的时候都需要byte数组，char数组，这样效率比循环一个一个的更高!

　　　　能用记事本打开编辑的，都是.txt文件

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

　　　　4.5 java.io.BufferedReader(缓冲流）//不需要定义数组了，只需要一个reader；

　　　　　　BufferedReader b=new BufferedReader(reader);

　　　　　　4.5.1 节点流和包装流（又叫处理流）

　　　　　　节点流就是在流里面套的流；

　　　　　　包装流指节点流外边套的流；

　　　　　　需掌握方法：

　　　　　　　　b.readline();//读取一行，可以转成字符串；

package IOtext;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReadertext01 
    public static void main(String[] args) 
        FileReader reader= null;
        try 
            reader = new FileReader("text.txt");
            BufferedReader b=new BufferedReader(reader);
            String a=null;
        while ((a=b.readLine())!=null)
        
            System.out.println(a);
        

         catch (IOException e) 
            throw new RuntimeException(e);
        finally 
            try 
                if (reader != null) //关最外边的流！！这写错了
                    reader.close();
                
             catch (IOException e) 
                throw new RuntimeException(e);

4.6 BufferInputStream和BufferOutputStream

　　与Reader和Writer一样；见上

4.8InputStreamReader与OutputStreamWriter（转换流）//将字节型转为字符型

　　　　　　可与Buffer连用，父类是Reader/Writer；

InputStreamReader：

　　　　以下代码抛出异常，并不是不需要写！！！！

package IOtext
import java.io.*;
public class BufferedReaderText02 
    public static void main(String[] args) throws Exception

        FileInputStream reader=null;
        BufferedReader reader1=new BufferedReader(new InputStreamReader(new FileInputStream("text.txt")));//套娃
        String a=null;
        while ((a=reader1.readLine())!=null)
        
            System.out.println(a);
        
        reader1.close();

OutputStreamWriter:

　　　　以下代码抛出异常，并不是不需要写！！！！

package IOtext;

import java.io.*;

public class BufferWriterText01 
    public static void main(String[] args) throws Exception

        BufferedWriter writer=new BufferedWriter((new OutputStreamWriter(new FileOutputStream("text.txt",true))));
        writer.write("加油！！！！！！！！！！");
        writer.close();

4.9 java.io.DataInputStream（数据字节输入流）//数据专属流不用DataInputStream读无法打开

用DataInputStream输入的只能用DataOutputStream输出，不然看的是乱码，并且输入的基本类型要与输入时的顺序一致。

package IOtext;
import java.io.*;
public class DataInputStreamText01 
    public static void main(String[] args) throws  Exception
        DataInputStream d=new DataInputStream(new FileInputStream("OutText.txt"));
        int a=d.readInt();
        float f=d.readFloat();
        System.out.println(a);
        System.out.println(f);

Out

package IOtext;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class DataOutputStreamText01 
    public static void main(String[] args) throws Exception
        DataOutputStream d1=new DataOutputStream(new FileOutputStream("OutText.txt"));
        int a=10;
        float f=3.14F;
        d1.writeInt(a);
        d1.writeFloat(f);
        d1.flush();
        d1.close();

　　4.10 java.io.PrintStream(标准输出流)//梦回开始的地方！

package IOtext;

import java.io.PrintStream;

public class PrintStreamText01 
    public static void main(String[] args) 
        PrintStream p=new PrintStream(System.out);
        p.println("我喜欢下雨");

PrintStream p=new PrintStream(new PrintStream("text.txt"));//更改方向

package IOtext;
import java.io.PrintStream;
public class PrintStreamText01 
    public static void main(String[] args) throws Exception
        //更改输出流方向，输出流不再指向控制台，指向text文件
        PrintStream p=new PrintStream(new PrintStream("text.txt"));
        p.println("我喜欢下雨");

*******************************************************************************************************************************

插入：

　　　　回顾：

　　　　　　　　System.gc();//垃圾处理器
　　　　　　　　System.exit(0);//退出
　　　　　　　　System.currentTimeMillis();//打印1980-现在的毫秒数
　　　　　　　　System.arraycopy();//数组拷贝

*******************************************************************************************************************************

日志文件怎么写？

package IOtext;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Logger  
    public static void log(String a)
        try 
            //创建标准输出流
            PrintStream p=new PrintStream(new FileOutputStream("loge.txt",true));
            //.setOut是更改输出流方向，默认在控制台上
            System.setOut(p);//
            //创建日期类
            Date nowTime=new Date();
            //定义日期格式
            SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-E-dd HH:mm:ss SSS");
            //用字符串接受
            String time=sdf.format(nowTime);
            //输出格式
            System.out.println(time+":"+a);
         catch (FileNotFoundException e) 
            throw new RuntimeException(e);

　随便整个类　new试一下就OK

package IOtext;

public class Logetext01 
    public static void main(String[] args) 
        Logger.log("最后执行时间");

loge.TXT；(执行了好几遍的结果）

//建议去看看日期格式这么写的，见日期随笔

　　　5 File类

　　　　5.1File和四大家族没有关系，所以File不能读和写

　　　　5.2File对象是什么？

　　　　　　　　文件和目录路径名的抽象表示形式。

　　　　　　　　D:\\BcutBilibili\\素材//这是就是一个File对象

　　　　5.3 File中需要掌握的常用方法：

　　　　　　　　File f=new File（）；

　　　　　　　　f.getName；//获取文件名

　　　　　　　　f.isDirectory;//判断是否是目录

　　　　　　　　f.isFile；//判断是否是文件

　　　　【long】f.lastModified（）；//1980-now的毫秒数

　　　　　　　 f.exists();//判断是否存在该文件，布尔类型，默认false。

 　　　　　　　f.createNewFile();//以文件的形式创建

　　　　　　　 f.mkdir();//以目录的形式创建

 　　　　　　　f.mkdirs();//以多重目录的形式创建

 　　　　　　　String parentPath=f.getParent();//上一级，父
　　　　　　　File f1=f.getAbsoluteFile();//fill型的绝对路径

　　　　　　　 f.getAbsolutePath());//String
   　　　　　　 f.getAbsoluteFile());//File
　　　　　　　 f.lenth();//长度

　　　　　　　　　　File [ ] f=f.listFiles();//获取当前目录所有子文件

　　　　　　　　　　for(File a : filessoutf.getName;//foreach

Work

import java.io.*;

public class FileclassWork01 
    public static void main(String[] args) 
        File a = new File("D:\\\\a\\\\b\\\\c\\\\d");
        File b = new File("C:\\\\");
        copyDir(a, b);
    

    private static void copyDir(File a, File b) 
        if (a.isFile()) 

            FileInputStream in = null;
            FileOutputStream out = null;
            try 
                
                in = new FileInputStream(a);
                String path = (b.getAbsolutePath().endsWith("\\\\") ? b.getAbsolutePath() : b.getAbsolutePath() + "\\\\") + a.getAbsolutePath().substring(3);
                out = new FileOutputStream(path);
                byte[] bytes = new byte[1024 * 1024];
                int temp = 0;
                while ((temp = in.read(bytes)) != -1) 
                    out.write(bytes, 0, temp);
                
                out.flush();


             catch (IOException e) 
                throw new RuntimeException(e);
             finally 
                if (out != null) 
                    try 
                        out.close();
                     catch (IOException e) 
                        throw new RuntimeException(e);
                    
                
                if (in != null) 
                    try 
                        in.close();
                     catch (IOException e) 
                        throw new RuntimeException(e);
                    
                
            

            return;
        

        File[] files = a.listFiles();
        for (File f : files
        ) 
            if (f.isDirectory()) 
                String a1 = f.getAbsolutePath();
                String b1 = (b.getAbsolutePath().endsWith("\\\\") ? b.getAbsolutePath() : b.getAbsolutePath() + "\\\\") + a1.substring(3);
                File file1 = new File(b1);
                if (!file1.exists()) 
                    file1.mkdirs();
                

            
            copyDir(f, b);

4.15 序列化与反序列化

什么是序列化？or反序列化？？？？

对象从内存到硬盘文件的过程就叫序列化，因为管道大小有限，它将对象分成一块一块的，就想切豆腐一样，才能放入硬盘中。反之，硬盘到内存的过程就是反序列化

　　Over!

java IO流 IO流概述

1.流的分类
* 1.操作数据单位：字节流、字符流
* 2.数据的流向：输入流、输出流
* 3.流的角色：节点流、处理流

图示：

2.流的体系结构

说明：红框对应的是IO流中的4个抽象基类。
蓝框的流需要大家重点关注。

3.重点说明的几个流结构

4.输入、输出的标准化过程
4.1 输入过程
① 创建File类的对象，指明读取的数据的来源。（要求此文件一定要存在）
② 创建相应的输入流，将File类的对象作为参数，传入流的构造器中
③ 具体的读入过程：
创建相应的byte[] 或 char[]。
④ 关闭流资源
说明：程序中出现的异常需要使用try-catch-finally处理。
4.2 输出过程
① 创建File类的对象，指明写出的数据的位置。（不要求此文件一定要存在）
② 创建相应的输出流，将File类的对象作为参数，传入流的构造器中
③ 具体的写出过程：
write(char[]/byte[] buffer,0,len)
④ 关闭流资源
说明：程序中出现的异常需要使用try-catch-finally处理。

package atguigu.senior.day11.exer;

import org.junit.Test;

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

public class PicTest {

    //图片的加密
    @Test
    public void test1(){
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try{
            fis = new FileInputStream("爱情与友情.jpg");
            fos = new FileOutputStream("爱情与友情secret.jpg");

            byte[] buffer = new byte[20];
            int len;
            while((len = fis.read(buffer))!=-1){
                //正确的
                for (int i = 0; i < len; i++) {
                    buffer[i] = (byte) (buffer[i] ^ 5);
                }
                fos.write(buffer,0,len);
            }

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

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

            }

        }
    }
    @Test
    public void test2(){
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try{
            fis = new FileInputStream("爱情与友情secret.jpg");
            fos = new FileOutputStream("爱情与友情4.jpg");

            byte[] buffer = new byte[20];
            int len;
            while ((len = fis.read(buffer)) != -1) {
                //字节数组进行修改
                //错误的
                //            for(byte b : buffer){
                //                b = (byte) (b ^ 5);
                //            }
                //正确的
                for (int i = 0; i < len; i++) {
                    buffer[i] = (byte) (buffer[i] ^ 5);
                }

                fos.write(buffer, 0, len);
            }

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

            }

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

            }
        }




    }


}

以上是关于IO流的主要内容，如果未能解决你的问题，请参考以下文章

IO流之IO流综述

IO异常--缓冲流--转换流--序列化流（ IO流2 ）