JAVA—IO流

于 2024-08-21 23:08:57 发布
阅读量439 收藏 7
点赞数 16
分类专栏： JAVA学习笔记 文章标签： java 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hismybestlove/article/details/141172853
版权

        存储数据的方案File和文件数据的操作IO流，学习字节流和字符流，了解框架和IO框架Commons IO

目录

1.File

（1）创建对象

（2）常用方法 

【1】判断类型，获取信息

【2】创建文件，删除文件

​编辑

【3】遍历文件夹

2.方法递归

（1）递归形式

（2）应用

（3）算法思想

（4）*文件搜索

3.字符集

（1）字符集介绍

（2）编码，解码操作

4.IO流

（1）IO流概述

【1】IO流介绍

【2】应用场景

 【3】分类

（2）字节流

【1】文件字节输入流

【2】文字字节输出流

【3】案例

（3）释放资源的方式

【1】try-catch-finally

【2】try-with-resource

（4）字符流

【1】文件字符输入流

【2】文件字符输出流

（5）缓冲流

【1】字节缓冲流

【2】字符缓冲流

【3】性能分析

（6）转换流

 【1】字符输入转换流

【2】字符输出转换流

（7）打印流

（8）数据流

（9）序列化流

（10）内容补充：IO框架

1.File

        是java.io包下的类，File类的对象，代表当前操作系统的文件。只能对文件本身进行操作，不能读写文件里存储的数据

（1）创建对象

构造器说明
public File (String pathname)根据文件路径创建文件对象
public File(String parent,String child)根据父路径和子路径名字创建文件对象
public File(FIle parent,String child)根据父路径对应文件对象和子路径名字创建文件对象
package File_IO.file;

import java.io.File;

public class Text {
    public static void main(String[] args) {
        //1.创建文件对象
        // 路径分割符 \\
        File f1 = new File("C:\\Users\\22935\\IdeaProjects\\JAVA_study\\data.txt");
        System.out.println(f1.length()); //文件大小 字节个数

        //File对象是可以之地啊一个不存在的文件路径
        File f2= new File("D:/resource");
        System.out.println(f2.length());
        System.out.println(f2.exists()); //判断是否为空文件 //false

        //需要定位的文件在模块里 如何定位
        //绝对路径 //带盘符
       //  File f4 = new File("C:\\Users\\22935\\IdeaProjects\\JAVA_study\\Collection\\src\\File_IO\\file\\data.txt");
        //相对路径（重点）不带盘符 默认到工程下去找文件
        File f4 = new File("JAVA_study\\Collection\\src\\File_IO\\file\\data.txt");
        System.out.println(f4.length());
    }
}

（2）常用方法 

【1】判断类型，获取信息
方法名说明
public boolean exists()判断当前文件对象，对应的的文件路径是否存在，存在返回ture
public boolean isFile()判断当前文件对象指代的是否是文件，是则返回ture
public boolean isDirectory()判断当前文件对象指代的是否是文件夹，是则返回true
public String getName()获取文件的名称（包含后缀）
public long length()获取文件的大小，返回字节个数
public long lastModified()获取文件的最后修改时间
public String getPath()获取创建文件对象时，使用的路径
public String getAbsolutePath()获取绝对路径

package File_IO.file;

import java.io.File;
import java.text.SimpleDateFormat;

public class Text1 {
    public static void main(String[] args) {
        File f1 = new File("C:\\Users\\22935\\IdeaProjects\\JAVA_study\\data.txt");
        //public boolean exists()	判断当前文件对象，对应的的文件路径是否存在，存在返回ture
        System.out.println(f1.exists());

        //public boolean isFile()	判断当前文件对象指代的是否是文件，是则返回ture
        System.out.println(f1.isFile());

        //public boolean isDirectory()	判断当前文件对象指代的是否是文件夹，是则返回true
        System.out.println(f1.isDirectory());

        //public String getName()	获取文件的名称（包含后缀）
        System.out.println(f1.getName());

        //public long length()	获取文件的大小，返回字节个数
        System.out.println(f1.length());

        //public long lastModified()	获取文件的最后修改时间
        long time = f1.lastModified();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH :mm:ss");
        System.out.println(sdf.format(time));

        //public String getPath()	获取创建文件对象时，使用的路径
        System.out.println(f1.getPath());

        //public String getAbsolutePath()	获取绝对路径 //相对路径可以转换到绝对路径
        System.out.println(f1.getAbsoluteFile());
    }
}
【2】创建文件，删除文件
方法名说明
public boolean creatNewFile()
 
创建一个新文件，内容为空 创建成功返回true
Public boolean mkdir() 
用于创建文件夹 注意只能创建一级文件夹
public boolean mkdirs()
 
