Java IO流全面教程

news2024/11/26 9:36:40

此笔记来自于B站黑马程序员

File

创建对象

image-20241005222459829

public class FileTest1 {
    public static void main(String[] args) {
        // 1.创建一个 File 对象，指代某个具体的文件
        // 路径分隔符
        // File f1 = new File("D:/resource/ab.txt");
        // File f1 = new FIle("D:\\resource\\ab.txt");
        File f1 = new File(pathname: "D:" + File.separator + "resource" + File.separator + "ab.txt");
        System.out.println(f1.length()); //文件大小

        File f2 = new File("D:/resource");
        System.out.println(f2.length());
        
        // 注意： File 对象可以代指一个不存在的文件路径
        File f3 = new File("D:/resource/aaaa.txt");
        System.out.println(f3.length());
        System.out.println(f3.exists()); // false
        
        / **
           我现在要定位的文件是在模块中，应该怎么定位呢？
           绝对路径：带盘符的
           File f4 = new File("D:\\code\\javasepromax\\file-io-app\\src\\itheima.txt");
        	相对路径(重点)：不带盘符，默认是直接去工程下寻找文件的
         */   
        File f4 = new File("file-io-app\\src\\itheima.txt");
    }
}
  • File对象既可以代表文件、也可以代表文件夹。
  • File封装的对象仅仅是一个路径名，这个路径可以是存在的，也允许是不存在的。

image-20241005225438100

常用方法1：判断文件类型、获取文件信息

image-20241005223959659

就不演示代码了，Java 有一个很好的优势，即见名知意思

常用方法2：创建文件、删除文件

/***
** 目标：掌握 File 的创建和删除文件相关的
**/
public class FileTest3 {
    public static void main(String[] args) {
        // 1.public boolean createFile(); 创建一个新文件(文件内容为空), 创建成功返回true, 反之
        File f1 = new File("D:/resurce/itheima2.txt");
        System.out.println(f1.createNewFile());
        
        // 2.public boolean mkdir(); 用于创建文件夹，注意：只能创建一级文件夹
        File f2 = new File("D:/resource/aaa");
        System.out.println(f2.mkdir());
        
        
        // 3.public boolean mkdirs() 用于创建文件夹，注意；可以创建多级文件夹
        File f3 = new File("D:/resource/bbb/ccc/ddd/eee/fff/ggg");
        System.out.println(f3.mkdirs());
        
        // 4.public boolean delete() 删除文件，或者空文件，注意：不能删除非空文件夹
        System.out.println(f1.delete());
        System.out.println(f2.delete());
        File f4 = new File("D:/resource");
        System.out.println(f4.delete());
    }
}

delete方法默认只能删除文件和空文件夹，删除文件后的文件不会进入回收站

常用方法3：遍历文件夹

public class FilleTest4 {
    public static void main(String[] args) {
        // 1. public String[] list(): 获取当前目录下所有的"一级文件名称"到一个字符串数组中去返回"
        File f1 = new File("D:/course/带研发内容");
        String[] names = f1.list();
        for (String name : names) {
            System.out.println(name);
        }
        
        
        // 2 public File[] listFiles(): (重点)获取当前目录下所有的“一级文件对象"到一个文件对象数组中去返回(重点)
        File f = new File("D:/resource/aaa");
        File[] files1 = f.listFiles();
        System.out.println(Arrays.toString(files1));
    }
}
使用 listFiles 方法时的注意事项：
  • 当主调是文件，或者路径不存在时，返回null
  • 当主调是空文件夹时，返回一个长度为0的数组
  • 当主调是一个有内容的文件夹时，将里面所有一级文件和文件夹的路径放在File数组中返回
  • 当主调是一个文件夹，且里面有隐藏文件时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏文件
  • 当主调是一个文件夹，但是没有权限访问该文件夹时，返回null

前置知识：方法递归

什么是方法递归？

递归是一种算法，在程序设计语言中广泛应用。

从形式上说：方法调用自身的形式称为方法递归（recursion）

递归的形式

直接递归：方法自己调用自己。

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

使用方法递归时需要注意的问题：

递归如果没有控制好终止，会出现递归死循环，导致栈内存溢出错误。

文件搜素

image-20241005231038801

package com.itheima.d2_recursion

import java.io.File;

