尚硅谷—初级—IO 流、NIO（581~617）

张老师的分享

已于 2023-10-27 17:06:40 修改

阅读量263

点赞数 1

分类专栏：一：Java_基础文章标签： java

于 2021-05-02 08:58:23 首次发布

本文链接：https://blog.csdn.net/qq_43056248/article/details/116347432

版权

一：Java_基础专栏收录该内容

8 篇文章 5 订阅

订阅专栏

标准输入、输出流（了解）
打印流（了解）
数据流（了解）
随机存取文件流（了解）
NIO.2 中，Path，Paths，Files 类的使用

七：NIO.2 中 Path、Paths、Files 类的使用（了解）：

一.`File 类的使用`：

二：IO 流的原理及流的分类

1）java IO 原理
d：输入输出：（都是相对于程序而言）（读进来Input，写出去Output）
    -1.输入（input）：读取外部数据到内存中
    -2.输出（output）：内存中数据写到外面

2）流的分类：
d：按照操作数据的基本单位不同：

d：按数据的流向分类
    -1.输入流：
    -2.输出流：

d：按流的角色分类
    -1.节点流：直接作用在文件上。
    -2.处理流：包在节点流外面的流，包了一层。

d：IO 流体系图片
    -1.分清字节流，字符流（字节流为Stream，字符流为 Reader）
    -2.分清输入流，输出流（input 为输入，output 为输出）
    -3.分清节点流，处理流（访问文件为节点流，以下其他都为处理流）
    -4.蓝色的为常用的：

三：节点流（文件流）

1）使用io流，读取文件内容
d：read():
    -1.read()的理解：返回读取的一个字符。返回读到的char。如果读到文件末尾，则返回-1
    -2.read( char[] c )：一下读取一个 char 数组长度，返回读取的长度。

b：异常的处理：
    -1.为了保证流资源一定可以执行关闭操作，需要使用 try-catch-finally 进行异常处理。

c：读入的文件一定要存在，否则就会报 FileNotFoundException。

