黑马程序员第五篇 Java I/O (foundation, completed)

最新推荐文章于 2020-07-17 09:11:18 发布

Das20pct

最新推荐文章于 2020-07-17 09:11:18 发布

阅读量535

点赞数

分类专栏：精选摘录

本文链接：https://blog.csdn.net/Das20pct/article/details/47254937

版权

精选摘录专栏收录该内容

2 篇文章 0 订阅

订阅专栏

——- android培训、java培训、期待与您交流！ ———-

1 I/O流简介
什么是I/O流
节点流与处理流
字节流与字符流
抽象基类
1. InputStream类
2. OutputStream类
3. Reader类
4. Writer类

2 使用流进行文件操作
2.1 使用File类进行文件与目录操作
2.2 FileInputStream类与 FileOuputStream类
2.3 FileReader类与 FileWriter类

————————————————————————————

Java中的流，可以从不同的角度进行分类。

这里写图片描述

definition

Java中的数据流分为两种，一种是字节流，另一种是字符流。这两种流主要由4个抽象类来表示，分别为InputStream， OutputSteam， Reader， Writer，输入输出各两种。其中InputStream和OutputStream表示字节流，Reader和Writer表示字符流，其他各种各样的流均是继承这4个抽象类而来

按照数：输入流和输出流。
按照处理数据单位不同可以分为：字节流和字符流。
按照实现功能不同可以分为：节点流和处理流。

字节流与字符流

字节流：一次读入或读出是8位二进制。例如声音,图像等数据

字符流：一次读入或读出是16位二进制。例如文本文件，网络中发送的文本信息。

字节流和字符流的原理是相同的，只不过处理的单位不同而已。后缀是Stream是字节流，而后缀是Reader，Writer是字符流。

节点流（Node Streams) 与处理流 (Processing Streams)

节点流一般用于直接从指定的位置进行读/写操作，例如磁盘文件，内存区域，网络连接等，其中一般只提供了一些基本的读写操作方法，功能比较单一。

节点流：直接与数据源相连，读入或读出。
这里写图片描述

直接使用节点流，读写不方便，为了更快的读写文件，才有了处理流。

=====分割线=====

处理流往往是用于对其他输入/输出流进行封装，对内容进行过滤处理，其中一般提供了一些功能比较强大的读写方法。

处理流：与节点流一块使用，在节点流的基础上，再套接一层，套接在节点流上的就是处理流。

实际应用中

通常是将节点流与处理流二者结合起来使用。节点流直接与指定的源或目标相连，例如某个文件，某个网络连接等。
而处理流则对节点流或其他处理流进一步进行封装，提供更丰富的输入/输出操作能力，例如缓冲，按字符串行读写等

这里写图片描述

Jdk提供的流继承了四大类：InputStream(字节输入流)，OutputStream（字节输出流），Reader（字符输入流），Writer（字符输出流）。

Java中常用的I/O流

这里写图片描述

简单介绍其上图：
对文件进行操作：

FileInputStream（字节输入流）
FileOutputStream（字节输出流）
FileReader（字符输入流）
FileWriter（字符输出流）

对管道进行操作：

PipedInputStream（字节输入流）
PipedOutStream（字节输出流）
PipedReader（字符输入流）
PipedWriter（字符输出流）

PipedInputStream的一个实例要和PipedOutputStream的一个实例共同使用，共同完成管道的读取写入操作。主要用于线程操作。
字节/字符数组：ByteArrayInputStream，ByteArrayOutputStream，CharArrayReader，CharArrayWriter是在内存中开辟了一个字节或字符数组。

Buffered缓冲流：BufferedInputStream，BufferedOutputStream，BufferedReader,BufferedWriter,是带缓冲区的处理流，缓冲区的作用的主要目的是：避免每次和硬盘打交道，提高数据访问的效率。

转化流：InputStreamReader/OutputStreamWriter，把字节转化成字符。
数据流：DataInputStream，DataOutputStream。

因为平时若是我们输出一个8个字节的long类型或4个字节的float类型，那怎么办呢？可以一个字节一个字节输出，也可以把转换成字符串输出，但是这样转换费时间，若是直接输出该多好啊，因此这个数据流就解决了我们输出数据类型的困难。数据流可以直接输出float类型或long类型，提高了数据读写的效率。

打印流：printStream，printWriter，一般是打印到控制台，可以进行控制打印的地方。
对象流：ObjectInputStream，ObjectOutputStream，把封装的对象直接输出，而不是一个个在转换成字符串再输出。
序列化流：SequenceInputStream。
对象序列化：把对象直接转换成二进制，写入介质中。
使用对象流需要实现Serializable接口，否则会报错。而若用transient关键字修饰成员变量，不写入该成员变量，若是引用类型的成员变量为null，值类型的成员变量为0.

2 使用流进行文件操作

Java中专门提供了一个表示目录与文件的类—–java.io.File, 通过其可以获取文件，目录的信息，对文件，目录进行管理。

public File(String panthname)
public File(String parent, String child)
public File(File parent, String child)

下面代码是一个创建文件对象的程序

import java.io.*
public class Liu
{
    public static void main(String[] args)
    {
        File f1 = new File("C:\\");

        //创建file文件
        File f2 = new File("C:\\a.txt");
        if(f1.isDirectory())
        {
            System.out.println("f1对象表示的是目录");
        }else if(f1.isFile())
        {
            System.out.println("f1对象表示的是文件");
        }



        if(f2.isDirectory())
        {
            System.out.println("f2对象表示的是目录");
        }else if(f2.isFile())
        {
            System.out.println("f2对象表示的是文件");
        }


    }
}