用于创建文件夹 注意 可以创建多级文件夹
public boolean delete()
 
删除文件，空文件 注意 不能删除非空文件

package File_IO.file;

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

public class Text2 {
    public static void main(String[] args) throws IOException {
        //1.public boolean creatNewFile() 创建一个新文件，内容为空 创建成功返回true
        //如果文件已经创建 那么此时再进行创建会返回失败
        File f1  = new File("C:/Users/22935/IdeaProjects/JAVA_study/data2.txt");
        System.out.println(f1.createNewFile());

        //2.Public boolean mkdir() 用于创建文件夹 注意只能创建一级文件夹
        File f2 = new File("D:/resource");
        System.out.println(f2.mkdir());

        //3.public boolean mkdirs() 用于创建文件夹 注意 可以创建多级文件夹
        File f3 = new File("D:/resource/aaa/bb/cc");
        System.out.println(f3.mkdirs());

        //4.public boolean delete() 删除文件，空文件 注意 不能删除非空文件
        //空文件夹也可以删除
        System.out.println(f1.delete());
    }
}
【3】遍历文件夹
方法名说明
Public string[ ] list() 
获取当前目录下所有的一级文件名称到一个字符串数组
public File[ ] listFiles() 
获取当前目录下所有等待一级文件对象到一个对象数组中
package File_IO.file;

import java.io.File;

public class Text3 {
    public static void main(String[] args) {
    //1.public String [] list() 获取当前目录下所有的一级文件名称到一个字符串数组
        File f1 = new File("D:/23130405班");
        String [] name = f1.list();
        for (String s : name) {
            System.out.println(s);
        }
    //2.public File [] listFile() (重点) 获取当前目录下所有等待一级文件对象到一个对象数组中
        File [] files = f1.listFiles();
        for (File file : files) {
            System.out.println(file.getAbsolutePath());
        }
    }
}

使用listfiles方法的注意事项

  • 当主调是文件或路径不存在时,返回null。
  • 当主调是空文件时，返回一个长度为零的数组。
  • 当主调是一个有内容的文件夹时，将里面一所有的一级文件和文件夹的路径都放在file数组中返回
  • 当主调是一个文件夹里面有隐藏文件时，将里面所有的文件和文件路径都放在file数组中，包括隐藏文件
  • 当主调是一个文件夹，但没有权限访问该文件夹时返回null。 

2.方法递归

        方法递归是一种算法，广泛使用，形式上来看是方法调用自身的形式

（1）递归形式

  •  直接递归：方法自己调用自己
  •  间接递归：调用其他方法，其他方法又调回自己

（2）应用

需求：计算n的阶乘

package File_IO.file;

public class Text4 {
    public static void main(String[] args) {
        System.out.println(fun(5));
    }

    public static int fun(int n){
        if(n == 1){return 1;}
        else {return fun(n-1)*n;}
    }
}

（3）算法思想

算法三要素

  • 递归公式
  • 递归的终结点
  • 递归的方向必须走向终结点

（4）*文件搜索

需求：从D盘中，搜索找到“QQ.exe”这个文件，找到后输出其位置

package File_IO.file;

import java.io.File;

public class Text5 {
    public static void main(String[] args) {
        search(new File("D:/"),"QQ.exe");
    }
     public static void search(File file,String filename){
        //1.拦截非法情况
         if(file == null || !file.exists() || file.isFile()){
             return;
         }
         File [] files = file.listFiles();
         if(files != null && files.length != 0){
             for (File f : files) {
                 if(f.isFile()){
                     if(f.getName().equals(filename)) {
                         System.out.println("已找到文件位置");
                         System.out.println(f.getAbsolutePath());
                     }
                 }
                 else{
                     search(f,filename);
                 }
             }
         }
     }
}

 需求：删除非空文件夹

package File_IO.file;

import java.io.File;

public class Text6 {
    public static void main(String[] args) {
        //目标 删除非空文件夹，独立功能独立成方法
      File file = new File("D:/");
      deleteDir(file);
    }

    public static void deleteDir(File dir){
    if(dir  == null ||!dir.exists()){
        return;
    }
    if(dir.isFile()){
        dir.delete();
        return;
    }
    File[] files = dir.listFiles();
    if(files == null){
        return;
    }

    if(files.length == 0){
        dir.delete();
        return;
    }
        for (File file : files) {
            if(file.isFile()){
                file.delete();
            }
            else{
                deleteDir(file);
            }
        }
        dir.delete();
    
    }
}

3.字符集

（1）字符集介绍

标准Ascll字符集

美国信息交换标准化码  英文，符号 共128个字符 首尾是0

GBK（汉字内码）

