码迷，mamicode.com
首页 > 其他好文 > 详细

IO流

时间：2020-03-21 21:45:31      阅读：66      评论：0      收藏：0      [点我收藏+]

标签：ignore   输入输出流   改进   finally   int   nal   思路   sig   stp   

流的分类

按操作数据单位不同分为：字节流(8 bit)，字符流(16 bit)

按数据流的流向不同分为：输入流，输出流

按流的角色的不同分为：节点流，处理流

技术图片

节点流

FileReader

import org.junit.Test;

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

public class test01 {
    @Test
    public void testFileReader() {
        FileReader fr = null;
        try {
//        1.实例化 File 类对象，指明要操作的文件
            File file = new File("hello.txt");
//        2.提供具体的流
            fr = new FileReader(file);
//        3.数据的读入
//        read():返回读入的一个字符，如果达到文件末尾，返回-1
            int data;
            while((data = fr.read()) != -1){
                System.out.print((char)data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fr != null){
//         4.流的关闭操作
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

使用char数组加速

import org.junit.Test;

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

//对read()操作升级：使用read的重载方法
public class test02 {
    @Test
    public void testFileReader() {
        FileReader fr = null;
        try {
//        1.File类的实例化
            File file = new File("hello.txt");
//        2.FileReader流的实例化
            fr = new FileReader(file);

//        3.读入的操作
//        read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1。
            char[] cbuf = new char[5];
            int len;
            while((len = fr.read(cbuf)) != -1){
                String str = new String(cbuf, 0, len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
//        4.资源关闭
            if(fr != null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

FileWriter

import org.junit.Test;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class test03 {
    /*
    从文件中写出数据到硬盘的文件里
    说明：
    1. File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
    2. File对应的硬盘中的文件如果存在：
        a. FileWriter(file, false) 覆盖掉，不追加
        b. FileWriter(file, true) 追加不覆盖
     */
    @Test
    public void testFileWriter() throws IOException {
//        1.提供File类的对象，指明写出到的文件
        File file = new File("hello1.txt");

//        2.提供FileWriter的对象，用于数据的写出
        FileWriter fw = new FileWriter(file, false);

//        3.写出的操作
        fw.write("I have a dream\n");
        fw.write("you need to have a dream!");

//        4.流资源的关闭
        fw.close();
    }
}

FileReader 和 FileWriter

import org.junit.Test;

import java.io.*;

public class test04 {
    @Test
    public void testFileReaderFileWriter() throws IOException {
//        1.创建File类的对象，指明读入和读出的文件
        File srcFile = new File("hello.txt");
        File destFile = new File("hello2.txt");

//        2.创建输入流和输出流的对象
        FileReader fr = new FileReader(srcFile);
        FileWriter fw = new FileWriter(destFile);

//        3.数据的读入和写入操作
        char[] cbuf = new char[5];
        int len;
        while((len = fr.read(cbuf)) != -1){
            fw.write(cbuf, 0, len);
        }

//        4.关闭流资源
        fw.close();
        fr.close();
    }
}

FileInputStream 和FileOutputStream

import org.junit.Test;

import java.io.*;

public class test05 {
    @Test
    public void testFileInputStream() throws IOException {
//        1.造文件
        File srcFile = new File("hello.jpg");
        File destFile = new File("hello.jpg");

//        2.造流
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);

//        3.读数据
        byte[] buffer = new byte[5];
        int len;
        while((len = fis.read(buffer)) != -1){
            fos.write(buffer, 0, len);
        }

//        4.关闭资源
        fos.close();
        fis.close();
    }
}


缓冲流

BufferedInputStream和BufferedOutputStream

import org.junit.Test;

import java.io.*;

public class test06 {
    @Test
    public void testBufferedInputStreamOutputStream() throws IOException {
//        1.造文件
        File srcFile = new File("hello.jpg");
        File destFile = new File("hello3.jpg");

//        2.造流
//        2.1 造节点流
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(destFile);

//        2.2 造缓冲流
        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

//        3.读数据
        byte[] buffer = new byte[10];
        int len;
        while((len = bis.read(buffer)) != -1){
            bos.write(buffer, 0, len);
        }

//        4.关闭资源
//        要求：先关外层，再关内层
        bos.close();
        bis.close();
//        说明：关闭外层流，内层流会自动关闭，写不写无所谓
        fos.close();
        fis.close();
    }
}

使用readerLine()

import org.junit.Test;

import java.io.*;

public class test07 {
    @Test
    public void testBufferedReaderBufferedWriter() throws IOException {
//        1.造流
        BufferedReader br = new BufferedReader(new FileReader(new File("dbcp.txt")));
        BufferedWriter bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));

//        2.读写操作
//        char[] cbuf = new char[1024];
//        int len;
//        while((len = br.read()) != -1){
//            bw.write(cbuf, 0, len);
//            //bw.flush();
//        }

        String data;
        while((data = br.readLine()) != null){
//            bw.write(data + "\n");// data中不包含换行符
            bw.write(data);
            bw.newLine();// 提供换行操作
        }

//        3.关闭资源
        bw.close();
        br.close();
    }
}


转换流

InputStreamReader

import org.junit.Test;

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

/**
 * 转换流的使用
 * 1.转换流：属于字符流
 * InputStreamReader：将一个字节的输入流转换为字符的输入流
 * OutputStreamWriter：将一个字符的输出流转换为字节的输出流
 *
 * 2.作用：提供字节流与字符流之间的转换
 *
 * 3.解码：字节、字节数组 ---> 字符数组、字符串
 *   编码：字符数组、字符串 ---> 字节、字节数组
 */

public class test08 {
    @Test
    public void testInputStreamReader() throws IOException {
        FileInputStream fis = new FileInputStream("hello.txt");
        InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
//        参数2指明了字符集，具体使用哪个字符集，取决于文件hello.txt保存时使用的字符集

        char[] cbuf = new char[20];
        int len;
        while((len = isr.read(cbuf)) != -1){
            String str = new String(cbuf, 0, len);
            System.out.println(str);
        }

        isr.close();
    }
}

InputStreamReader和OutputStreamWriter

import org.junit.Test;

import java.io.*;

public class test09 {
    @Test
    public void testInputStreamReaderOutputStreamWriter() throws IOException {
//        1.造文件、造流
        File file1 = new File("hello.txt");
        File file2 = new File("hello2.txt");

        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);

        InputStreamReader isr = new InputStreamReader(fis, "UTF-8");// 解码
        OutputStreamWriter osw = new OutputStreamWriter(fos, "gbk");// 编码

//        2.读写过程
        char[] cbuf = new char[20];
        int len;
        while((len = isr.read(cbuf)) != -1){
            osw.write(cbuf, 0, len);
        }

//        3.关闭资源
        isr.close();
        osw.close();
    }
}


标准输入输出流

import org.junit.Test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class test10 {
    /*
    1.标准输入、输出流
      System.in：标准输入流，默认从键盘输入
      System.out：标准输出流，默认从控制台输出
      但是，System类的setIn(InputStream is) / setOut(PrintStream ps)方式重新指定输入和输出的位置

    2.示例：
        从键盘输入字符串，转为大写后输出；然后继续输入，当输入"e"或者"exit"时，退出程序。

    3.思路：
        System.in ---> 转换流 ---> BufferedReader的readLine()
     */

    @Test
    public void testOtherStream() throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);

        while(true){
            System.out.println(" 请输入字符串: ");
            String data = br.readLine();
            if("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)){
                System.out.println(" 程序结束 ");
                break;
            }

            String upperCase = data.toUpperCase();
            System.out.println(upperCase);

            br.close();
        }
    }
}


打印流

PrintStream

import org.junit.Test;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;

public class test11 {
    @Test
    public void testPrintStream() throws FileNotFoundException {
        FileOutputStream fos = new FileOutputStream(new File("D:\\DESKTOP\\text.txt"));
//        创建打印输出流，设置为自动刷新模式（写入换行符或字节 '\n' 时都会刷新输出缓冲流）
        PrintStream ps = new PrintStream(fos, true);

//        把标准输出流（控制台输出）改成文件
        if(ps != null){
            System.setOut(ps);
        }

        for(int i = 0; i <= 255; i++){
            System.out.println((char) i);
            if(i % 50 == 0){
                System.out.println();
            }
        }

        ps.close();
    }
}


数据流

DataInputStream和DataOutputStream

import org.junit.Test;

import java.io.*;

public class test12 {
    /*
    将内存中的字符串、基本数据类型的变量写出到文件中
     */
    @Test
    public void testDataOutputStream() throws IOException {
//        创建文件、流
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));

        dos.writeUTF("孙悟空");
        dos.flush();
        dos.writeInt(20);
        dos.flush();
        dos.writeBoolean(true);
        dos.flush();

//        关闭流资源
        dos.close();
    }



    /*
    将文件存储的基本数据类型和字符串读取到内存中，保存在变量中

    注意点：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致。
     */
    @Test
    public void testDataInputStream() throws IOException {
//        造流
        DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));

        String name = dis.readUTF();
        int age = dis.readInt();
        boolean isMale = dis.readBoolean();

        System.out.println("name = " + name);
        System.out.println("age = " + age);
        System.out.println("isMale = " + isMale);

//        关闭资源
        dis.close();
    }
}


对象流

ObjectInputStream和ObjectOutputStream

import org.junit.Test;

import java.io.*;

/**
 * 对象流的使用
 * 1.ObjectInputStream 和 ObjectOutputStream
 * 2.作用：用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把java中的对象写入到数据源中，也能把对象从数据源中还原回来。
 *
 * 3.要想一个java对象是可序列化的，需要满足相应的要求。见Person.java
 */
public class test13 {
    /*
    序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去
    使用ObjectOutputStream实现
     */
    @Test
    public void testObjectOutputStream() throws IOException {
        // 1.
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"));

        // 2.
        oos.writeObject(new String("我爱北京天安门"));
        oos.flush();

        oos.writeObject(new Person("孙悟空", 20));
        oos.flush();

        // 3.
        oos.close();
    }


