2021-05-12 19:53 已编辑南京传媒学院全栈开发

关注

IO流

java的io是实现输入和输出的基础,可以方便的实现数据的输入和输出操作。在java中抽象表述为流( stream)

IO流的分类

1.按照流的流向分,可以分为输入流和输岀流

输入流:只能从中读取数据,而不能向其写入数据

输出流:只能向其写入数据,而不能向其读取数据

2.按照操作单元划分,可以划分为字节流和字符流

字节流和字符流的用法几乎完成全一样,区别在于字节流和字符流所操作的数据单元不同,一个字符等于两个字节

字节流主要是由InputStream和OutputStream作为基类,而字符流则主要有 Reader和Writer作为基类

3.按照流的角色划分为节点流和处理流

可以从/向—个特定的io设备(如磁盘,网络)读/写数据的流,称为节点流节点流也被称为低级流

处理流则是用于对一个已存在的流进行连接和封装,通过封装后的流来实现数据的读/写功能处理流也被称为髙级流

了解数据源

IO流分类表

Java中四大io抽象类

InputStream

常用方法

read() 返回值 int类型（0-255之间的一个值）如果未读出字节则返回-1，表示读取结束读取一个字节的数据

close() 无返回值关闭输入流对象，释放相关资源

OutputStream

常用方法

write（int n）无返回值向目的地写入一个字节

close（）无返回值关闭输出流对象，释放相关资源

Reader

常用方法

read() 返回值 int类型（0-65535之间的一个Unicode值）如果未读出字节则返回-1，表示读取结束读取一个字符的数据

close() 无返回值关闭输入流对象，释放相关资源

Writer

常用方法

write(int n) 无返回值写入一个字符的数据

close() 无返回值关闭输出流对象，释放相关资源

小总结

动手写第一个io程序

package com.vis_yang.io;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
 * @author Vis.Yang
 * @project_name study io
 * @date 2021/5/10 11:06
 */
public class Demo {
    public static void main(String[] args) throws IOException {
        //为什么定义在外面（全局变量），方便最后关闭流对象，防止资源的浪费
        FileInputStream fis = null;
        try {
            /*
             * 创建字节输入流对象
             * FileInputStream  fis=new FileInputStream("C:/Users/ASUS/Desktop/a.txt");
             */
            fis = new FileInputStream("C:/Users/ASUS/Desktop/a.txt");
            //read()方法 读取文件里的第一个字符，会把这个字符基于字节的形式读取出来，将字节转换成一个十进制的整数返回，即返回这个整数相应的ASCII码
            int read = fis.read();
            System.out.println(read);
            //得到类容  (char) read ASCII码转成文字
            System.out.println((char) read);
            //read()方法 并不是一次性读出所有的字符，想要一次性全部读出需要使用循环
             //    int i;
            //     while(( i=fis.read())!=-1){
            //      System.out.print((char) i);
            //            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            System.out.println("找不到此文件");
        } finally {
            if (fis != null) {
                fis.close();
            }
        }
    }
}

ASCII相关

不同的字符所占的字节是不同的

ASCII码：

一个英文字母（不分大小写）占一个字节的空间，一个中文汉字占两个字节的空间。一个二进制数字序列，在计算机中作为一个数字单元，一般为8位二进制数，换算为十进制。最小值0，最大值255。如一个ASCII码就是一个字节。

UTF-8编码：

一个英文字符等于一个字节，一个中文（含繁体）等于三个字节

Unicode编码：

一个英文等于两个字节，一个中文（含繁体）等于两个字节

File类简介

针对文件操作的方法

敲代码

createNewFile() 返回布尔值成功：true 失败：false

exists() 返回值 boolean 判断文件是否存在

delete () 返回值 boolean 删除文件

一起上

字节数获取

针对目录操作的方法

mkdir() 返回值 boolean 创建目录成功返回true 失败则是false 创建一个单级目录 | mkdirs() 同理创建一个多级目录

😇

一起上

常用流对象

文件字节流

文件字节输入流

FileInputStream

写代码

文件字节输出流

FileOutPutStream

通过缓冲区提高读写效率不再是一个字节一个一字节读写，而是一个缓冲区一个缓冲区的读写了

通过创建一个指定长度的字节数组（byte[ ]）作为缓冲区,以此来提高io流的读写效率。该方式适用于读取较大图片时的缓冲区定义。注意:缓冲区的长度一定是2的整数幂,一般情况下1024长度较为合适。

写代码

缓冲区长度固定 1024字节如操作的文件过大则建议采用此方法,节省内存比拟：一袋一袋拿利用缓冲区方法，读写流都必须传入缓冲参数，此外缓冲区长度固定的写出流还要而外指定长度

读取速度加快

预估缓冲区长度操作大文件不建议 ,内存占用很大比拟:一次性拿走利用缓冲区方法，读写流都需要要传入定义好的缓冲区参数

通过字节缓冲流提高读写效率

字节输入缓冲流

BufferedInputStream

字节输出缓冲流

BufferedOutStream

写一个文件拷贝工具类

package com.vis_yang.io;

import java.io.*;