包含两万多个汉字字符（一个中文字符编码成两个字节的形式）兼容Ascll字符集

Uniccode字符集

（统一码，万国码）国际组织制定2，可以容纳世界上所有文字，所有字符集

  UTF-32 4个字节表示一个字符 空间占用比较大 通讯效率低

  UTF-8   采用可变编码方案 分四个长度区 1，2，3，4

  •    英文字符，数字等占1个字节
  •    汉字占用3个字节
UTF-8 编码方式
0XXXXXXX（ASCLL码）
110XXXXX  10XXXXXX
1110XXXX   10XXXXXX  10XXXXXX
11110XXX    10XXXXXX  10XXXXXX  10XXXXXX  

（2）编码，解码操作

  • 字符编码时使用的字符集，和解码时使用的字符集必须一致否则会出现乱码
  • 英文，数字一般不会乱码，很多都兼容了ASCLL编码

编码： 

string 提供方法说明
byte [] getBytes()使用平台的默认字符集将该string编码为1系列字体，将结果存储到新的字节数组中
byte [] getBytes(String charsetName)使用指定字符集将该string编码为一系列字节结果存储到新的字节数组中。

 解码：

string 提供方法说明
String (byte [] bytes)通过使用平台的默认字符集解码指定字节数组来构建新的string
String (byte [] bytes, String charsetName)通过指定字符集解码指定的字节数组来构建string
package File_IO.file;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class Text7 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //1.编码
        String data = "w愿爱你1314";
        byte [] bytes = data.getBytes(); //默认按照平台 UTF-8

        System.out.println(Arrays.toString(bytes));
        System.out.println(bytes.length);

        //指定字符集编码
        byte [] bytes1 = data.getBytes("GBK"); //抛出一个异常
        System.out.println(Arrays.toString(bytes1));

        //2.解码
        String s1 = new String(bytes);
        System.out.println(s1);

        //String s2 = new String(bytes1);//会出现乱码 编码方式不一致
        String s2 = new String(bytes1,"GBK");
        System.out.println(s2);
    }
}

4.IO流

（1）IO流概述

【1】IO流介绍

 I    指input   称为输入流 负责把数据读到内存/网络中去

O   指output 称为输出流 负责写出数据

【2】应用场景

数据传输，数据存储...

 【3】分类

（2）字节流

【1】文件字节输入流

FileInputStream

作用：以内存为基准，可以将磁盘文件中的数据以字节的形式读入到内存中

构造器说明
Public FileInputStream(File file)创建字节输入流管道与源文件接通
public FileInputStream(String pathname)创建字节输入流管道与源文件接通
方法名称说明
public int read()每次读取一个字节返回，如果发现没有数据可读会返回-1
public int read(byte[ ] buffer)每次用一个字节数组去读取数据，返回字节数组读取了多少个字节，如果发现没有数据可读返回-1
package IO_Study;

import java.io.*;

public class Text {
    public static void main(String[] args) throws IOException {
        //1.创建文字字节输入流 与源文件接通
        // InputStream is = new FileInputStream(new File("C:\\Users\\22935\\IdeaProjects\\JAVA_study\\Collection\\src\\IO_Study\\data01.txt"));
        InputStream is = new FileInputStream("C:\\Users\\22935\\IdeaProjects\\JAVA_study\\Collection\\src\\IO_Study\\data01.txt");//可以直接填入地址 推荐使用

        //2.开始读取文件字节数据
        int b1 = is.read();
        System.out.println((char) b1);

        int b2 = is.read();
        System.out.println((char) b2);

        int b3 = is.read();
        System.out.println((char) b3); // 没有数据就返回-1
        
        //循环改造上述代码
        int b;
        while((b = is.read() )!= -1){
            System.out.println((char) b);
        } //读取性能很差
          //读取汉字会出现乱码

    }
}

package IO_Study;

import java.io.*;

public class Text {
    public static void main(String[] args) throws IOException {
        //1.创建文字字节输入流 与源文件接通
        // InputStream is = new FileInputStream(new File("C:\\Users\\22935\\IdeaProjects\\JAVA_study\\Collection\\src\\IO_Study\\data01.txt"));
        InputStream is = new FileInputStream("C:\\Users\\22935\\IdeaProjects\\JAVA_study\\Collection\\src\\IO_Study\\data01.txt");//可以直接填入地址 推荐使用

       //2.读取文件的字节内容，每次多次读取
        //读取完毕返回-1
        /*byte [] buffer = new byte[3];
        int len = is.read(buffer);
        String rs = new String(buffer);
        System.out.println(rs);
        System.out.println("当前读取字符的数量" + len);
*/
        //再次王往一个数组中读取数据时 并不会重置数组
        //注意：读取多少 倒出多少

        //3.循环改造
        byte [] buffer1 = new byte[3];
        int len;
        while((len = is.read(buffer1)) != -1){
            String rs1  = new String(buffer1,0,len);
            System.out.println(rs1);
        }
        is.close(); //关闭流
    }
}

