JAVA—IO流

news2024/11/25 20:25:15

        存储数据的方案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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2063462.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

LNMP学习

LNMP学习

一、LNMP—web 1. 概述 LNMP/LAMP linux/windows/unix apache/nginx mysql/pgsql php/jsp 2. nginx部署及其平滑升级 实操 3. nginx七层负载均衡及算法 算法参考文档：https://docs.nginx.com/nginx/admin-guide/load-balancer/http-load-balancer/ 实操 4…
阅读更多...
flv格式转换mp4怎么转换？5个软件帮助你自己快速进行格式转换

flv格式转换mp4怎么转换？5个软件帮助你自己快速进行格式转换

flv格式转换mp4怎么转换？5个软件让你从此快速转换格式不求别人 将FLV格式的视频转换为MP4格式可以通过使用以下五款软件来轻松实现。这些工具操作简便，能够快速高效地完成视频格式的转换，让你轻松应对各种视频格式需求。 口袋视频转换器 这…
阅读更多...
网安新声 | 网易云音乐崩了：网络安全如何守护在线体验

网安新声 | 网易云音乐崩了：网络安全如何守护在线体验

网安加社区【网安新声】栏目，汇聚网络安全领域的权威专家与资深学者，紧跟当下热点安全事件、剖析前沿技术动态及政策导向，以专业视野和前瞻洞察，引领行业共同探讨并应对新挑战的策略与可行路径。 8月19日，#网易云音乐崩…
阅读更多...
“休闲化“趋势增强，IAA手游出海如何抓住增长机遇？

“休闲化“趋势增强，IAA手游出海如何抓住增长机遇？

进入存量时代，全球手游市场正面临严峻的挑战。数据显示，2023年 App Store 和 Google Play 的全球双端下载量同比下降10%，IAP 收入也同比减少2%。而作为大盘的支柱品类，中重度手游首当其冲。以 RPG 和 SLG 品类为例，虽然…
阅读更多...
Halo个人博客Docker部署结合内网穿透为本地站点配置公网地址远程访问

Halo个人博客Docker部署结合内网穿透为本地站点配置公网地址远程访问

文章目录 前言1. Docker部署Halo1.1 检查Docker版本如果未安装Docker可参考已安装Docker步骤：1.2 在Docker中部署Halo 2. Linux安装Cpolar2.1 打开服务器防火墙2.2 安装cpolar内网穿透 3. 配置Halo个人博客公网地址4. 固定Halo公网地址 前言 本文主要介绍如何在Cen…
阅读更多...
常见计算机网络协议汇总（非常详细）从零基础入门到精通，看完这一篇就够了

常见计算机网络协议汇总（非常详细）从零基础入门到精通，看完这一篇就够了

文章目录 前言计算机网络五层模型回顾应用层协议 DNS协议：HTTP协议HTTPS协议 传输层协议 UDP协议TCP 网络层 IP协议ICMP协议 数据链路层 ARP协议 物理层整体的网络传输流程 1️⃣网络安全零基础入门 ① 学习路线② 路线对应学习视频 2️⃣视频配套资料&国内外网…
阅读更多...
二分+前缀和+思维，CF 1902D - Robot Queries

二分+前缀和+思维，CF 1902D - Robot Queries

目录 一、题目 1、题目描述 2、输入输出 2.1输入 2.2输出 3、原题链接 二、解题报告 1、思路分析 2、复杂度 3、代码详解 一、题目 1、题目描述 2、输入输出 2.1输入 2.2输出 3、原题链接 1902D - Robot Queries 二、解题报告 1、思路分析 不管怎么反转: 起点终…
阅读更多...
【新品实测】C1001毫米波人体检测传感器来了！跌倒检测、睡眠监测更准确！

【新品实测】C1001毫米波人体检测传感器来了！跌倒检测、睡眠监测更准确！

我们最近推出了一款全新的60G毫米波产品：C1001毫米波人体检测传感器。在这篇文章中，我们将深入测评这款产品的性能，并详细解析C1001毫米波人体检测传感器的功能和特性。 产品链接：C1001 60GHz毫米波人体检测传感器 原文链接&…
阅读更多...
QML ScrollView 实现自动滚动到底部

QML ScrollView 实现自动滚动到底部

先看效果,每当有新的日志,会自动添加到Text中,主要实现了ScrollView自动滑动到底部,显示最新的日志 目录 1.思路2.position分析 1.思路 在官网中scrollview并没有关于scrollview位置的设置 但是我们可以控制右边滑动条scrollbar的位置 注意position并不是一个高度数据,你可以…
阅读更多...
Adobe Dreamweaver（DW）网页代码编辑器win/mac软件安装下载