public class RecursionTest3 {
    public static void main(String[] args) {
        searchFile(new File("D:/"), "QQ.exe");
    }
    /**
    * 去目录下搜索某个文件
    * @param dir 目录
    * @param fileName 要搜索的文件名称
    */
    public static void searchFile(File dir, String fileName) {
        // 1.把非法的情况都拦截住
        if (dir == null || !dir.exists() || dir.isFile()) {
            reutrn;
        }
        
        // 2.dir不是null,存在，一定是目录对象
        // 获取当前目录下的全部一级文件对象
        File[] files = dir.listFiles();
        
        // 3. 判断当前目录下是否存在一级文件对象，以及是否可以拿到一级文件对象
        if (files != null && files.length > 0) {
			// 4.遍历全部一级文件对象
			for (File f : files) {
                if (f.isFile()) {
                    if (f.getName().contains(fileName)) {
                    	System.out.println("找到了: " + f.getAbsolutePath());
                	}
                } else {
                 	searchFile(f, fileName);   
                }
            }
        }
    }
}

前置知识：字符集

image-20241006002947388

image-20241006003403394

image-20241006003517166

image-20241006003531605

image-20241006134415217

本节要点
  • ASCI字符集：只有英文、数字、符号等，占1个字节。
  • GBK字符集：汉字占2个字节，英文、数字占1个字节。
  • UTF-8字符集：汉字占3个字节，英文、数字占1个字节。

注意1：字符编码时使用的字符集，和解码时使用的字符集必须一致，**否则会出现乱码 **⚠️

注意2：英文，数字一般不会乱码，因为很多字符集都兼容了 ASCII 编码。 ⚠️

image-20241006134944825

import java.util.Arrays;

public class Test {
    public static void main(String[] args) throws Exception {
        // 1.编码
        String data = "a我b";
        byte[] bytes = data.getBytes(); // 默认是按照平台字符集 (UTF-8) 进行编码的
        System.out.println(Arrays.toString(bytes));
        
        // 按照指定字符集进行编码
        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, "GBK");
        System.out.println(s2);
    }
}

IO 流

image-20241006140113709

IO 流的应用场景

image-20241006140335209

IO 流概述

image-20241006140806697

IO流-字节流

文件字节输入流：每次读取一个字节(FileInputStream)

image-20241006141529213

public class FileInputStreamTest1 {
    public static void main(String[] args) throws Exception {
        // 1. 创建文件字节输入流管道,与源文件接通
        // InpustStream is = new FileInputStream(new File("file-io-app\\src\\itheima01.txt"));
        
        // 简化写法，推荐使用
		InputStream is = new FileInputStream(("file-io-app\\src\\itheima01.txt"));
        
        // 2.开始读取文件的字节数据
        // public int read(); 每次读取一个字节返回，如果没有数据了，返回-1
      //  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(b3);
        int b;
        while ((b = is.read()) != -1) {
			System.out.print((char) b);
        }
        
        // 读取的性能很差
        // 读取汉字会乱码
        
        // 流使用完毕后，必须关闭，释放系统资源
        is.close();
    }
}

public class FileInputStreamTest1 {
    public static void main(String[] args) throws Exception {
        // 1. 创建文件字节输入流管道,与源文件接通
        // InpustStream is = new FileInputStream(new File("file-io-app\\src\\itheima01.txt"));
        
        // 简化写法，推荐使用
		InputStream is = new FileInputStream(("file-io-app\\src\\itheima01.txt"));
        
        // 2.开始读取文件的字节数据: 每次读取多个数据
        // public int read(byte b[]) throws IOException
       // 每次读取多个字节到字节数组中去，返回读取的字节数量，读取完毕会返回 -1
        
        byte[] buffer = new byte[3];
        int len = is.read(buffer);
        String rs = new String(buffer);
        
        System.out.println(rs);
        System.out.println("当次读取的字节数量: " + len);
        
        // buffer = [abc]
        // buffer = [66c]
        int len2 = is.read(buffer);
        // 注意：读取多少，倒出多少
        String rs2 = new String(buffer, 0, len2);
        System.out.println(rs2);
        System.out.println("当次读取的字节数量: " + len2);
        
        int len3 = is.read(buffer);
        System.out.println(len3); // -1
        
        is.close();
    }
}

文件字节输入流：每次读取多个字节 (FileOutputStream)

public class FileInputStreamTest1 {
    public static void main(String[] args) throws Exception {
        // 1. 创建文件字节输入流管道,与源文件接通
        // InpustStream is = new FileInputStream(new File("file-io-app\\src\\itheima01.txt"));
        
        // 简化写法，推荐使用
		InputStream is = new FileInputStream(("file-io-app\\src\\itheima01.txt"));
        
        byte[] buffer = new byte[3];
        int len; // 记住每次读取了多少个字节。abc 66
        while ((len = is.read(buffer)) != -1) {
            // 注意：读取多少，倒出多少
            String rs = new String(buffer, 0, len);
            System.out.print(rs);
        }
        
        // 性能得到了明显的提升!!
        // 这种方案也不能避免读取汉字输出乱码的问题!!
        is.close(); // 关闭流
    }
}

文件字节输入流：一次读取完全部字节 (FileReader)