package IO_Study;

import javax.imageio.stream.FileImageInputStream;
import java.io.*;

public class Text1 {
    public static void main(String[] args) throws IOException {
        //一次读取完文件全部字节到一个数组中
        //1.创建一个字节输入流
        InputStream is = new FileInputStream("C:\\Users\\22935\\IdeaProjects\\JAVA_study\\Collection\\src\\IO_Study\\data01.txt");

        //方式一 ：.准备一个字节数组，大小与文件的大小正好一样大 方案对于内存有要求 文件过大会导致内存溢出
        //读写文本更适合使用字符流
        File f = new File("C:\\Users\\22935\\IdeaProjects\\JAVA_study\\Collection\\src\\IO_Study\\data01.txt");
        long size = f.length();
        byte[] buffer = new byte[(int) size];

        int len = is.read(buffer);
        System.out.println(new String(buffer));

        System.out.println(size);
        System.out.println(len);
        
        //方式二 ：使用java提供的方法 readAllBytes 
        byte[] buffer1 = is.readAllBytes();
        System.out.println(buffer1);
    }
}
【2】文字字节输出流

FileOutputStream

作用：

构造器说明
public FileOutputStream(File file)创建字节输出流管道与源文件对象接通
public FileOutputStream(String filepath)创建字节输出流管道与源文件对象接通
public FileOutputStream(File file,boolean append)创建字节输出流管道与源文件对象接通，可以追加数据
public FileOutputStream(String filepath,boolean append)创建字节输出流管道与源文件对象接通，可以追加数据
方法名称说明
public void write(int a)写一个字节出去
public void write(byte[] buffer)写一个字节数组出去
public void write(byte[] buffer,int pos,int len)写一个字节数组的一部分出去
public void close() throws IOException关闭流
package IO_Study;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;

public class Text2 {
    public static void main(String[] args) throws Exception {
    //创建字节输出流
        OutputStream os = new FileOutputStream("C:\\Users\\22935\\IdeaProjects\\JAVA_study\\Collection\\src\\IO_Study\\data01.txt",true);//可以追加数据的管道

        //写入文字字节
        os.write(97); //一个字节数据
        os.write('w');//也是一个字节

        byte [] bytes = "万水千山 我陪你去看".getBytes();
        os.write(bytes);

        //换行符号
        os.write("\r\n".getBytes());
        
        os.write(bytes,0,12); //写字节的一部分
        os.close();
    }
}
【3】案例

文件复制

从文件位置创建字节输入到内存中，然后再创建字节输出流管道输出文件到复制位置

package IO_Study;

import java.io.*;

public class Demo1 {
    public static void main(String[] args) throws IOException {
        //复制文件 - 图片
        //1.创建一个字节输入流管道与源文件接通
        InputStream is = new FileInputStream("");
        //2.创建一个字节输出流管道与源文件接通
        OutputStream os = new FileOutputStream(""); //输出位置需要自己填入文件名
        //3.创建一个字节数组，负责转移字节数据
        byte[] buffer = new byte[1024]; //1KB
        //4.从字节中输入流读取字节数据，写出到字节输出流，读多少写多少
        int len; //记住每次读取多少个字节
        while((len = is.read(buffer)) != -1){
            os.write(buffer,0,len);
        }
        os.close();
        is.close();
        System.out.println("复制完成");
    }
}

        字节流适合做一切文件的复制操作，转移完全部字节，只要复制后的文件格式一致就没有问题 

（3）释放资源的方式

【1】try-catch-finally

finally 代码区的特点：无论try的程序是否正常执行，还是出现异常，最后都一定会执行finally区，除非JVM终止（不要在finally里写返回语句）

     作用：一般用于在程序执行完成后进行资源的释放

package IO_Study;

import java.io.*;