/**
 * @author Vis.Yang
 * @project_name 定义文件拷贝类    
 * @date 2021/5/10 22:09
 */
public class FileCopyTools {
    public static void main(String[] args) throws IOException {
        //桌面的power.png 复制到 E盘
        copyFile("C:\\Users\\ASUS\\Desktop\\power.png","E:\\power.png");
    }
                //可以操作多种文件
    public static void copyFile(String src, String des) throws IOException {
        //1.定义字节流和缓冲流
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        //实例化字节流和缓冲流
        try {
            fis = new FileInputStream(src);
            fos = new FileOutputStream(des);
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            int i=0;
            while ((i=bis.read())!=-1){
                bos.write(i);
            }
            bos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            //关闭资源
            if (bos!=null){
                bos.close();
            }
            if (bis!=null){
                bis.close();
            }
            if (fis!=null){
                fis.close();
            } if (fos!=null){
                fos.close();
            }
        }
    }
}

文件字符流

文件字符输入流

FileReader

文件字符输出流

FileWriter

换行？就这样😁

多个字符输出流同时操作同一个文件

实现追加

使用字符流实现文本文件拷贝

敲代码

全局代码

package com.vis_yang.io;

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

/**
 * @author Vis.Yang
 * @project_name TxtFileCopyTools
 * @date 2021/5/11 13:59
 */
public class TxtFileCopyTools {
    public static void main(String[] args) {
        copyTxtFile();
    }