Adobe Dreamweaver（DW）网页代码编辑器win/mac软件安装下载

一、Adobe DW软件概览 1.1 DW软件简介 Adobe Dreamweaver（简称DW）是一款功能强大的网页代码编辑器，由Adobe公司开发并维护。其全称为“Adobe Dreamweaver”，中文译为“梦想编织者”。DW集网页制作和管理网站于一身，支…
阅读更多...
Allegro PCB位号重排反标原理图步骤

Allegro PCB位号重排反标原理图步骤

第一步：也是最重要的一步，备份整个工程文件夹。 防止操作过程中误操作导致工程文件出问题，万一出问题，没有备份，调整代价比较大 第二步：确认当前PCB和原理图的网表统一。 稳妥做法： 2a:原理图…
阅读更多...
Linux入门——07 动静态库软硬连接

Linux入门——07 动静态库软硬连接

1.动静态库 静态库（.a）：程序在编译链接的时候把库的代码链接到可执行文件中。程序运行的时候将不再需要静态库动态库（.so）：程序在运行的时候才去链接动态库的代码，多个程序共享使用库的代码。一…
阅读更多...
如何在VMware ESXI中创建Linux虚拟机并实现异地SSH远程访问

如何在VMware ESXI中创建Linux虚拟机并实现异地SSH远程访问

目录 ⛳️推荐 前言 1. 在VMware ESXI中创建Ubuntu虚拟机 2. Ubuntu开启SSH远程服务 3. 安装Cpolar工具 4. 使用SSH客户端远程访问Ubuntu 5. 固定TCP公网地址 ⛳️推荐 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不…
阅读更多...
抛苹果卖银行 巴菲特到底怕什么？

抛苹果卖银行 巴菲特到底怕什么？

文｜琥珀食酒社 作者 | 积溪 停不下来、根本就停不下来 94岁的巴菲特还在疯狂卖股票 他到底是看到什么我们没看到的真相 对咱们普通人到底有没有参照价值？ 我先说结论 你可以不相信有钱人的人品 但一定要知道有钱人的钱去哪儿了 尤其这个人还是巴…
阅读更多...
机房环境监控系统

机房环境监控系统

随着信息技术的飞速发展，数据中心作为信息处理的核心设施，其重要性日益凸显。数据中心内部通常包含大量的服务器、存储设备以及网络设备等关键基础设施，这些设备的稳定运行直接影响到业务的连续性和数据的安全性。因此，建立一个高…
阅读更多...
插入排序（直接插入排序和希尔排序）

插入排序（直接插入排序和希尔排序）

先写单趟，再写整体。 一、直接插入排序 1.基本思想 直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经安排好的有序序列中，直到所有的记录插入完为止，得到一个新…
阅读更多...
2024年【起重信号司索工(建筑特殊工种)】考试题及起重信号司索工(建筑特殊工种)免费试题

2024年【起重信号司索工(建筑特殊工种)】考试题及起重信号司索工(建筑特殊工种)免费试题

题库来源：安全生产模拟考试一点通公众号小程序 起重信号司索工(建筑特殊工种)考试题是安全生产模拟考试一点通总题库中生成的一套起重信号司索工(建筑特殊工种)免费试题，安全生产模拟考试一点通上起重信号司索工(建筑特殊工种)作业手机同步练习。2024年…
阅读更多...
自定义注解,实现字段加密解密

自定义注解,实现字段加密解密

根据业务需求,要求多部分字段,进行加解密,想到实现方式,就是通过自定义的注解AOP来实现 首先新建一个注解,注意ElementType.FIELD类型,说明这个注解只能作用在字段上 Target({ElementType.FIELD}) Retention(RetentionPolicy.RUNTIME) public interface NeedEncrypt { }在新建…
阅读更多...
合宙Air700ECQ硬件设计手册——应用接口2

合宙Air700ECQ硬件设计手册——应用接口2

Air700ECQ是一款高度集成的LTE Cat1无线通信模组，基于移芯EC716E平台设计，有着极小的封装和极高的性价比。 它支持移动双模FDD-LTE/TDD-LTE 4G远距离无线传输技术，能够广泛应用于共享设备、定位器、DTU数传等多种场景。 此外，Air7…
阅读更多...
基于方面的情感分析研究综述——论文阅读笔记

基于方面的情感分析研究综述——论文阅读笔记

前言 学习NLP领域知识时，先从情感分析入手。 在网上看到一篇方面级的情感分析综述性文章，觉得挺好的就找到其原来的论文进行阅读。 原文：《A Survey on Aspect-Based Sentiment Analysis: Tasks, Methods, and Challenges》 原文地址&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023