public class Demo1 {
    public static void main(String[] args) throws IOException {
        //复制文件 - 图片
        //1.创建一个字节输入流管道与源文件接通
        InputStream is = null;OutputStream os = null;
        try {
            is = new FileInputStream("");
            //2.创建一个字节输出流管道与源文件接通
            os = new FileOutputStream(""); //输出位置需要自己填入文件名
            //3.创建一个字节数组，负责转移字节数据
            byte[] buffer = new byte[1024]; //1KB
            //4.从字节中输入流读取字节数据，写出到字节输出流，读多少写多少
            int len; //记住每次读取多少个字节
            while((len = is.read(buffer)) != -1){
                os.write(buffer,0,len);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                if(os != null) os.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            try {
                if(is != null) is.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        System.out.println("复制完成");
    }
}
【2】try-with-resource

        finally 语句臃肿 不雅观 JDK17后使用更加简单的资源释放方案try-with-resource

                     

package IO_Study;

import java.io.*;

public class Demo1 {
    public static void main(String[] args) throws IOException {
        //复制文件 - 图片


        try (
                //1.创建一个字节输入流管道与源文件接通
                InputStream is = new FileInputStream("");
                //2.创建一个字节输出流管道与源文件接通
                OutputStream os =new FileOutputStream(""); //输出位置需要自己填入文件名
                //注意：这里只能放置资源对象（流对象）
                //资源 资源都是会实现AutoCloseable接口
                ){
            //3.创建一个字节数组，负责转移字节数据
            byte[] buffer = new byte[1024]; //1KB
            //4.从字节中输入流读取字节数据，写出到字节输出流，读多少写多少
            int len; //记住每次读取多少个字节
            while((len = is.read(buffer)) != -1){
                os.write(buffer,0,len);
            }
            System.out.println("复制完成");
        } catch (IOException e) {
           e.printStackTrace();
        }

    }
}

（4）字符流

【1】文件字符输入流

FileReader

作用：以内存为基准，可以把文件中的数据以字符的形式读入到内存中

构造器说明
public FileReader(File file)创建字符输入流管道与源文件接通
public FileReader(String pathname)创建字符输入流管道与源文件接通
方法名称说明
public int read()每次读取一个字符返回，如果发现没有数据可读返回-1
public int read(char[ ] buffer)每次用一个字符数组去读取数据，返回字符数组读取了多少字符，没有数据可读返回-1
package IO_Study;

import java.io.*;

public class Text3 {
    public static void main(String[] args){
        //1.创建一个文件字符输入流与源文件接通
        try (Reader r = new FileReader("C:\\Users\\22935\\IdeaProjects\\JAVA_study\\Collection\\src\\IO_Study\\data02.txt");){
            //2.读取内容
            //（1）每次读取一个字符 性能比较差
           /* int c; //记录编号
            while ((c = r.read()) != -1){
                System.out.print((char) c); //英文和汉字都看做一个字符
            }*/

            //（2）每次读取多个字符
            char[] buffer = new char[3];
            int len; //记住每次读取了多少个字符
            while((len = r.read(buffer)) !=-1){
                System.out.print(new String(buffer, 0, len));
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
【2】文件字符输出流

FileWrite

作用：以内存为基准，把内存中的数据以字符的形式写到文件中去

构造器说明
public FileWriter(File fiel)创建字符输出流管道与源文件对象接通
public FileWriter(String filepath)创建字符输出流管道与源文件路径接通
public FileWriter(File file,booleanappend)创建字符输出流管道与源文件对象接通，可追加数据
public FileWriter(String filepath,boolean append)创建字符输出流管道与源文件路径接通，可追加数据
方法名称说明
void write(int c)写一个字符
void write(String str)写一个字符串
void write(String str,int off,int len)写一个字符串的一部分
void write(char[] cbuf)写一个字符数组
void write(char[] cbuf,int off,int len)写入字符数组的一部分
package IO_Study;

import java.io.FileWriter;
import java.io.Writer;

public class Text4 {
    public static void main(String[] args) {

        try(Writer fw = new FileWriter("C:\\Users\\22935\\IdeaProjects\\JAVA_study\\Collection\\src\\IO_Study\\data02.txt",true)){
            //1.void write(int c)	写一个字符
            fw.write('a');
            fw.write('b');
            fw.write('c');

            //void write(String str)	写一个字符串
            fw.write("此生 只为你我相望");

            //void write(String str,int off,int len)	写一个字符串的一部分
            fw.write("愿意",0,1);

            //void write(char[] cbuf)	写一个字符数组
            char[] data = {'a','b','c'};
            fw.write(data);

            //void write(char[] cbuf,int off,int len)	写入字符数组的一部分
            fw.write(data,0,2);

            //字符输出流写出数据后，必须刷新流，或者关闭流，写出的数据才能生效
            fw.flush(); //刷新流
            //关闭流包含刷新操作
            //适合做文本文件的操作（读写）
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

（5）缓冲流

                         对于原始流进行包装，以提高原始数据读写数据的性能

【1】字节缓冲流

提高字节流读写数据的性能

原理：字节缓冲输入流自带8KB缓冲池，缓冲输出流也自带8KB缓冲池

构造器说明
pubilc BufferedInputStream(InputStream is)把低级的字节输入流包装成一个高级的缓冲字节输入流，从而提高读数据的性能
public BufferedOutputStream(OutputStream os)把低级的字节输出流包装成一个高级的缓冲字节输出流，从而提高读数据的性能
package IO_Study;

import java.io.*;

public class Text5 {
    public static void main(String[] args) {
        try (
               //1.定义一个字节输入包装流包装原始的输入流
                InputStream is = new FileInputStream("");
                InputStream bis = new BufferedInputStream(is);
              
                OutputStream os = new FileOutputStream(""); //输出位置需要自己填入文件名
                OutputStream bos = new BufferedOutputStream(os); 
        ){
          
            byte[] buffer = new byte[1024]; //1KB
            int len; 
            while((len = bis.read(buffer)) != -1){
                bos.write(buffer,0,len);
            }
            System.out.println("复制完成");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
【2】字符缓冲流

BufferedReader(字符缓冲输入流)

作用：提高字符流输入字符数据的性能

原理：字符缓冲输入流自带8KB缓冲池

构造器说明
public BufferedReader(Reader r)把低级的字符输入流包装成字符缓冲输入流管道，从而提升性能
方法说明
public String readLine()读取一行数据返回，没有数据可读了，就返回null
package IO_Study;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.Reader;

public class Text6 {
    public static void main(String[] args) {
        try (
                Reader fr = new FileReader("C:\\Users\\22935\\IdeaProjects\\JAVA_study\\Collection\\src\\IO_Study\\data02.txt");
                BufferedReader bfr = new BufferedReader(fr);
                ){
            char[] buffer  = new char[3];
            int len;
            while((len = bfr.read(buffer)) != -1){
                System.out.println(new String(buffer, 0, len));
            }
            //特色功能 按行读取
            String line;
            while((line = bfr.readLine()) != null){
                System.out.println(line);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

BufferedWriter（字符缓冲输出流）

作用：提高字符流输出字符数据的性能

原理：字符缓冲输出流自带8KB缓冲池

构造器说明
public BufferedWriter(Writer r)把低级的字符输出流包装成字符缓冲输出流管道，从而提升性能
方法说明
public void newLine()换行
package IO_Study;

import java.io.*;

public class Text7 {
    public static void main(String[] args) {
        try(
                Writer fw = new FileWriter("C:\\Users\\22935\\IdeaProjects\\JAVA_study\\Collection\\src\\IO_Study\\data03.txt");
                BufferedWriter bfw = new BufferedWriter(fw);
                ){
            bfw.write('a');
            bfw.write('b');
            bfw.write('v');
            bfw.write("\r\n");

            bfw.write("爱你");
            bfw.newLine();
            bfw.write("爱你");


        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
【3】性能分析

测试案例：使用两种流分别按照一个字节一个字节的形式和按照字节数组的形式复制文件

 计算耗费时间来比较性能

（6）转换流

如果代码编码和被读取的文本文件的编码是一致的，使用字符流读取文本文档时不会出现乱码，不一致时就会出现乱码

package IO_Study;

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

public class Text8 {
    public static void main(String[] args) {
        //1.文件字符输入流
        try(
                Reader r = new FileReader("C:\\Users\\22935\\IdeaProjects\\JAVA_study\\Collection\\src\\IO_Study\\data03.txt");
                //Reader r = new FileReader("C:\\Users\\22935\\IdeaProjects\\JAVA_study\\Collection\\src\\IO_Study\\data04.txt");
                BufferedReader br = new BufferedReader(r);
        ) {
          String line;
          while((line = br.readLine()) != null){
              System.out.println(line);
          }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
 【1】字符输入转换流

InputStreamReader

  • 解决不同编码，字符流读取文本内容乱码的问题
  • 解决思路：获取文件的原始的字节流，再按照真实的字符集编码转成字符输入流

    构造器

    说明

    public InputStreamReader(InputStream is)

    把原始的的字节输入流，按照代码默认的编码转换成字符输入流

    public InputStreamReader(InputStream is,String charset)

    把原始的字节输入流，按照指定的字符集编码转换成字符输入流

package IO_Study;

import java.io.*;

public class Text9 {
    public static void main(String[] args) {
        try ( InputStream is = new FileInputStream("C:\\Users\\22935\\IdeaProjects\\JAVA_study\\Collection\\src\\IO_Study\\data04.txt");
              Reader isr = new InputStreamReader(is,"GBK");
              BufferedReader br = new BufferedReader(isr);
        ){
        
        } catch (Exception e) {
           e.printStackTrace();
        }
    }
}
【2】字符输出转换流

控制写出去的字符使用什么字符集编码

  1. 调用String提供的getBytes方法解决
  2. 使用“字符输出转换流”
构造器说明
Public OutputStreamWriter(OutputStream os)可以把原始的字节输出流，按照代码默认编码转换为字符输出流
public OutputStreamWriter(OutputStream os,String charset)把原始的字节输出流，按照指定的编码转换为字符输出流

（7）打印流

【1】PrintStream（字节）【2】PrintWriter（字符）

作用：打印流可以实现更方便，更高效的打印数据出去

构造器说明
public PrintStream(OutputStream/File/String)打印流直接通向字节输出流文件文件路径
public PrintStream(String filename,Charset charset)可以指定写出去的字符编码
public PrintStream(OutputStream out,boolean autoFlush)可以指定实现自动刷新
public PrintStream(OutputStream out,autoFlush,String encoding)可以指定实现自动刷新，并可指定字符的编码
方法说明
public void println(Xxx xx)打印任意类型的数据出去
public void write(int/byte[] /byte[]的一部分)可以支持写字节数据出去
package IO_Study;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintStream;

public class Text10 {
    public static void main(String[] args) {

        try (    //1.创建一个打印流
                PrintStream ps = new PrintStream("");
                
                ){
           ps.println(97); //打印97
           ps.println('a');
           ps.println("前面都白雪");
           byte [] bytes = new byte[3];
           bytes[0] = 97;
           ps.write(97); //a
           ps.write(bytes);
           
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

 输出语句的重定向

        修改System中的out的文件位置

package IO_Study;

import java.io.FileNotFoundException;
import java.io.PrintStream;

public class Text11 {
    public static void main(String[] args) {
        System.out.println("1");
        System.out.println("2");
        try(PrintStream ps = new PrintStream("");) //定向输出到文件中
        {
            System.setOut(ps);
            System.out.println("2");
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
        System.out.println("3");
        System.out.println("4");
    }
}

（8）数据流

DataOutputstream（数据输出流）

作用：允许把数据和其类型一并写出去

构造器说明
public DataOutputstream(Out putStream out)创建新数据输出包装基础的字节输出流
方法说明
public final void writeByte(int v) throw IOException将byte类型的数据写入基础字节输出流
public final void writeInt(int v) throw IOException将int类型的数据写入基础字节输出流
public final void writeDouble(int v) throw IOException将Double类型的数据写入基础字节输出流
public final void writeUTF(String str) throw IOException将字符串类型的数据按照UTF-8编码成字节写入基础字节输出流
public final void write(int /byte[]) throw IOException支持写字节数据出去
package IO_Study;

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

public class Text12 {
    public static void main(String[] args) {
        try(
                DataOutputStream dos = new DataOutputStream(new FileOutputStream(""));
                ) {
            dos.writeInt(12);
            dos.writeDouble(12.0);
            dos.writeBoolean(true);
            dos.writeUTF("韩");
           
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

DataInputStream(数据输入流) 

作用：读取数据输出流输出的数据

构造器说明
pubic DataInputStream(InputStream is)创建新数据输入流包装基础的字节输入流
方法说明
public fianl byte readByte() throws IOException读取字节数据返回
public fianl int readInr() throws IOException读取int类型的数据返回
public fianl double  readDouble() throws IOException读取double类型的数据返回
public fianl String readUTF() throws IOException读取字符串数剧返回
public int  readByte() /read(byte[])支持读写字节数据进来

（9）序列化流

ObjectInputStream（对象字节输出流）

把java对象序列化，把java对象存入到文件中去

package IO_Study;

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

public class Text13 {
    public static void main(String[] args) {

        //2.创建一个对象字节输出流包装
        try( ObjectOutputStream os =new ObjectOutputStream(new FileOutputStream(""))){//文件位置
            //1.创建一个对象
            Student stu = new Student("韩",19,"050501");

            //3.序列化文件
            os.writeObject(stu);
            System.out.println("ok");
            
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

package IO_Study;

import java.io.Serializable;
//注意 要实现序列化 要实现接口
public class Student implements Serializable {
    private String name;
    private int age;
    private String passWord;

    public String getName() {
        return name;
    }

    public Student() {
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    public Student(String name, int age, String passWord) {
        this.name = name;
        this.age = age;
        this.passWord = passWord;
    }
}

ObjectOutputStream（对象字节输入流）

把java对象反序列化，把存储在文件中的java对象读入到内存中

package IO_Study;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class Text14 {
    public static void main(String[] args) {
        try(
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream(""));
                ){
            Student student = (Student) ois.readObject();
            System.out.println(student);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

一次序列化多个对象，使用集合存储多个对象即可，ArrayList已经实现了序列化接口 

（10）内容补充：IO框架

框架：解决某类的问题，编写的一套类，接口等，是一个半成品

好处：会得到优秀的架构，并提高开发效率

IO框架

封装了JAVA提供的对文件数据进行操作的代码，对外提供了更简单的方式对文件进行操作，对数据进行读写的。 

                                                                                                        学习时间：2024-8-21

W.KN
关注
  • 16
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java IO流（超详细！）
一只小菜鸡
05-07 6万+
一、什么是IO流 I : Input O : Output 通过IO可以完成硬盘文件的读和写。 二、IO流的分类 按照 流的方向 进行分类： 以内存作为参照物： 往内存中去：叫做输入(Input)。或者叫做读(Read)。 从内存中出来：叫做输出(Output)。或者叫做写(Write)。 按照 读取数据方式 不同进行分类： 按照 字节 的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。 这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文
java IO流详细笔记
07-12
Java IO流详解
javaIO流详解
weixin_46676497的博客
01-27 2164
java常用io流介绍
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
Java io流 详解
m0_68987535的博客
06-11 4677
"IO流"（Input/Output stream）指的是Java中用于处理输入输出（I/O）数据的机制。在Java中，所有的输入和输出都被抽象为“流”对象，并通过输入流读取数据、输出流写入数据。Java的I/O包提供了丰富的类和方法来支持不同类型的流，输入流和输出流之间可以自由地进行转换。它们分别主要包括字节流和字符流两种类型。其中，字节流是操作二进制数据的流，可以处理任何类型的数据，常见的例如InputStream和OutputStream；
java IO流
D大调奏鸣曲_第七序章_de博客
11-11 8万+
目录 序 一、IO流开篇 1、概念 2、流的分类 3、IO流的作用 4、IO流的使用场景 二、字节流 1、字节流抽象基类 2、字节流写数据 （1）基本步骤 （2）三种方式 （3）两个问题 （4）异常处理 3、字节缓冲流 （1）基本分类&概述 （2）构造方法 （3）代码演示 三、字符流 1、概念 2、分类 （1）字符流体系图 （2）字符输入流（Reader） （3）字符输出流（Writer） 3、字符缓冲流 （1）概念 （2）构造方法 （3）...
Java IO流详解
ss810540895的博客
04-21 1万+
原文 Java IO流详解 1.什么是IO Java中I/O操作主要是指使用Java进行输入，输出操作. Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java的I/O流提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据流的方式读写它的数据的方法。 IO又分为流IO（java.io）和块IO(java.nio) Java.io是大多数面向数据流的输入/输出类的主要软件包。此外，Java也对块传输提供支持，在核心库 java.nio中采用的
Java IO流的种类
程序员
02-20 3278
Java IO流的种类
JavaIO流：模型
栗筝i的博客
11-24 3216
IO 的字面意思是读/写数据，IO 模型是读/写数据的方式。常用到的读/写数据方式有：同步阻塞 IO、同步非阻塞 IO、IO 多路复用、信号驱动、异步 IO 本篇内容包括：Java IO 与 IO 模型、五种 IO 模型、三种 Java IO 模型。
java IO流之BufferedReader和BufferedWriter
学习笔记，相关教程 分享
04-03 6255
笑霸能看懂的学习笔记
JavaIO流详解
itqcyyl的博客
08-09 2万+
转载：https://www.cnblogs.com/LittleHann/p/3678685.html Java输入、输入、IO流 类层次关系梳理 本文主要关注在Java编程中涉及到的IO相关的类库、方法。以及对各个层次(抽线、接口继承)的流之间的关系进行梳理   相关学习资料 http://baike.baidu.com/view/1007958.htm?noadapt=1 h...
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析 Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而...
javaIO流javaIO流javaIO流
07-02
Java IO流是Java平台中用于处理输入输出操作的核心机制，它允许程序与各种数据源（如文件、设备、网络）进行交互。Java IO流体系结构是基于“流”的概念，流是一组有序的数据序列，可以是字节流或字符流。Java IO库...
java IO流文件的读写具体实例
09-04
Java IO流是Java平台中用于处理输入输出的重要机制，它允许程序与各种数据源和目的地进行交互，包括文件、网络连接、系统硬件等。在Java中，IO流分为四个主要类别，分别是字节流（处理二进制数据）、字符流（处理...
Java IO流 文件传输基础
09-02
Java IO流是Java平台中用于处理输入输出的重要机制，它涉及到数据从源到目标的传输。文件传输基础是Java IO流应用的一个核心场景，通过IO流可以实现对文件的读写操作，包括创建、打开、修改和删除文件。在本文中，...
JAVA进阶补充
2301_80150315的博客
08-15 1026
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
【Spring框架】
最新发布
m0_71941456的博客
08-18 983
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 943
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
网上商品订单转手系统bootpf
weixin_43213064的博客
08-18 494
【代码】springboot网上商品订单转手系统bootpf
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值