d：操作代码:

                FileReader fileReader = null;
                try {
                    //相对于当前module
                    File file = new File("d:" + File.separator + "ddd" + File.separator + "4.txt");
                    /*读取 文件 内容到 控制台 */
                    fileReader = new FileReader(file);
                    int read = 0;
                    while ((read = fileReader.read()) != -1) {
                        System.out.print((char) read);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                     try {
                         //保证流不为空
                         if (fileReader != null) {
                             fileReader.close();
                         }
                    } catch (IOException e) {
                         e.printStackTrace();
                    }
                }

e：使用 read(char[] aa)

                     char[] chars = new char[3];
                     int read;
                     while ((read = fileReader.read(chars)) != -1) {

                         // 方式 一：
                         for (int i = 0; i < len; i++) {
                             System.out.print(chars[i]);
                         }
                        
                         // 方式 二：
                         String s = new String(chars, 0, len);
                         System.out.print(s);
                     }

f：使用io流，往文本里写数据：

    public static void main(String[] args) throws IOException {

        File file = new File("/Users" + File.separator + "zhangsan" + File.separator + "workspace" + File.separator + "renren_vue" + File.separator + "mall-test" + File.separator + "my_test_01" + File.separator + "src" + File.separator + "main" + File.separator + "resources" + File.separator + "application.properties");
        boolean ee = file.exists();
        System.out.println(ee);

        FileWriter fileWriter = new FileWriter(file, true);
        String s = new String("server.port=8080");
        fileWriter.write(s);
        fileWriter.flush();
        fileWriter.close();
    }

g：使用io流，实现文本文件的复制：（内存层面不读，使用子节流也行）（使用字符流：.txt；.java ）

    public static void main(String[] args) throws IOException {

        File file = new File("/Users" + File.separator + "zhangsan" + File.separator + "workspace" + File.separator + "renren_vue" + File.separator + "mall-test" + File.separator + "my_test_01" + File.separator + "src" + File.separator + "main" + File.separator + "resources" + File.separator + "application.properties");
        File fil2 = new File("/Users" + File.separator + "zhangsan" + File.separator + "workspace" + File.separator + "renren_vue" + File.separator + "mall-test" + File.separator + "my_test_01" + File.separator + "src" + File.separator + "main" + File.separator + "resources" + File.separator + "application2.properties");
        FileReader fileReader = new FileReader(file);
        FileWriter fileWriter = new FileWriter(fil2);

        int len = 0;
        char[] chars = new char[5];
        while ((len = fileReader.read(chars)) != -1) {
            fileWriter.write(new String(chars, 0, len));
        }
        fileReader.close();
        fileWriter.close();
    }

h：使用io流，实现图片或者视频的复制：（非文本文件：使用子节流处理）

    public static void main(String[] args) throws IOException {

        File file = new File("/Users/zhangsan/Pictures/WechatIMG185.png");
        File fil2 = new File("/Users/zhangsan/Pictures/22222.png");
        FileInputStream fileInputStream = new FileInputStream(file);
        FileOutputStream fileOutputStream = new FileOutputStream(fil2);

        int len = 0;
        byte[] bytes = new byte[5];
        while ((len = fileInputStream.read(bytes)) != -1) {
            fileOutputStream.write(bytes, 0, len);
        }
        fileOutputStream.close();
        fileInputStream.close();
    }

四：缓冲流

1）缓冲流：
a：为处理流的一种，主要作用，就是为了提高文件的读写效率。

2）使用方法：
a：只是在 FileInputStream 外面的基础上，多套了一层处理流 BufferedInputStream，
b：还是使用 byte[] 数组存数据，

3）关闭缓冲流：
a：先关闭外面流，在关闭里面流。但是关闭外层流的同时，内层流会自动被关闭。

4）是清空缓冲区：
a：BufferOutputStream 有 flush() 方法，。

5）使用缓冲流，复制图片。flush(),
a：使用缓冲流，赋值文本。readLine()，newLine()。

五：转换流

1）转换流：（属于字符流、处理流）
d：提供了在字节流和字符流之间的转换。
b：InputStreamReader：将一个字节输入流 --> 字符输入流。（InputStream --> Reader）
c：OutputStreamWriter：将一个字符输出流 --> 字节输出流。（Writer --> OutputStream）

2）作用：
a：可以用节流，b读取文本数据，转换成字符流在控制台展示，再将字符流转换为字节流，写到文本中。

b：也可以进行，文本编码集的转换。

3）方法：
a：read() 方法：同样是使用，read() 方法读取，创建转换流时候，可以指定编码。

4）使用：

        File file1 = new File("");
        FileInputStream fileInputStream1 = new FileInputStream(file1);
        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream1);

五：对象流

1）对象流作用：
a：用于存储和读取，基本数据类型数据，或者对象的处理流：
    -1.他的强大之处，就是可以把，Java中的对象，写入到数据源中，也能把对象从数据源中还原回来。

2）ObjectInputStream 和 ObjectOutputStream（读对象和写出去对象）（子节流）

3）使用场景：
a：序列化：
    -1.用 ObjectOutputStream 类保存基本类型数据或者对象的机制

b：反序列化：
    -1.用 ObjectInputStream 类读取基本类型数据或者对象的机制

c：注意：
    -1.不能序列化 static 和 transient 修饰的成员变量。
    -2.对象是可序列化的，要实现 Serializable 接口
    -3.写序列化版本号：public static final long serialVersionUID = 213123123L;
    -4.除了实现接口之外，还要保证，类里面属性，都要是可序列化的，
  （默认情况下，基本数据类型，都可以序列化）

4）代码：

    public static void main(String[] args) throws IOException, ClassNotFoundException {

//     写对象：：：
//        AA aa = new AA("张三", 15);
//        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(new File("/Users" + File.separator + "zhangsan" + File.separator + "workspace" + File.separator + "renren_vue" + File.separator + "mall-test" + File.separator + "my_test_01" + File.separator + "src" + File.separator + "main" + File.separator + "resources" + File.separator + "application.dat")));
//        objectOutputStream.writeObject(aa);
//        objectOutputStream.close();


//     读对象：：：
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(new File("/Users/zhangsan/workspace/renren_vue/mall-test/my_test_01/src/main/resources/application.dat")));
        AA aa = (AA) objectInputStream.readObject();
        System.out.println(aa);
    }


@Data
class AA implements Serializable {

    private static final long serialVersionUID = 42L;

        private String name;
        private Integer age;
        private String addr;
   }
}