    /*
    反序列化：将磁盘文件中的对象还原为内存中的一个java对象
    使用ObjectInputStream实现
     */
    @Test
    public void testObjectInputStream() throws IOException, ClassNotFoundException {
        // 1.
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));

        // 2.
        Object obj = ois.readObject();
        String str = (String) obj;

        Person p = (Person) ois.readObject();

        System.out.println(str);
        System.out.println(p);

        // 3.
        ois.close();
    }
}


随机存取文件流

import org.junit.Test;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class test14 {
/**
 * RandomAccessFile的使用
 * 1.RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput接口
 * 2.RandomAccessFile既可以作为一个输入流，又可以作为一个输出流
 *
 * 3.如果RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建。
 *   如果存在，则从头覆盖。
 *
 * 4.可以通过相关操作，实现RandomAccessFile“插入”数据的效果
 */
    @Test
    public void testRandomAccessFile() throws IOException {
        //1.
        RandomAccessFile raf1 = new RandomAccessFile(new File("hello.jpg"),"r");
        RandomAccessFile raf2 = new RandomAccessFile(new File("hello1.jpg"),"rw");

        //2.
        byte[] buffer = new byte[1024];
        int len;
        while((len = raf1.read(buffer)) != -1){
            raf2.write(buffer, 0, len);
        }

        //3.
        raf1.close();
        raf2.close();
    }

    @Test
    public void testRandomAccessFile2() throws IOException {
        RandomAccessFile raf1 = new RandomAccessFile("hello.txt", "rw");

        raf1.seek(3);//将指针调到角标为3的位置

        //保存指针3后面的所有数据到StringBuilder中
        StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
        byte[] buffer = new byte[20];
        int len;
        while((len = raf1.read(buffer)) != -1){
            builder.append(new String(buffer, 0, len));
        }

        //返回指针，写入"xyz"
        raf1.seek(3);
        raf1.write("xyz".getBytes());

        raf1.close();

        //可用ByteArrayOutputStream代替StringBuilder改进，避免出现乱码。
    }
}

IO流

标签：ignore   输入输出流   改进   finally   int   nal   思路   sig   stp   

原文地址：https://www.cnblogs.com/xiaoran991/p/12541940.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！