文件字节输入流：一次读取完全部字节
  • 方式一： 自己定义一个字节数组与被读取的文件大小一样大，然后使用该字节数组，一次读完文件的全部字节。
  • image-20241006145641914
public class FileInputStreamTest1 {
    public static void main(String[] args) throws Exception {
        // 1. 创建文件字节输入流管道,与源文件接通
        // InpustStream is = new FileInputStream(new File("file-io-app\\src\\itheima01.txt"));
        
        // 简化写法，推荐使用
		InputStream is = new FileInputStream(("file-io-app\\src\\itheima01.txt"));
        
       // 2.准备一个字节数组，大小与文件的大小正好是一样大
        File f = new File("file-io-app\\src\\itheima03.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);
        
        is.close(); // 关闭流
    }
}
方式二：Java官方为lnputStream提供了如下方法，可以直接把文件的全部字节读取到一个字节数组中返回。

image-20241006150532012

public class FileInputStreamTest1 {
    public static void main(String[] args) throws Exception {
        // 1. 创建文件字节输入流管道,与源文件接通
        // InpustStream is = new FileInputStream(new File("file-io-app\\src\\itheima01.txt"));
        
        // 简化写法，推荐使用
		InputStream is = new FileInputStream(("file-io-app\\src\\itheima01.txt"));
       
        byte[] buffer = is.readAllBytes();
        System.out.println(new String(buffer));
        is.close(); // 关闭流
    }
}
总结

image-20241006150614013

文件字节输出流：写字节出去 (FileWriter)

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

image-20241006151008372

public class FileOutputStreamTest4 {
    public static void main(String[] args) throws Exception {
        //1、创建一个字节输出流管道与目标文件接通。
        //覆盖管道：覆盖之前的数据
        
       // OutputStream os =
       //     new File0utputStream("file-io-app/src/itheima04out.txt");
        
        //追加数据的管道
        OutputStream os =
            new File0utputStream(name:"file-io-app/src/itheima04out.txt", append:true);
        
        //2、开始写字节数据出去了
        os.write(97); //97 就是一个字节，代表 a
        os.write('b'); //‘b'也是一个字节
        //os.write（'磊'）；//[ooo］默认只能写出去一个字节
        
        byte[] bytes = "我爱你中国abc".getBytes()；
        os.write(bytes);
        
        os.write(bytes, off:0, len:15);
        
        os.close()；//关闭流
    }
}

案例：文件复制

image-20241006152027887

public class FileOutputStreamTest4 {
    public static void main(String[] args) throws Exception {
        // 复制文件
		InputStream is = new FileInputStream("file-io-app\\src\\itheima03.txt");
        
        // 2.创建一个字节输出流管道与目标文件接通
        OutputStream os = new FileOutputStream("file-io-app\\src\\itheima03copy.txt");
        
        // 1024 * 1024 + 6;
        // 3.创建要给字节数组，负责转移字节数组
        byte[] buffer = new byte[1024]; // 1kb
        int lne;
        while ((len == is.read(buffer)) != -1) {
            os.write(buffer, 0, len);
        }
        
        os.close();
        is.close();
        System.out.println("复制完成!!!");
    }
}

IO流-资源释放方式

  • finally 代码区的特点：无论 try 中的程序是正常执行了，还是出现了异常，最后都一定会执行 finally区，除非JVM终止。

作用：一般用于在程序执行完成后进行资源的释放操作**（专业级做法)。**

public class Test1 {
    public static void main(String[] args) {
        try {
            System.out.println(10 / 0);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("===finally执行了一次===");
        }
    }
    
    public static int chu(int a, int b) {
        try {
            return a / b;
        } catch (Exception e) {
            return -1;
        } finally {
            // 千万不要在 finally 中返回数据(会覆盖之前return的语句)
            return 111;
        }
    }
}

public class FileOutputStreamTest4 {
    public static void main(String[] args) throws Exception {
        InputStream is = null;
        OutputStream os = null;
        // 复制文件
        try {
            System.out.println(10 / 0);
            is = new FileInputStream("file-io-app\\src\\itheima03.txt");
            // 2. 创建一个字节输出流管道与目标文件接通
            os = new FileOutputStream("file-io-app\\src\\itheima03copy.txt");
            // 制作一个错误
            System.out.println(10 / 0);
            // 3. 创建要给字节数组，负责转移字节数组
            byte[] buffer = new byte[1024]; // 1KB
            // 4. 从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
            int lne; // 记住每次读取了多少个字节
            while ((len == is.read(buffer)) != -1) {
                os.write(buffer, 0, len);
            }
            System.out.println("复制完成!!!");
        } catch(IOException e) {
            e.printStackTrace();
        } finally {
            if (os != null) os.close();
            if(is != null) is.close();
        }
    }
}

