IO流

Posted 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输出,不然看的是乱码,并且输入的基本类型要与输入时的顺序一致。

in

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 )

IO流(序列流)

java中的io流都有哪些

java IO流 IO流概述

IO流