5）serialVersionUID：（序列化和反序列化确保一致性）
a：写序列化版本号：public static final long serialVersionUID = 213123123L;

六：随机存储文件流：（可以存，可以取）

1）RandomAccessFile 类的使用
a：RandomAccessFile：直接继承于 java.lang.Object 类，实现了 DataInput 和 DataOutput 接口
b：RandomAccessFile：既可以作为一个输入流，又可以作为一个输出流。

2）代码：（读写文件，需要两个流）

    public static void main(String[] args) throws Exception {
        File file = new File("");
        RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");
        // 获取指针的位置。
        long filePointer = randomAccessFile.getFilePointer();
        // 移动指针的位置，到指定位置读写：
        randomAccessFile.seek(100L);

        randomAccessFile.write(1234);
        randomAccessFile.close();

    }

   3）作为输出流时：
a：写出到文件，对原有文件内容，进行覆盖，默认从头覆盖，类似于 insert 方式。
   b：写出到文件，实现插入，可以使用 seek(long l) 方法。先调动插入指针，后插入。
    -1.如果获取文件内容大小，可以调用 File.length() 方法。

七：其他流的使用

1）标准的输入输出流：（了解）
   a：标准的输入流：
    -1.System.in：默认从键盘输入
b：标准的输出流：
    -1.System.out：默认从控制台输出

2）打印流：（了解）

a：printStream 和 printWriter：（都是输出流）
b：println()：点进去，就是打印流中的方法。
-1.提供了一系列重载的 print() 和 println()

3）数据流：（了解）

b：DataInputStream 和 DataOutputStream：（套接再InputStream上）
b：作用：
    -1.用于读取或者写出：基本数据类型的变量或者字符串。
    -2.读取：int ，boolean，等基本类型。
    -3.需要按照，写入顺序读取。

八：`NIO.2 中 Path、Paths、Files 类的使用`（了解）：

1）传统的IO流：
a：传统的IO流是阻塞式的，会一直监听一个ServerSocket，在调用read等方法时，他会一直等到数据到来或者缓冲区已满时才返回。
b：调用accept也是一直阻塞到有客户端连接才会返回。每个客户端连接过来后，服务端都会启动一个线程去处理该客户端的请求。
c：并且多线程处理多个连接。每个线程拥有自己的栈空间并且占用一些 CPU 时间。每个线程遇到外部未准备好的时候，都会阻塞掉。阻塞的结果就是会带来大量的进程上下文切换。
c：File 访问文件系统，功能有限，性能也不高。而且出错只返回失败，没有异常信息返回。

1）NIO分类：
a：标准的输入输出 NIO
b：网络编程 NIO

1）对于NIO，它是非阻塞式，核心类：
a：Buffer为所有的原始类型提供 (Buffer)缓存支持。
b：Charset 字符集编码解码解决方案。
c：Channel 一个新的原始 I/O抽象，用于读写Buffer类型，通道可以认为是一种连接，可以是到特定设备，程序或者是网络的连接。
2）NIO2 来历：
a：因为传统 IO 的效率低，java推出 NIO，以更加高效的方式，进行对文件的读写操作。
b：随着 JDK7 的发布，java 对 NIO 有了极大的扩展，增强对文件处理和文件系统特性的支持，以至于称他们为 NIO2。

4）NIO2 中，对于 Path，Paths，Files 类的使用。
a：Paths：可以理解为 NIO2 提供的 File 类。

    public static void main(String[] args) throws Exception {

        File file = new File("");
        //替换为
        Path path = Paths.get("");
    }

b：Path 常用方法：

c：Files

5）实际开发中：
c：多使用 commons.io 包，第三方的jar包，FileUtils 方法类调用方法，去执行 io 流操作。都给封装好了。

张老师的分享

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
尚硅谷—初级—IO 流、NIO（581~617）

一：File 类的使用1.File 类的理解（1）File 类的一个实例化对象，代表一个文件或者一个文件目录（俗称：文件夹）（2）File 类声明在 java.io 包下（3）File 类中涉及到，关于文件或者文件目录的操作方法，比如：创建，删除，重命名，修改时间文件大小等方法。并未涉及到写入或者读取文件内容的操作，如果涉及到文件中的内容，则需...
复制链接

扫一扫