image-20241006160922550

JDK7 开始提供了更简单的资源释放方案：try-with-resource****

image-20241006161003253

该资源使用完毕后，会自动调用其 close()方法，完成对资源的释放！

public class FileOutputStreamTest4 {
    public static void main(String[] args) throws Exception {
        // 复制文件
        
        try ( 
            InputStream is = new FileInputStream("file-io-app\\src\\itheima03.txt");
            // 2. 创建一个字节输出流管道与目标文件接通
            OutputStream os = new FileOutputStream("file-io-app\\src\\itheima03copy.txt");)
        {            
            System.out.println(10 / 0);
            // 制作一个错误
            // 3. 创建要给字节数组，负责转移字节数组
            byte[] buffer = new byte[1024]; // 1KB
            // 4. 从字节输入流中读取字节数据，写出去到字节输出流中。读多少写出去多少。
            int lne; // 记住每次读取了多少个字节
            while ((len == is.read(buffer)) != -1) {
                os.write(buffer, 0, len);
            }
            System.out.println("复制完成!!!");
        } catch(IOException e) {
            e.printStackTrace();
        } 
    }
}

public class MyConnection implements AutoCloseable {
    @Override
    public void close() throws Exception {
        System.out.println("释放了与某个硬件的链接资源~~~~");
    }
}
  • () 中只能放置资源，否则报错
  • 什么是资源呢?
  • 资源一般指的是最终实现了 AutoCloseable 接口。
  • public abstract class InputStream implements Closeable { }
  • public abstract class OutputStream implements Closeable, Flushable { }
  • public interface Closeable extends AutoCloseable { }

IO 流-字符流(字节流：适合复制文件等，不适合读写文本文件)

文件字符输入流(FileReader)-读字符数据进来

image-20241006162637865

image-20241006162730811