    /**
     * @MethodName:copyTxtFile
     * @Description:只能操作文本文件
     * @Author: Vis.Yang
     * @Date: 2021/5/11 14:08
     * @return: void
     */
    public static void copyTxtFile() {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            //从a.txt里读取
            fr = new FileReader("C:\\Users\\ASUS\\Desktop\\a.txt");
            //写入c.txt
            fw = new FileWriter("C:\\Users\\ASUS\\Desktop\\c.txt");
            //读取方式
            int i = 0;
            while ((i = fr.read()) != -1) {
                fw.write(i);
            }
            fw.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (fr != null) {
                    fr.close();
                }
                if (fw != null) {
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

通过缓冲区提高读写效率不再是一个字符一个一字符读写，而是一个缓冲区一个缓冲区的读写了

通过创建一个指定长度的字符数组（char[ ]）作为缓冲区,以此来提高io流的读写效率。该方式适用于读取较大图片时的缓冲区定义。注意:缓冲区的长度一定是2的整数幂,一般情况下1024长度较为合适。

长度固定利用缓冲区方法，读写流都必须传入缓冲区参数并且写出流有长度

全局代码

package com.vis_yang.io;

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

/**
 * @author Vis.Yang
 * @project_name TxtFileCopyTools
 * @date 2021/5/11 13:59
 */
public class TxtFileCopyTools {
    public static void main(String[] args) {
        copyTxtFile();
    }

    /**
     * @MethodName:copyTxtFile
     * @Description:只能操作文本文件
     * @Author: Vis.Yang
     * @Date: 2021/5/11 14:08
     * @return: void
     */
    public static void copyTxtFile() {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            //从a.txt里读取
            fr = new FileReader("C:\\Users\\ASUS\\Desktop\\a.txt");
            //写入c.txt
            fw = new FileWriter("C:\\Users\\ASUS\\Desktop\\c.txt");
            //读取方式 改进：加入字符数组作为缓冲区，加快读写速度
            //定义一个char[]字符数组作为缓冲区           类似一个装米的包(字符数据)的包
            char [] buffer=new char[1024];
            //利用缓冲区方法，读写流都必须传入缓冲区参数 并且写出流有长度
            int i = 0;
            while ((i = fr.read(buffer)) != -1) {
                /*
                 *缓冲区用法 write(buffer,0,i)  长度：起始位置从0开始到i=fr.read(buffer) 比拟：若包未装满返回-1，数据读取结束 写入也随即停止
                 *相当于一次拿一整个的buffer缓冲区里存的数据写入磁盘      类似一堆大米(字符数据)，原来一粒粒(字符)拿，现在一包一包拿
                 */
                fw.write(buffer,0,i);
            }
            fw.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (fr != null) {
                    fr.close();
                }
                if (fw != null) {
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字符流没有预估长度的缓冲区的方法

字符缓冲流

字符输入缓冲流

BufferedReader

字符输出缓冲流

BufferedWriter

全局代码

package com.vis_yang.io;

import java.io.*;

/**
 * @author Vis.Yang
 * @project_name 学习字符输入输出缓冲流，提高文本文件读取效率
 * @date 2021/5/11 15:35
 */
public class BufferedReaderTest {
    public static void main(String[] args) {
        //定义变量
        FileReader fr = null;
        FileWriter fw = null;
        BufferedReader br = null;
        BufferedWriter bw = null;
        //实例化
        try {
            fr = new FileReader("C:\\Users\\ASUS\\Desktop\\a.txt");
            fw = new FileWriter("C:\\Users\\ASUS\\Desktop\\c.txt");
            br = new BufferedReader(fr);
            bw = new BufferedWriter(fw);
            /*加入缓冲流后，直接操作缓冲流即可
             *学习一下readline()这个按行读取的方法
             * 每次读取一行，效率更高
             */
            String str = "";
            while ((str = br.readLine()) != null) {
                bw.write(str+"\r\n");
            }
          /*
            每次读取一个字符，相对readline()要慢
            bw = new BufferedWriter(fw);
            加入缓冲流后，直接操作缓冲流即可
            int i = 0;
            while ((i = br.read()) != -1) {
                bw.write(i);
            }
            */
            //刷新
            bw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null) {
                    br.close();
                }
                if (bw != null) {
                    bw.close();
                }
                if (fw != null) {
                    fw.close();
                }
                if (fr != null) {
                    fr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

换行改进

package com.vis_yang.io;

import java.io.*;

/**
 * @author Vis.Yang
 * @project_name 学习字符输入输出缓冲流，提高文本文件读取效率
 * @date 2021/5/11 15:35
 */
public class BufferedReaderTest {
    public static void main(String[] args) {
        //定义变量
        FileReader fr = null;
        FileWriter fw = null;
        BufferedReader br = null;
        BufferedWriter bw = null;
        //实例化
        try {
            fr = new FileReader("C:\\Users\\ASUS\\Desktop\\a.txt");
            fw = new FileWriter("C:\\Users\\ASUS\\Desktop\\c.txt");
            br = new BufferedReader(fr);
            bw = new BufferedWriter(fw);
            /*加入缓冲流后，直接操作缓冲流即可
             *学习一下readline()这个按行读取的方法
             * 每次读取一行，效率更高
             */
            String str = "";
            while ((str = br.readLine()) != null) {
                
                //bw.write(str+"\r\n");  其实这样也挺快
                bw.write(str);
                //new line()方法换行:代替\r\n
                bw.newLine();
            }
          /*
            每次读取一个字符，相对readline()要慢
            bw = new BufferedWriter(fw);
            加入缓冲流后，直接操作缓冲流即可
            int i = 0;
            while ((i = br.read()) != -1) {
                bw.write(i);
            }
            */
            //刷新
            bw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null) {
                    br.close();
                }
                if (bw != null) {
                    bw.close();
                }
                if (fw != null) {
                    fw.close();
                }
                if (fr != null) {
                    fr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

通过字符缓冲流为文件中的内容添加行号

JAVA 中int类型转String类型的通常方法,有三种：

1、Integer.toString(int i)

2、String.valueOf(int i)

3、i + " " i 为 int类型先将int型的i转为string接上后面的字符串

三种方法效率排序为：

Integer.toString(int i) > String.valueOf(int i) > i+" "

全局代码

package com.vis_yang.io;

import java.io.*;

/**
 * @author Vis.Yang
 * @project_name  通过字符缓冲流实现为文件中的内容添加行号
 * @date 2021/5/11 15:35
 */
public class BufferedReaderTest {
    public static void main(String[] args) {
        //定义变量
        FileReader fr = null;
        FileWriter fw = null;
        BufferedReader br = null;
        BufferedWriter bw = null;
        //实例化
        try {
            fr = new FileReader("C:\\Users\\ASUS\\Desktop\\a.txt");
            fw = new FileWriter("C:\\Users\\ASUS\\Desktop\\c.txt");
            br = new BufferedReader(fr);
            bw = new BufferedWriter(fw);
            /*加入缓冲流后，直接操作缓冲流即可
             *学习一下readline()这个按行读取的方法
             * 每次读取一行，效率更高
             */
            int i=1;
            String str = "";
            while ((str = br.readLine()) != null) {
                //bw.write(str+"\r\n");  其实这样也挺快
                //添加功能：每行加行号
                bw.write(i+"."+str);
                //new line()方法换行:代替\r\n
                bw.newLine();
                i++;
            }
          /*
            每次读取一个字符，相对readline()要慢
            bw = new BufferedWriter(fw);
            加入缓冲流后，直接操作缓冲流即可
            int i = 0;
            while ((i = br.read()) != -1) {
                bw.write(i);
            }
            */
            //刷新
            bw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null) {
                    br.close();
                }
                if (bw != null) {
                    bw.close();
                }
                if (fw != null) {
                    fw.close();
                }
                if (fr != null) {
                    fr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

缓冲流

功能：将字节流转换成字符流

通过转换流实现键盘输入屏幕输出

InputStream  is=System.in    "标准"字节输入流对象

OutputStream os=System.out   "标准"字节输出流对象

采用转换流

全局代码

package com.vis_yang.io;

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

/**
 * @author Vis.Yang
 * @project_name 学习转换流
 * @date 2021/5/11 17:19
 */
public class ConvertString {
    public static void main(String[] args) throws IOException {
        InputStream is = null;
        BufferedReader br = null;
        InputStreamReader isr = null;
        try {
            //"标准"字节输入流对象  System.in
            is = System.in;
            // 使用 InputStreamReader（is）转换流把字节流 is= System.in  转换成字符流
            isr = new InputStreamReader(is);
            //字符流才可以添加到字符缓冲流
            br = new BufferedReader(isr);
            //这样一波三折后就可以使用BufferedReader字节缓冲流的readLine()方法了
            String input = br.readLine();
            System.out.println(input);
        } finally {
            try {
                br.close();
                isr.close();
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

全局代码

package com.vis_yang.io;

import java.io.*;

/**
 * @author Vis.Yang
 * @project_name 学习转换流
 * @date 2021/5/11 17:19
 */
public class ConvertString {
    public static void main(String[] args) throws IOException {
        InputStream is = null;
        OutputStream os = null;
        BufferedReader br = null;
        BufferedWriter bw = null;
        InputStreamReader isr = null;
        OutputStreamWriter osw = null;
        try {
            //"标准"字节输入流对象  System.in
            is = System.in;
            // 使用 InputStreamReader（is）转换流把字节流 is= System.in  转换成字符流
            isr = new InputStreamReader(is);
            //字符流才可以添加到字符缓冲流
            br = new BufferedReader(isr);
            //"标准"字节输出流对象  System.out
            os = System.out;
            // 使用 OutputStreamWriter(os) 转换流把字节流 os=System.out  转换成字符流
            osw = new OutputStreamWriter(os);
            //字符流才可以添加到字符缓冲流
            bw = new BufferedWriter(osw);
            //这样一波三折后就可以使用BufferedReader字节缓冲流的readLine()方法了
            String input = br.readLine();
//            System.out.println(input);
            bw.write(input);
            bw.flush();
        } finally {
            try {
                bw.close();
                osw.close();
                os.close();
                br.close();
                isr.close();
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

键盘输入屏幕输出

package com.vis_yang.io;

import java.io.*;

/**
 * @author Vis.Yang
 * @project_name 学习转换流
 * @date 2021/5/11 17:19
 */
public class ConvertString {
    public static void main(String[] args) throws IOException {
        InputStream is = null;
        OutputStream os = null;
        BufferedReader br = null;
        BufferedWriter bw = null;
        InputStreamReader isr = null;
        OutputStreamWriter osw = null;
        try {
            //"标准"字节输入流对象  System.in
            is = System.in;
            // 使用 InputStreamReader（is）转换流把字节流 is= System.in  转换成字符流
            isr = new InputStreamReader(is);
            //字符流才可以添加到字符缓冲流
            br = new BufferedReader(isr);
            //"标准"字节输出流对象  System.out
            os = System.out;
            // 使用 OutputStreamWriter(os) 转换流把字节流 os=System.out  转换成字符流
            osw = new OutputStreamWriter(os);
            //字符流才可以添加到字符缓冲流
            bw = new BufferedWriter(osw);
            //这样一波三折后就可以使用BufferedReader字节缓冲流的readLine()方法按行读取了
            //这样一波三折后就可以使用BufferedWriter字节缓冲流的newLine()方法换行了
            while (true){
                String input = br.readLine();
                if (input.equals("exit")){
                    break;
                }
                bw.write("你输入的是:"+input);  //另起一行输出                
                               bw.newLine();
                bw.flush();
            }
        } finally {
            try {
                bw.close();
                osw.close();
                os.close();
                br.close();
                isr.close();
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

全局代码

package com.vis_yang.demos;

import java.io.*;

/**
 * @author Vis.Yang
 * @project_name  通过转换流实现键盘输入屏幕输出
 * @date 2021/5/11 19:01
 */
public class NewTab {
    public static void main(String[] args) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
            br=new BufferedReader(new InputStreamReader(System.in));
            bw=new BufferedWriter(new OutputStreamWriter(System.out));
            while (true){
                String input = br.readLine();
                if (input.equals("exit")){
                    break;
                }
                bw.write("你输入的是:"+input);
                              //另起一行输出
                bw.newLine();
                bw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                bw.close();
                br.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

通过字节流读取文本文件并添加行号肯定要转换流对象

全局代码

读到键盘中

package com.vis_yang.io;

import java.io.*;

/**
 * @author Vis.Yang
 * @project_name  通过字节流读取文本文件并添加行号
 * @date 2021/5/11 19:18
 */
public class NewConvertString {
    public static void main(String[] args) throws IOException {
        //肯定要转换流对象
        BufferedReader br=null;
        BufferedWriter bw=null;
        try {
            br=new BufferedReader(new InputStreamReader(new FileInputStream("C:\\Users\\ASUS\\Desktop\\a.txt")));

            bw=new BufferedWriter(new OutputStreamWriter(System.out));
            String str="";
            int i=1;
            while (true){
                 str = br.readLine();
                if (str==null){
                    break;
                }
                bw.write(i+"."+str);
                bw.newLine();
                i++;
                bw.flush();
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            try {
                br.close();
                bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

读到文本文件里

全局代码

package com.vis_yang.io;

import java.io.*;

/**
 * @author Vis.Yang
 * @project_name  通过字节流读取文本文件并添加行号
 * @date 2021/5/11 19:18
 */
public class NewConvertString {
    public static void main(String[] args) throws IOException {
        //肯定要转换流对象
        BufferedReader br=null;
        BufferedWriter bw=null;
        try {
            br=new BufferedReader(new InputStreamReader(new FileInputStream("C:\\Users\\ASUS\\Desktop\\a.txt")));
            bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("C:\\Users\\ASUS\\Desktop\\b.txt")));
            String str="";
            int i=1;
                      //readLine()每次只读一行，循环才会流动，就像游标卡尺上的游标
            while ((str = br.readLine())!=null){
                bw.write(i+"."+str);
                     //代替换行符
                bw.newLine();
                i++;
            }
             bw.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            try {
                br.close();
                bw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字符输出流

有它自己的输出方法，同时不需要刷新，println（）方法自带换行功能

字节数组流

字节数组输入流

ByteArrayInputStream

全局代码

package com.vis_yang.io;

import java.io.ByteArrayInputStream;
import java.io.IOException;

/**
 * @author Vis.Yang
 * @project_name  学习字节数组输入流 ByteArrayInputStream
 * @date 2021/5/11 20:51
 */
public class ByteArrayInputStreamTest {
    public static void main(String[] args) {
        //创建字节数组    "HelloWorld".getBytes() 字符串.getBytes()可以形成一个字节数组
        byte [] byteArray="HelloWorld".getBytes();
        ByteArrayInputStream bais=null;
        StringBuilder sb=new StringBuilder();
        try {
            //该构造方法的参数是一个字节数组，这个字节数组就是数据源，需要读取哪个字节数组就把哪个数组传给他即可
           bais= new ByteArrayInputStream(byteArray);
           int i=0;
           while((i=bais.read())!=-1){
               //append(Char c):字符串连接
               sb.append((char) i);
           }
            System.out.println(sb);
        }finally {
            try {
                bais.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

字节数组输出流

ByteArrayOutputStream

全局代码

package com.vis_yang.io;

import java.io.ByteArrayOutputStream;

/**
 * @author Vis.Yang
 * @project_name 学习字节数组输出流 ByteArrayOutputStream
 * @date 2021/5/12 9:28
 */
public class ByteArrayOutputStreamTest {
    public static void main(String[] args) {
        ByteArrayOutputStream baos=null;
        try{
            baos=new ByteArrayOutputStream();
            baos.write('a');
            baos.write('c');
            baos.write('b');
            byte [] byteArray= baos.toByteArray();
            for (int i = 0; i < byteArray.length; i++) {
                System.out.print((char) byteArray[i]);
            }
        }finally {
            try {
                if (baos!=null){
                    baos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

数据流

数据输出字节流

DataOutputStream

全局代码

package com.vis_yang.io;

import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;

/**
 * @author Vis.Yang
 * @project_name 学习数据输出流 DataOutputStream
 * @date 2021/5/12 12:32
 */
public class DataOutputStreamTest {
    public static void main(String[] args) {
        DataOutputStream dos = null;
        try {
            //DataOutputStream是一个处理流，这里套了个字节缓冲流，里面套了个文件字节流，用于操作文件
            dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("C:\\Users\\ASUS\\Desktop\\data.txt")));
            //写入单个字节数据
            dos.writeByte('哈');
            //写入多个字节数
            dos.writeBytes("哈喽呀");
            //写入单个字符数据
            dos.writeChar(1);
            dos.writeChar('1');
            dos.writeChar('嘿');
            //写入多个字符数据
            dos.writeChars("你好呀");
            //写入int类型的数据
            dos.writeInt(1);
            //写入double类型的数据
            dos.writeDouble(2.0);
            //写入float类型的数据
            dos.writeFloat(1.9f);
            //写入boolean类型的数据
            dos.writeBoolean(true);
            //writeUTF("hello 世界") 写入字符串类型的数据
            dos.writeUTF("hello 世界");
            //刷新
            dos.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (dos != null) {
                    dos.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }
}

数据输入流

DataInputStream

全局代码

package com.vis_yang.io;

import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;

/**
 * @author Vis.Yang
 * @project_name 学习数据输出流 DataOutputStream
 * @date 2021/5/12 12:32
 */
public class DataOutputStreamTest {
    public static void main(String[] args) {
        DataOutputStream dos = null;
        try {
            //DataOutputStream是一个处理流，这里套了个字节缓冲流，里面套了个文件字节流，用于操作文件
            dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("C:\\Users\\ASUS\\Desktop\\data.txt")));
            //写入单个字节数据
            dos.writeByte('哈');
            //写入单个字符数据
            dos.writeChar('1');
            dos.writeChar('嘿');
            //写入int类型的数据
            dos.writeInt(1);
            //写入double类型的数据
            dos.writeDouble(2.0);
            //写入float类型的数据
            dos.writeFloat(1.9f);
            //写入boolean类型的数据
            dos.writeBoolean(true);
            //writeUTF("hello 世界") 写入字符串类型的数据
            dos.writeUTF("hello 世界");
            //刷新
            dos.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (dos != null) {
                    dos.close();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }
}

package com.vis_yang.io;

import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

/**
 * @author Vis.Yang
 * @project_name  学习数据输入流 DataInputStream
 * @date 2021/5/12 12:31
 */
public class DataInputStreamTest {
    public static void main(String[] args) {
        DataInputStream dis=null;
        try {
            dis=new DataInputStream(new BufferedInputStream(new FileInputStream("C:\\Users\\ASUS\\Desktop\\data.txt")));
            //注意：读取与写顺序和次数必须一致 
            System.out.println(dis.readByte());
            System.out.println(dis.readChar());
            System.out.println(dis.readChar());
            System.out.println(dis.readInt());
            System.out.println(dis.readDouble());
            System.out.println(dis.readFloat());
            System.out.println(dis.readBoolean());
            System.out.println(dis.readUTF());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (dis!=null){
                try {
                    dis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

对象流

额外功能：可以对Java对象进行读写操作

对象输出流

操作数据

ObjectOutputStream

package com.vis_yang.io;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

/**
 * @author Vis.Yang
 * @project_name 学习对象流
 * @date 2021/5/12 14:23
 */
public class ObjectOutputStreamBasicTypeTest {
    public static void main(String[] args) {
        ObjectOutputStream oos = null;
        try {
            //ObjectOutputStream处理流
            oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream("C:\\Users\\ASUS\\Desktop\\ObjectData.txt")));
            oos.writeInt(10);
            oos.writeDouble(Math.random());
            oos.writeChar('a');
            oos.writeBoolean(true);
            oos.writeUTF("hello world");
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (oos != null) {
                    oos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

对象输入流

操作数据

ObjectInputStream

package com.vis_yang.io;

import java.io.*;

/**
 * @author Vis.Yang
 * @project_name
 * @date 2021/5/12 14:37
 */
public class ObjectInputStreamBasicTypeTest {
    public static void main(String[] args) {
        ObjectInputStream ois = null;
        try {
            //ObjectInputStream也是处理流
            ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream("C:\\Users\\ASUS\\Desktop\\ObjectData.txt")));
            //同理写和读顺序必须一致
            System.out.println(ois.readInt());
            System.out.println(ois.readDouble());
            System.out.println(ois.readChar());
            System.out.println(ois.readBoolean());
            System.out.println(ois.readUTF());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null) {
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

输出效果图

操作对象

将对象序列化到文件

需要注意的地方

将文件里的对象序列化文件反序列化到内存

具体代码

package com.vis_yang.io;

import java.io.*;

/**
 * @author Vis.Yang
 * @project_name 学习反序列化
 * @date 2021/5/12 15:40
 */
public class ObjectInputStreamObjectTypeAntiSerializeTest {
    public static void main(String[] args) {
        ObjectInputStream ois = null;
        try {
            //实例化一个对象输入流
            ois = new ObjectInputStream(new FileInputStream("C:\\Users\\ASUS\\Desktop\\serialize"));
                        //ois.readObject()得到的对象类型不是User 所以这里要强制类型转换
            User user = (User) ois.readObject();
            System.out.println("该用户的id:"+user.getUserId()+"该用户的name:"+user.getUserName()+"该用户的Age:"+user.getUserAge());
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null) {
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

随机访问流

RandomAccessFile

独立于Java.io包外

掌握三个核心方法：

全局代码

package com.vis_yang.io;

import java.io.IOException;
import java.io.RandomAccessFile;

/**
 * @author Vis.Yang
 * @project_name 学习随机访问流 RandomAccessFile
 * @date 2021/5/12 16:13
 */
public class RandomAccessFileTest {
    public static void main(String[] args) throws IOException {
        RandomAccessFile raf = null;
        //mode:"rw" 可读可写 "r"只可读  "w"只可写
        raf = new RandomAccessFile("C:\\Users\\ASUS\\Desktop\\student.txt", "rw");
        //将若干数据写入到文件     10,20,30,90每个都占4个字节
        int[] intArray = new int[]{10, 20, 30, 90};
        for (int i = 0; i < intArray.length; i++) {
            raf.writeInt(intArray[i]);
        }
        //传入的是字节数   10,20,30,90每个都占4个字节  10-->0~3 20-->4~7 30-->8~11 90-->12~15
        raf.seek(4);
        //传入的是字节数是4，打印的是20
        System.out.println(raf.readInt());
        //getFilePointer() 查看指针位置
        long filePointer = raf.getFilePointer();
        System.out.println(filePointer);
        //循环输出到控制台
        for (int i = 0; i < 4; i++) {
            raf.seek(i * 4);
            System.out.print(raf.readInt() + "\t");
        }
        //利用raf.seek()替换数据     将30换成40
        raf.seek(8);
        raf.writeInt(40);
        //更改后
        System.out.println();
        for (int i = 0; i < 4; i++) {
            raf.seek(i * 4);
            System.out.print(raf.readInt() + "\t");
        }
    }
}

结果：
"C:\Program Files\Java\jdk-11.0.6\bin\java.exe" 
20
8
10    20    30    90    
10    20    40    90    
Process finished with exit code 0

File类在IO中的作用

全局代码

package com.vis_yang.io;

import java.io.*;

/**
 * @author Vis.Yang
 * @project_name 学习File类在IO中的作用
 * @date 2021/5/12 17:18
 */
public class FileInIoTest {
    public static void main(String[] args) {
        //字符输入缓冲流 BufferedReader  字符输出缓冲流 BufferedWriter
        BufferedReader br = null;
        BufferedWriter bw = null;
        //File类用于存放地址信息
        try {
            //字符输入流 FileReader  字符输出流  FileWriter
            //从IoTest.txt里读写到Io.txt
            br = new BufferedReader(new FileReader(new File("C:\\Users\\ASUS\\Desktop\\IoTest.txt")));
            bw = new BufferedWriter(new FileWriter(new File("C:\\Users\\ASUS\\Desktop\\Io.txt")));
            String s = "";
            int i=1;
            while ((s = br.readLine()) != null) {
                bw.write(i+"."+s);
                bw.newLine();
                i++;
            }
            bw.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Apache IO包

下载地址：

https://commons.apache.org/proper/commons-io/download_io.cgi

导入jar

开始使用吧

先学习一些常用方法

FileUtils的

 FileUtils.readFileToString(file, "utf-8") 将文件内容作为字符串返回

FileUtils.copyDirectory（）     FileFilter:过滤器接口

IoUtils的

IOUtils.toString(new FileInputStream("C:\\Users\\ASUS\\Desktop\\a.txt"), "utf-8")     将输入流或数组中的内容转化为字符串    utf-8 :指定编码格式

其他方法多用用就知道了

全部评论

推荐最新楼层

12-02 11:08

vivo_数据算法工程师(准入职员工)

正浩创新内推，正浩创新内推码

26届女硬件工程师丨正浩创新面经及流程9.1一面1.自我介绍2.有无相关电源设计项目或经历，并浅谈3.DCDC拓扑手撕（但是我当时没带纸笔所以口头描述），BUCK和BOOST，同步异步的区别和优缺点，同步电路的控制方式（施加什么PWM波形，如何控制MOS通断）4.项目中最有挑战性的部分，怎么解决的，然后会深挖这一部分再提问（这个问题出现的根本原因，下次如何避免）5.面试官说我专业其实不是很对口，不是电气工程专业，所以问的比较浅，大家仅供参考9.2收到笔试链接，非笔试，为性格测试9.5收到二面短信9.8 二面，没有技术问题，主要问了在校做过什么项目，调试遇到什么问题，除此之外有没有做过电源相关项...

点赞评论收藏

12-05 10:08

SHEIN_HR(准入职员工)

SHEIN内推，SHEIN内推码

在SHEIN你可以获得什么？ 1⃣️首先，时尚公司体验感直线拉满！我很多同学毕业都去做男装，做运动服，做轻熟装！但是shein真的很时尚！你可以在摄影棚直线面对外国模特，给她们搭配衣服和配饰！ 2⃣️公司工作环境超级好，工作氛围也很轻松愉快啦～每个校招生都会有专门的带教导师，很重要！！不会走冤枉路，能快速学习到东西，快速成长～咱们就是说，直球女孩的快乐！！ 3⃣️福利 超级翻倍！任何节日你都能收到来自公司满满的心意公司每个人都是shein专业的周边大户～下午茶吃到你嘴软，节日小礼物也是经常拿～ 4⃣️超值内购会！来到快时尚公司，妈妈再也不怕我没有衣服穿了！各种样衣全部十元！只要你敢来，公司就敢...

SHEIN希音公司福利 257人发布

点赞评论收藏

10-10 01:10

已编辑

深圳大学测试开发

为啥0面试啊家人们

😇😇😇  

面了100年面试不知...：六月到九月，四个项目一个实习，是魔丸吗

投了多少份简历才上岸

点赞评论收藏

12-01 14:24

吉首大学 Java

27双非0实习找实习

有没有大佬看看简历，找个百人小厂实习可以吗鸡

投递实习岗位前的准备

点赞评论收藏

12-04 09:55

顺丰集团_HR(准入职员工)

顺丰内推，顺丰内推码

java面经：顺丰一面：1. 自我介绍2. 线程池核心参数3. 任务队列大小如何设置4. 拒绝策略有哪些，可能会有什么问题5. 核心线程数如何设置6. 一个类如何保证线程安全7. CAS原理8. synchornized和reentrantlock区别9. wait、notify使用需要注意什么10. 什么是死锁，如何避免11. volatile的作用12. 数据库ACID13. 数据库隔离级别14. 分布式事务了解吗15. 场景题：生成订单和第三方支付16. 时长：30min顺丰集团2026届校招启动！【公司简介】：顺丰集团是世界500强企业第377位，中国第一大、世界第四大快递物流服务商。...

点赞评论收藏

全站热榜

创作者周榜

正在热议

IO流

IO流

java的io是实现输入和输出的基础,可以方便的实现数据的输入和输出操作。在java中抽象表述为流( stream)

IO流的分类

1.按照流的流向分,可以分为输入流和输岀流

输入流:只能从中读取数据,而不能向其写入数据

输出流:只能向其写入数据,而不能向其读取数据

2.按照操作单元划分,可以划分为字节流和字符流

字节流和字符流的用法几乎完成全一样,区别在于字节流和字符流所操作的数据单元不同,一个字符等于两个字节

字节流主要是由InputStream和OutputStream作为基类,而字符流则主要有 Reader和Writer作为基类

3.按照流的角色划分为节点流和处理流

可以从/向—个特定的io设备(如磁盘,网络)读/写数据的流,称为节点流 节点流也被称为低级流

处理流则是用于对一个已存在的流进行连接和封装,通过封装后的流来实现数据的读/写功能 处理流也被称为髙级流

了解数据源

IO流分类表

Java中四大io抽象类

InputStream

常用方法

read() 返回值 int类型 （0-255之间的一个值） 如果未读出字节则返回-1，表示读取结束 读取一个字节的数据

close() 无返回值 关闭输入流对象，释放相关资源

OutputStream

常用方法

write（int n） 无返回值 向目的地写入一个字节

close（） 无返回值 关闭输出流对象，释放相关资源

Reader

常用方法

read() 返回值 int类型 （0-65535之间的一个Unicode值） 如果未读出字节则返回-1，表示读取结束 读取一个字符的数据

close() 无返回值 关闭输入流对象，释放相关资源

Writer

常用方法

write(int n) 无返回值 写入一个字符的数据

close() 无返回值 关闭输出流对象，释放相关资源

小总结

动手写第一个io程序

ASCII相关

不同的字符所占的字节是不同的

ASCII码：

一个英文字母（不分大小写）占一个字节的空间，一个中文汉字占两个字节的空间。一个二进制数字序列，在计算机中作为一个数字单元，一般为8位二进制数，换算为十进制。最小值0，最大值255。如一个ASCII码就是一个字节。

UTF-8编码：

一个英文字符等于一个字节，一个中文（含繁体）等于三个字节

Unicode编码：

一个英文等于两个字节，一个中文（含繁体）等于两个字节

File类简介

针对文件操作的方法

敲代码

createNewFile() 返回布尔值 成功：true 失败：false

exists() 返回值 boolean 判断文件是否存在

delete () 返回值 boolean 删除文件

一起上

字节数获取

针对目录操作的方法

mkdir() 返回值 boolean 创建目录成功返回true 失败则是false 创建一个单级目录 | mkdirs() 同理 创建一个多级目录

一起上

常用流对象

文件字节流

文件字节输入流

FileInputStream

写代码

文件字节输出流

FileOutPutStream

通过缓冲区提高读写效率 不再是一个字节一个一字节读写，而是一个缓冲区一个缓冲区的读写了

通过创建一个指定长度的字节数组（byte[ ]）作为缓冲区,以此来提高io流的读写效率。该方式适用于读取较大图片时的缓冲区定义。注意:缓冲区的长度一定是2的整数幂,一般情况下1024长度较为合适。

写代码

缓冲区长度固定 1024字节 如操作的文件过大则建议采用此方法,节省内存 比拟：一袋一袋拿 利用缓冲区方法，读写流都必须传入缓冲参数，此外缓冲区长度固定的写出流还要而外指定长度

读取速度加快

预估缓冲区长度 操作大文件不建议 ,内存占用很大 比拟:一次性拿走 利用缓冲区方法，读写流都需要要传入定义好的缓冲区参数

通过字节缓冲流提高读写效率

字节输入缓冲流

BufferedInputStream

字节输出缓冲流

BufferedOutStream

写一个文件拷贝工具类

文件字符流

文件字符输入流

FileReader

文件字符输出流

FileWriter

换行？就这样😁

多个字符输出流同时操作同一个文件

实现追加

可以从/向—个特定的io设备(如磁盘,网络)读/写数据的流,称为节点流节点流也被称为低级流

处理流则是用于对一个已存在的流进行连接和封装,通过封装后的流来实现数据的读/写功能处理流也被称为髙级流

read() 返回值 int类型（0-255之间的一个值）如果未读出字节则返回-1，表示读取结束读取一个字节的数据

close() 无返回值关闭输入流对象，释放相关资源

write（int n）无返回值向目的地写入一个字节

close（）无返回值关闭输出流对象，释放相关资源

read() 返回值 int类型（0-65535之间的一个Unicode值）如果未读出字节则返回-1，表示读取结束读取一个字符的数据

close() 无返回值关闭输入流对象，释放相关资源

write(int n) 无返回值写入一个字符的数据

close() 无返回值关闭输出流对象，释放相关资源

createNewFile() 返回布尔值成功：true 失败：false

mkdir() 返回值 boolean 创建目录成功返回true 失败则是false 创建一个单级目录 | mkdirs() 同理创建一个多级目录

通过缓冲区提高读写效率不再是一个字节一个一字节读写，而是一个缓冲区一个缓冲区的读写了

缓冲区长度固定 1024字节如操作的文件过大则建议采用此方法,节省内存比拟：一袋一袋拿利用缓冲区方法，读写流都必须传入缓冲参数，此外缓冲区长度固定的写出流还要而外指定长度

预估缓冲区长度操作大文件不建议 ,内存占用很大比拟:一次性拿走利用缓冲区方法，读写流都需要要传入定义好的缓冲区参数

通过缓冲区提高读写效率不再是一个字符一个一字符读写，而是一个缓冲区一个缓冲区的读写了

长度固定利用缓冲区方法，读写流都必须传入缓冲区参数并且写出流有长度

3、i + " " i 为 int类型先将int型的i转为string接上后面的字符串

通过字节流读取文本文件并添加行号肯定要转换流对象

有它自己的输出方法，同时不需要刷新，println（）方法自带换行功能