输出结果:

打印   f1对象表示的是目录
      f2对象表示的是文件

如下是使用exists方法判断文件或牧师是否存在的程序

import java.io.*;
public class Liu
{
    public static void main(String[] args)
    {
        File f1 = new File("C:\\b.txt");
        if(!f1.exists())
        {

            try
            {
                System.out.println("文件不存在，创建该文件");
                f1.createNewFile();
                System.out.println("创建成功！");
            }
            catch(IOException e)
            {
                e.printStackTrace();
            }

        }

        if(f1.isDirectory())
        {
            System.out.println("f2对象表示的是目录，目录名为: " + f1.getName());
        }else if(f1.isFile()){
            System.out.println("f2对象表示的是文件，文件名为: " + f1.getName());
            System.out.println("路径为: "+ f1.getPath());
        }

    }
}


运行结果:

第一次结果

        文件不存在，创建该文件
        创建成功！
        f2对象表示的是文件，文件名为b.text
        路径为：C：\b.txt


第二次结果
        f2对象表示的是文件，文件名为b.text
        路径为：C：\b.txt

2.2 FileInputStream类与FileOutputStream类

FileInputStream类是InputStream的子类： 主要用于从文件系统中的某个文件中获取输入字节。
FileOutputStream类是OutputStream的子类： 主要用于将数据以字节流写入目标文件的输出流。

每次使用完流对象之后，都必须要调用close()方法进行显示的关闭操作

以下代码演示使用FileInputStream类的程序

一个使用FileInputStream类的程序

import java.io.*;
public class FileIS
{
    public static void main(String[] args)
    {
        //创建File对象
        File f = new File("c:\\c.txt");

        //创建FileInputStream对象
        FileInputStream fis = new FileInputStream(f);


        char ch;
        for(int i=0; i<f.length(); i++)
        {
            //读取内容
            ch=(char)fis.read();
            //显示
            System.out.print(ch);
        }

        //关闭
        fis.close();
    }
}

输出结果:

asdf
qwer
zxcv

一个使用FileOutputStream类的程序

import java.io.*;
public class FileOS
{
    public static void main(String[] args)throws IOException
    {
        //创建两个File对象
        File f = new File("c:\\d.txt");
        //创建FileOnputStream对象
        FileOutputStream fos = new FileOutputStream(f);

        //写入
        for(int i='a'; i<'z'; i++)
        {
            fos.write(i);
        }

        fos.close();

    }
}


输出结果

C盘中有一个d.txt

abcdefg.......z

Tips
FileInputStream类和FileOutputStream类经常一起配合使用，最经常的使用就是读取一个文件中的信息，然后将信息复制到另一个文件中

一个FileInputStream类和FileOutputStream类结合使用的程序

import java.io.*;
public class FisFos
{
    public static void main(String[] args)throws IOException
    {
        //创建两个File对象
        File f1=new File("c:\\1.txt");
        File f2=new File("c:\\2.txt");

        //创建FileInputStream对象
        FileInputStream fis = new FileInputStream(f1);
        //创建FileOutputStream对象
        FileOutputStream fos = new FileOutputStream(f2);

        byte[] b = new byte[(int)f1.length()];
        //读取1文件
        fis.read(b);
        //写入2文件
        for(int i=0; i<f1.length(); i++)
        {
            fos.write(b[i]);
        }
        fix.close();
        fox.close();
    }
}


代码解析：


在本程序中首先创建了两个File对象，要对应的指定的位置创建这两个文件。其
中f1是一个被读取文件，f2是一个要写入的文件。该程序看起来功能复杂，其实
只是简单地从一个文件读取信息，然后将信息写入到另一个文件。

2.3 FileReader类与FileWriter类


import java.io.*;
public class Liu6 
{
    public static void main(String[] args) 
    {
        File f = new File("C://aaa.txt");       //创建一个File类对象
        String str = "FileReader and FileWriter";
        char[] buffer = new char[str.length()];//创建一个char数组，初始化大小为str字符串对象的长度
        buffer = str.toCharArray();
        try 
        {
            if (!f.exists()) 
            {
                f.createNewFile();
            }
            FileWriter writer = new FileWriter(f);
            writer.write(buffer);           //输出整个字符数组到文件
            writer.close();
            //从文件中读取数据
            FileReader reader1 = new FileReader(f); //从文件头读取所有数据
            char[] result1 = new char[20];
            int i1 = reader1.read(result1);
            System.out.println("读取文件中所有字符，字符数为:" + i1);
            System.out.println(result1);
            FileReader reader4 = new FileReader(f);
            char[] result4 = new char[100];     //从文件中逐个读取字符,直到文件末尾,返回-1
            int i = 0;
            System.out.println("从文件中逐个读取字符:");
            while (i != -1) 
            {
                i = reader4.read();
                if (i != -1) 
                {
                    System.out.print(String.valueOf(Character.toChars(i)) + ";");
                }
            }
        } 
        catch (IOException e) 
        {
            e.printStackTrace();
        }
    }
}





        }
        catch(IOException e)
        {
            e.printStackTrace();
        }
    }
}

输出结果:

读取文件中所有字符，字符数为：20
FileReader and FileW
从文件中逐个读取字符：
F;i;l;e;R;e;a;d;e;r;  ;a;n;d; ;F;i;l;e