public class itcasttest2 {
    public static void main(String[] args) {
        try (
        	// 1.创建一个文件字符输入流管道与源文件接通
            Reader fr = new FileReader("io-app2\\src\\itheima01.txt");
        ) {
           char[] buffer = new char[3];
            int len; // 记住每次读取了多少字符
            while ((len = fr.read(buffer)) != -1) {
                // 读取多少倒出多少
                System.out.print(new String(buffer, 0, lent));
            }
            // 性能是比较不错的
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

文件字符输出流(FileWriter)-写字符数据出去

image-20241006163819987

image-20241006163900254

public class test3 {
    public static void main(String[] args) {
        try {
            ( // 0.创建一个文件输出流管道与目标文件接通
            // 覆盖管道
            // Writer fw = new FileWriter("io-app2/src/itheima02out.txt");
            Writer fw = new FileWriter("io-app2/src/itheima02out.txt", true))
           {
               // 1.public void write(int c)写一个字符出去
                fw.write('a');
                fw.write(97);
                fw.write('磊');
                fw.write("\r\n"); //换行(可兼容性好)
               
               // 2.public void write(String c) 写一个字符串出去
               fw.write("我爱你中国abc");
               fw.write("\r\n");
               
               // 3.public void write(String c, int pos, int len) 写字符串的一部分出去
				fw.write("我爱你中国abc", 0, 5);
                fw.write("\r\n");
               
               // 4. public void write(char[] buffer): 写一个字符数组出去
				char[] buffer = {'黑'，'马', 'a', 'b', 'c'};
               fw.write(buffer);
               fw.write("\r\n");
               
               fw.close();
            }
        }
    }
}
**字符输出流写出数据后，必须刷新流，或者关闭流，**写出去的数据才能生效 ⚠️

image-20241006165421514

IO 流-缓冲流

image-20241006170037134

字节缓冲流

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

image-20241006170415695

image-20241006170630810

public class BufferInputStreamTest1 { 
    public static void main(String[] args)) {
        tyr (
        	InputStream is = new FileInputStream("io-app2/src/itheima01.txt");
            // 1.定义一个字节缓冲输入流包装原始的字节输入流
            InputStream bis = new BufferedInputStream(is);
            
            OutputStream os = new FileOutputStream("io-app2/src/itheima01_back.txt");
            // 2.定义一个字节缓冲输出流包装原始的字节输出流
            OutputStream bos = new BufferedOutputStream(os);
        ) {
           byte[] buffer = new byte[1024];
            int len;
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
            }
            System.out.println("复制完成!!");
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

字符缓冲流

字符缓冲输入流(BufferedReader)

作用：自带 8K（8192）的字符缓冲池，可以提高字符输入流读取字符数据的性能。

image-20241006171450175

public class BufferedReaderTest2 {
    public static void main(String[] args) {
        try (
        	Reader fr = new FileReader("io-app2\\src\\itheima02.txt");
            
            // 创建一个字符缓存输入流包装原始的字符输入流
			BufferedReader br = new BufferedReader(fr);
        ) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
}
字符缓冲输出流(BufferedWriter)

image-20241006172337012

public class BufferedWriterTest3 {
    public static void main(String[] args) {
        try (
        	Writer fw = new FileWriter("io-app2/src/itheimao5out.txt", true);
            BufferWriter bw = new BufferedWriter(fw);
        ) {
            bw.write('a');
            bw.write(97);
            bw.write('磊')；
            bw.newLine();
            
            bw.write("我爱你中国abc");
            bw.newLine();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

原始流、缓冲流的性能分析[重点]

测试用例：

分别使用原始的字节流，以及字节缓冲流复制一个很大视频。

测试步骤：
使用低级的字节流按照一个一个字节的形式复制文件。
使用低级的字节流按照字节数组的形式复制文件。
使用高级的缓冲冲字节流按照一个一个字节的形式复制文件。
使用高级的缓冲字节流按照字节数组的形式复制文件。
public class TimeTest4 {
    private static final String SRC_FILE = "D:\\resource\\线程池.avi";
    
    private static final String DEST_FILE = "D:\\";
    
    public static void main(String[] args) {
        copy01(); //copy01（）；//低级字节流一个一个字节的赋值，慢的简直让人无法忍受，直接淘汰！
        copy02(); //低级的字节流流按照一个一个字节数组的形式复制，速度较慢！
        copy03(); // 缓冲流按照一个一个字节的形式复制，速度较慢
        copy04(); //缓冲流按照一个一个字节数组的形式复制，速度极快，推荐使用！
    }
    private static void copy01() {
        long startTime = System.currentTimeMillis();
        
        try (
        		InputStream is = new FileInputStream(SRC_FILE);
            	outputStream os = new FileOutputStream(DEST_FILE + "1.avi");
        ) {
            
            int b;
            while ((b = is.read()) != -1) {
                os.write(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        logn endTime = System.currentTimeMillis();
        System.out.println("低级字节流一个一个字节复制耗时: " + (endTime - startTime) / 1000.0);
    }
    
    
    
    private static void copy02() {
		long startTime = System.currentTimeMillis();
        try (
        	InputStream is = new FIleInputStream(SRC_FILE);
            OutputStream os = new FIleOutputStream(DEST_FILE + "2.avi");
        ) {
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1 ) {
				os.write(buffer, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        long endTime = System.currentTimeMIllis();
        System.out.println("低级字节流使用字节数组复制耗时： " + (endTime - startTime) / 1000.0 + "s");
    }
    
    private static void copy03() {
        long startTime = System.currentTimeMillis();
        
        try (
        		InputStream is = new FileInputStream(SRC_FILE);
            	BufferInputStream bis = new BufferInputStream(is);
            	OutputStream os = new FileOutputStream(DEST_FILE + "1.avi");
            	BufferOutputStream bos = new BufferOutputStream(os);
        ) {
            
            int b;
            while ((b = is.read()) != -1) {
                bos.write(b);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        logn endTime = System.currentTimeMillis();
        System.out.println("缓冲流一个一个字节复制耗时: " + (endTime - startTime) / 1000.0);
    }
    
    
    private static void copy04() {
		long startTime = System.currentTimeMillis();
        try (
        	InputStream is = new FIleInputStream(SRC_FILE);
            BufferInputStream bis = new BufferInputStream(is);
            OutputStream os = new FIleOutputStream(DEST_FILE + "2.avi");
            BufferOutputStream bos = new BufferOutputStream(os);
        ) {
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1 ) {
				bos.write(buffer, 0, len);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        long endTime = System.currentTimeMIllis();
        System.out.println("低级字节流使用字节数组复制耗时： " + （endTime - startTime) / 1000.0 + "s");
    }
}

IO 流-转换流

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

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

引出问题：不同编码读取时会乱码

image-20241006182332362

字符输入转换流 (InputStreamReader)

解决思路：先获取文件的原始字节流，再将其按真实的字符集编码转成字符输入流，这样字符输入流中的字符就不乱码了。

image-20241006193522774

public class InputStreamReaderTest2 {
    public static void main(String[] args) {
        try (
        		// 1.得到文件的原始字节流(GBK的字节流形式)
            	InputStream is = new FileInputStream("io-app2/src/itheima06.txt");
            	// 2.把原始的字节输入流按照指定的字符集编码转换成字符输入流
				Reader isr = new InputStreamReader(is, "GBK");
            	// 3. 把字符输入流包装成缓冲字符输入流
            	BufferedReader br = new BufferedReader(isr);
        ) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

字符输出转换流(OutputStreamWrite)

image-20241006194807562

  • 解决思路：获取字节输出流，再按照指定的字符集编码将其转换成字符输出流，以后写出去的字符就会用该字符集编码了。

image-20241006195948045

IO 流-打印流

image-20241006200704131

作用：打印流可以实现更方便、更高效的打印数据出去，能实现打印啥出去就是啥出去。

image-20241006201027313

import java.io.PrintStream;
imort java.nio.charset.Charset;

public class PrintTest1 {
    public static void main(String[] args) {
        try (
        	// 1. 创建一个打印流管道
            PrintStream ps = new PrintStream("io-app2/src/itheima08.txt", Charset.forName("GBK"));
        ) {
            ps.println(97);
            ps.println('a');
            ps.println("我爱你中国abc");
            ps.println(true);
            ps.println(99.5);
            
            ps.write(97);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

PrintWriter

image-20241006201842873

PrintStream 和 PrintWriter 的区别
  • 打印数据的功能上是一模一样的：两者都是使用方便，性能高效 (核心优势)
  • PrintStream 继承自字节 输出流OutputStream，因此支持写字节数据的方法。
  • PrintWriter 继承自字符 输出流Writer，因此支持写字符数据出去。
public class PrintTest2 {
    public static void main(String[] args) {
        System.out.println("老骥伏枥");
        System.out.println("志在千里");
        
        try (PrintStream ps = new PrintStream("io-app2/src/itheima09.txt"); ) {
            // 把系统默认的打印流对象改成自己设置的打印流
            System.setOut(ps);
            
            System.out.println("烈士暮年");
            System.out.println("壮心不已");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

image-20241006203148059

IO 流-数据流

image-20241006204604982

image-20241006204433348

image-20241006204756408

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

public class DataOutputStreamTest1 {
    public static void main(String[] args) {
        try (
        		// 1. 创建一个数据输出流包装低级的字节输出流
            	DataOutputStream dos = new DataOutputStream(new FileOutputStream("io-app2/src/itheima10out.txt"));
            
        ) {
            dos.writeInt(97);
            dos.writeDouble(99.5);
            dos.writeBoolean(true);
            dos.writeUTF("黑马程序员666!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class DataInputStreamTest2 {
    public static void main(String[] args) {
        try (
            DataTnputStream dis = new DataInputStream(new FileInputStream("io-app2/src/itheima10out.txt"));
        ) {
            int i = dis.readInt();
            System.out.println(i);
            
            double d = dis.readDouble();
            System.out.println(d);
            
            boolean b = dis.readBoolean();
            System.out.println(b);
            
            String rs = dis.readUTF();
            System.out.println(rs);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

IO 流-序列化流

  • 对象序列化：把Java对象写入到文件中去
  • 对象反序列化：把文件里的java对象读出来

image-20241006211813361

可以把 Java 对象进行序列化：把 Java 对象存入到文件中去

注意：对象如果要参与序列化，必须实现序列化接口**（java.io.Serializable）**

image-20241006212130859

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

public class Test1ObjectOutputStream {
    public static void main(Stirng[] args) {
        try (
        		// 2. 创建一个对象字节输出流包装原始的字节 输出流
            	ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("io-app2/src/itheima11out.txt"));
        ) {
            // 1.创建一个 Java 对象
            User u = new User("admin", "张三", 32, "666888xyz");
            
            // 3.序列化对象到文件中
            oos.writeObject(u);
            System.out.println("序列化对象成功!!");
            
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
}

ObjectlnputStream（对象字节输入流）

可以把 Java 对象进行反序列化：把存储在文件中的 Java 对象读入到内存中来。

image-20241006213242956

public class Test20bjectInputStream {
    public static void main(String[] args) {
        try (
        	ObjectInputStream ois  = new ObjectInputStream(new FileInputStream("io-app/src/itheima11out.txt"));
        ) {
            
            User u = (User) ois.readObject();
            System.out.println(u);
            
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

transient 这个成员变量将不参与序列化

image-20241006214212793

补充知识：：IO 框架

什么是框架?
  • 解决某类问题，编写的一套类、接口等，可以理解成一个半成品，大多框架都是第三方研发的。
  • 好处：在框架的基础上开发，可以得到优秀的软件架构，并能提高开发效率。
  • 框架的形式：一般是把类、接口等编译成class形式，再压缩成一个.jar结尾的文件发行出去。

image-20241006214527615

什么是 IO 框架
  • 封装了 Java 提供的对文件、数据进行操作的代码，对外提供了更简单的方式来对文件进行操作，对数据进行读写等。
Commons-io

Commons-io 是 apache开源基金组织 提供的一组有关 lO操作 的小框架，目的是 提高lO流 的开发效率。

image-20241006214655003

image-20241006215007477

建议用 Maven, 导入依赖就是爽啊.

public class CommonsTOTest1 {
    public static void main(String[] args) throws Exception {
        // FileUtils.copyFile(new File("io-app2\\src\\itheima01.txt"), new File("io-app2/src/a.txt"));
        // FileUtils.copyDirectory(new File("D:\\resource\\私人珍藏"), new File("D:\\resource\\私人珍藏3"));
        // FileUtils.deleteDirectory(new File("D:\\resource\\私人珍藏3"));
        
        // Java提供的原生的一行代码搞定很多事情
        Files.copy(Path.of("io-app2\\src\\itheima01.txt"), Path.of("io-app2\\src\\b.txt"));
        System.out.println(Files.readString(Path.of("io-app2\\src\\itheima01.txt"));
    }
}

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

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

相关文章

子比主题美化 – 添加天气教程

子比主题美化 – 添加天气教程

前言 经常看到很多的网站顶部或者侧边有显示天气状态的小条幅，看着也美观，寻思着也在自己的小站上显示天气。大体的思路是能识别用的ip地址来确认位置然后以代码形式在前台显示出。 经过在百度上搜索一番，发现一个很不错的天气api&#xff…
阅读更多...
VMware ESXi Centos7网卡名称 ens192 变更eth0

VMware ESXi Centos7网卡名称 ens192 变更eth0

1.在 /etc/sysconfig/network-scirpts/ 文件夹下 创建一个ifcfg-eth0的文件， 最简单的方式是 mv ifcfg-ens192 ifcfg-eth0 然后 vi ifcfg-eth0 把DEVICE改成 DEVICEeth0 wq! 保存 2. vi /etc/sysconfig/grub # 在位置添加 net.ifnames0 biosdevname0 参数 完…
阅读更多...
数据结构之红黑树实现（全）

数据结构之红黑树实现（全）

一、红黑树 红黑树是一种自平衡的二叉搜索树，它通过约束节点的颜色和结构来保持平衡。红黑树是由 Rudolf Bayer 在1972年发明的，被认为是一种优秀的平衡树结构，广泛应用于各种数据结构和算法中。 1.红黑树的性质 1. 每个结点是红的或者黑的…
阅读更多...
detectron2/data/catalog.py源码笔记

detectron2/data/catalog.py源码笔记

公开接口是DatasetCatalog对象，MetadataCatalog对象和Metadata类 DatasetCatalog.register(name, func) #用于注册函数 DatasetCatalog.get(name) #返回函数调用结果return func() DatasetCatalog.list() #return list(self.keys()) Datase…
阅读更多...
Windows系统编程（三）进程与线程二

Windows系统编程（三）进程与线程二

进程与线程 进程：直观的说就是任务管理器中各种正在运行的程序。对于操作系统来说，进程仅仅是一个数据结构，并不会真实的执行代码 线程：通常被称作但并不真的是轻量级进程或实际工作中的进程，它会真实的执行代码。每…
阅读更多...
强制删除了windows自带的edge浏览器，重装不了怎么办【已解决】

强制删除了windows自带的edge浏览器，重装不了怎么办【已解决】

#最近我的edge浏览器出了点问题，点击打不开但是能在下面的任务栏看到他开启了，就是不能够显示在桌面，小窗口叫我配置设置。 我不懂，感觉很烦，就把他强制卸载了。但是windows是不允许将他卸载的，使用window…
阅读更多...
LeetCode讲解篇之695. 岛屿的最大面积

LeetCode讲解篇之695. 岛屿的最大面积

文章目录 题目描述题解思路题解代码题目链接 题目描述 题解思路 我们遍历二维矩阵，如果当前格子的元素为1进行深度优先搜索，将搜索过的格子置为0，防止重复访问，然后对继续深度优先搜索上下左右中为1的格子 题解代码 func maxAr…
阅读更多...
sublime配置(竞赛向)

sublime配置(竞赛向)

我也想要有jiangly一样的sublime 先决条件 首先，到官网上下载最新的sublime4，然后在mingw官网上下载最新的mingw64 mingw64官网：左边菜单栏点击dowloads,然后选择MinGW-W64-builds(可能会有点慢)——然后有时候会变成选LLVM-minGW,接着选择…
阅读更多...
Vue入门-指令学习-v-show和v-if

Vue入门-指令学习-v-show和v-if

v-show： 作用：控制元素的显示隐藏 语法：v-show"表达式" 表达式值true显示，false隐藏 v-if 作用：控制元素的显示隐藏（条件渲染） 语法： vif"表达式" 表达式tr…
阅读更多...
【Mybatis篇】Mybatis的注解开发

【Mybatis篇】Mybatis的注解开发

🧸安清h：个人主页 🎥个人专栏：【计算机网络】，【Mybatis篇】 🚦作者简介：一个有趣爱睡觉的intp，期待和更多人分享自己所学知识的真诚大学生。 文章目录 🎯 Select注解 …
阅读更多...
Nuxt.js 应用中的 app：suspense：resolve 钩子详解

Nuxt.js 应用中的 app：suspense：resolve 钩子详解

title: Nuxt.js 应用中的 app：suspense：resolve 钩子详解 date: 2024/10/6 updated: 2024/10/6 author: cmdragon excerpt: app:suspense:resolve 是一个强大的钩子，允许开发者在异步数据解析完成后的最后一步执行必要的处理。通过合理使用该钩子，我们可以优化组件的渲染…
阅读更多...
AI赋能，旅游新纪元，看旅游大厂携程的AI实践

AI赋能，旅游新纪元，看旅游大厂携程的AI实践

大家好，我是Shelly，一个专注于输出AI工具和科技前沿内容的AI应用教练，体验过300款以上的AI应用工具。关注科技及大模型领域对社会的影响10年。关注我一起驾驭AI工具，拥抱AI时代的到来。 国庆假期马上过去了，2024年国庆…
阅读更多...
智能制造的人机料法环的内涵

智能制造的人机料法环的内涵

在生产和管理领域，有个很重要的概念叫 “人、机、料、法、环”。 “人” 就是参与其中的人员，他们的技能、态度、责任心等对事情的结果影响很大； “机” 指的是机器设备和工具等，就像干活要用的家伙事儿，好不好用、正不正常直接关系到工作的效率和质量； “料” 呢，就…
阅读更多...
【动态规划-最长公共子序列（LCS）】【hard】【科大讯飞笔试最后一题】力扣115. 不同的子序列

【动态规划-最长公共子序列（LCS）】【hard】【科大讯飞笔试最后一题】力扣115. 不同的子序列

给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数，结果需要对 10^9 7 取模。 示例 1： 输入：s “rabbbit”, t “rabbit” 输出：3 解释： 如下所示, 有 3 种可以从 s 中得到 “rabbit”…
阅读更多...
手撕正弦-余弦位置编码（Sinusoidal Positional Encoding）

手撕正弦-余弦位置编码（Sinusoidal Positional Encoding）

改写后的代码： import torch import math import torch.nn as nnclass PositionalEncoder(nn.Module):def __init__(self, d_model, max_seq_len80):super().__init__()self.d_model d_model# 根据 pos 和 i 创建一个常量 PE 矩阵pe torch.zeros(max_seq_len, d_…
阅读更多...
【unity游戏开发】彻底理解AnimatorStateInfo，获取真实动画长度

【unity游戏开发】彻底理解AnimatorStateInfo，获取真实动画长度

前言 前置知识：设置参数后，下一个循环才会切换对应动画，所以在下一个循环获取真实的动画长度 AnimatorStateInfo是结构体！值类型，要不断重复获取才是最新的 主要是自动设置trigger切换的动画自动切回上一个动画&#x…
阅读更多...
Linux命令：用于管理 Linux 系统中用户组的命令行工具gpasswd详解

Linux命令：用于管理 Linux 系统中用户组的命令行工具gpasswd详解

目录 一、概述 二、使用方法 1、 基本语法 2、 常用选项 （1）无选项（仅组名） （2）-a 用户 （3）-d 用户 （4）-M 用户列表 （5）-A 管…
阅读更多...
系统架构设计师-下午案例题（2021年下半年）

系统架构设计师-下午案例题（2021年下半年）

1.试题一(共25分) 阅读以下关于软件架构设计与评估的叙述在答题纸上回答问题1和问题2。 【说明】某公司拟开发一套机器学习应用开发平台支持用户使用浏览器在线进行基于机器学习的智能应用开发活动。该平台的核心应用场景是用户通过拖拽算法组件灵活定义机器学习流程&#xf…
阅读更多...
【Linux】信号知识三把斧——信号的产生、保存和处理

【Linux】信号知识三把斧——信号的产生、保存和处理

目录​​​​​​​ 1、关于信号的前置知识 1.1.什么是信号？ 1.2.为什么要学习信号？ 1.3.如何学习信号？ 1.4.一些常见的信号 1.5.信号的处理方式 1.6.为什么每一个进程都可以系统调用？ 2.信号的产生 2.1.kill命令产生信号…
阅读更多...
[Python学习日记-40] 函数进阶之装饰器

[Python学习日记-40] 函数进阶之装饰器

[Python学习日记-40] 函数进阶之装饰器 简介 引子 什么是装饰器 装饰器终结版 装饰器的层层叠加 简介 在前面铺垫了这么多终于该讲到重点了，前面说的匿名函数、高阶函数、闭包等等都是为了这篇文章所讲的装饰器而使用的，本篇文章将会一一个故事通俗…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023