凯哥带你从零学大数据系列之Java篇---第二十六章 IO流详解_jdkio流(2)

最新推荐文章于 2024-07-29 09:10:44 发布
最新推荐文章于 2024-07-29 09:10:44 发布
阅读量570 收藏 25
点赞数 8
分类专栏： 程序员 文章标签： 大数据 面试 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84165953/article/details/138711102
版权

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

        // 流的关闭，不能放到try里面。需要放到finally中。
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } finally {
        // 流在使用结束之后，一定要进行关闭。
        if (inputStream != null) {
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

}


#### **2.3.2. try结构的特使使用**


在 JDK1.7 之后， 可以在try后面添加一对小括号。 将 AutoClosable 接口实现类的对象， 实例化放到小括号中完成。 此时， 在try结构执行结束的时候， 会自动的调用AutoClosable接口实现类中的close方法， 进行流的关闭。 这样写的流的建立比较简单， 也是后面我们最主要使用的方式。

import java.io.*;

/**

  • @Description 常见的IO流的创建的方式
    /
    public class IO2 {
    public static void main(String[] args) {
    /    *
    * try结构的特殊语法: try ()
    * 将 AutoClosable 接口的实现类对象的实例化放到小括号中。
    * 此时，在离开了try结构的时候，会自动的对这个类进行close方法的调用
    */
    try (InputStream inputStream = new FileInputStream(“file\day25\source”)) {
    // 数据的读取操作
    } catch (FileNotFoundException e) {
    e.printStackTrace();
    } catch (IOException e) {
    e.printStackTrace();
    }
    System.out.println(new File(“file\day25\source”).delete());
    }
    }

### **2.4. InputStream**


#### **2.4.1. InputStream简介**


这是一个字节输入流。 从方向来说， 是一个输入流， 数据是从文件中流动到程序中， 是为了读取文件中的数据的。 从数据单位来说， 这个流中流动的数据是以字节为单位的。


#### **2.4.2. 文件的读取**

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

/**

  • @Description 使用字节流进行数据的读取
    */
    public class InputStreamTest {
    public static void main(String[] args) {
    // 1. 建立程序与文件之间的连接，用来读取这个文件
    try (InputStream inputStream = new FileInputStream(“file\day25\source”)) {
    // 2. 读取字节流中的数据，需要有一个字节数组，用来读取数据
    // 这个数组长度，不用和文件一样大小，找一个大小合适的数组读取即可
    byte[] array = new byte[32];
    // 3. 声明一个整型变量，用来记录每次读取了多少个字节的数据
    int length = 0;
    // 3. 循环读取数据
    while ((length = inputStream.read(array)) != -1) {
    // 将读取到的字节数组中的数据，转成字符串输出
    // 为了去除最后一次进行读取数据的时候，上次读取残留的问题
    // 最后一次读取的数据，只有指定部分是我们需要的数据
    String str = new String(array, 0, length);
    System.out.print(str);
    }
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    }

### **2.5. OutputStream**


#### **2.5.1. OutputStream简介**


字节输出流。 从方向上来分， 是一个输出流， 数据从程序中流动到文件中， 实现文件的写操作。 从流中流动的数据单位来分， 是一个字节流， 流中流动的数据是以字节为单位的。


**2.5.2. 文件的写**

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

/**

  • @Description 字节输出流，写文件
    */
    public class OutputStreamTest {
    public static void main(String[] args) {
    // 1. 实例化一个管道，连接文件和程序。
    // 对于FileOutputStream来说，如果目标文件不存在，则会自动的创建。
    // 当无法创建这个文件的时候(父级目录不存在)，创建会失败，会触发 FileNotFoundException 。
    try (OutputStream outputStream = new FileOutputStream(“file\day25\dst”, true)) {
    // 2. 准备需要写入到这个文件中的数据
    String message = “你好，师姐”;
    // 3. 将数据写入到输出流中，由输出流写入到文件中
    outputStream.write(message.getBytes());

         // 冲刷缓冲区，将缓冲区中的数据强制流动到文件中。
     // 在流关闭的时候，会自动的调用。
     outputStream.flush();
 } catch (IOException e) {
     e.printStackTrace();
 }

    }
    }
    ​


### **2.6. 案例: 文件拷贝**


#### **2.6.1. 需求分析**


实现， 将一个文件拷贝到另外一个地方。 注意， 这个不是剪切， 拷贝完成之后， 原文件还在。


实现方式： 借助两个流来完成。


* 使用字节流输入， 循环读取原文件中的数据。
* 使用字节输出流， 将每次读取到的数据， 写入到目标文件中。


#### **2.6.2. 示例代码**

import java.io.*;

/**

  • @Description 使用字节流实现文件的拷贝
    */
    public class FileCopy {
    public static void main(String[] args) {
    boolean ret = copy(“C:\Users\luds\Desktop\src.mp4”, “C:\Users\luds\Desktop\dst.mp4”);
    System.out.println(ret);
    }

    /**

    • 实现功能: 将源文件中的数据拷贝到目标文件
    • @param srcPath 原文件路径
    • @param dstPath 目标文件路径
    • @return 拷贝的结果
      */
      private static boolean copy(String srcPath, String dstPath) {
      // 1. 判断目标路径上，是否有文件存在
      File dst = new File(dstPath);
      if (dst.exists()) {
      return false;
      }
      // 2. 实现文件的拷贝
      try (InputStream inputStream = new FileInputStream(srcPath);
      OutputStream outputStream = new FileOutputStream(dst)) {
      // 拷贝的过程
      // 2.1. 实例化一个字节数组
      byte[] array = new byte[1024];
      // 2.2. 声明一个整型变量，用来记录每次读取到了多少个字节的数据
      int length = 0;
      // 2.3. 循环读取数据
      while ((length = inputStream.read(array)) != -1) {
      // 2.4. 将读取到的数据，写入到输出流中
      outputStream.write(array, 0, length);
      }
      // 2.5. 冲刷缓冲区
      outputStream.flush();
      return true;
      }
      catch (IOException e) {
      e.printStackTrace();
      return false;
      }
      }
      }

### **2.7. Reader**


#### **2.7.1. Reader的简介**


这是一个字符输入流。 从方向来说， 是一个输入流， 数据是从文件中流动到程序中， 是为了读取文件中的数据的。 从数据单位来说， 这个流中流动的数据是以字符为单位的。


#### **2.7.2. 读取文件**

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

/**

  • @Description 字符输入流读取数据
    */
    public class ReaderTest {
    public static void main(String[] args) {
    // 读取过程与字节输入流完全相同，只需要将使用到的类换一下即可。
    try (Reader reader = new FileReader(“file\day25\src”)) {
    // 1. 实例化一个字符数组
    char[] array = new char[100];
    // 2. 声明一个变量，用来记录每次读取到了多少个数据
    int length = 0;
    // 3. 循环读取数据
    while ((length = reader.read(array)) != -1) {
    String str = new String(array, 0, length);
    System.out.print(str);
    }
    }
    catch (IOException e) {
    e.printStackTrace();
    }
    }
    }

### **2.8. Writer**


#### **2.8.1. Writer的简介**


字符输出流。 从方向上来分， 是一个输出流， 数据从程序中流动到文件中， 实现文件的写操作。 从流中流动的数据单位来分， 是一个字符流， 流中流动的数据是以字符为单位的。


#### **2.8.2. 文件的写操作**

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

/**

  • @Description 使用字符流写数据
    */
    public class WriterTest {
    public static void main(String[] args) {
    // 1. 实例化相关的类
    try (Writer writer = new FileWriter(“file\day25\target”, true)) {
    // 2. 将数据写入到输出流中
    writer.write(“hello, world”);
    // 3. 冲刷缓冲区
    writer.flush();
    }
    catch (IOException e) {
    e.printStackTrace();
    }
    }
    }


**2.9. 案例: 文件拷贝**


#### **2.9.1. 需求分析**


实现， 将一个文件拷贝到另外一个地方。 注意， 这个不是剪切， 拷贝完成之后， 原文件还在。


实现方式： 借助两个流来完成。


* 使用字符输入流， 循环读取原文件中的数据。
* 使用字符输出流， 将每次读取到的数据， 写入到目标文件中。


#### **2.9.2. 示例代码**

/**

  • 使用字符流实现文件的拷贝
  • @param srcPath 原文件路径
  • @param dstPath 目标文件路径
    */
    private static void fileCopy2(String srcPath, String dstPath) {
    // 2. 循环读取目标文件中的数据
    try (Reader reader = new FileReader(srcPath); Writer writer = new FileWriter(dstPath)) {
    // 3. 循环读取源文件中的数据
    char[] array = new char[100];
    int length = 0;
    while ((length = reader.read(array)) != -1) {
    // 4. 将读取到的数据写入到输出流
    writer.write(array, 0, length);
    }
    writer.flush();
    return true;
    }
    catch (IOException e) {
    e.printStackTrace();
    return false;
    }
    }

**3. 常见的其他流**


### **3.1. 缓冲流**


#### **3.1.1. 缓冲流的简介**


给普通的IO流， 套上一个缓冲区。 所有的使用缓冲流进行的读写操作， 都是和缓冲区进行交互的， 避免了频繁的IO操作。 这样一来， 带来的好处就是可以提高读写的效率。 这个缓冲区， 其实是一个数组。


**常见的缓冲流:**


* BufferedInputStream : 缓冲字节输入流
* BufferedOutputStream ： 缓冲字节输出流
* BufferedReader ： 缓冲字符输入流
* BufferedWriter ： 缓冲字符输出


#### **3.1.2. 缓冲字节流**

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

/**

  • @Description BufferedInputStream使用
    */
    public class BufferedInputStreamTest {
    public static void main(String[] args) {
    // 过程和InputStream一模一样的
    // 缓冲字节输入流流是需要基于一个字节输入流来进行实例化的
    // 在这里，BufferedInputStream构造方法中的InputStream对象，只是用来做当前的对象的实例化，在使用结束的时候，理论上来讲，是需要关闭的
    // 实际在使用中，使用结束后，只需要关闭BufferedInputStream即可。
    try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(“file\day26\source”))) {
    // 1. 实例化一个字节数组
    byte[] array = new byte[1024];
    // 2. 声明一个整型变量，用来记录每次读取了多少个字节数据
    int length = 0;
    // 3. 循环读取
    while ((length = bufferedInputStream.read(array)) != -1) {
    // 4. 将读取到的数据转成字符串输出到控制台
    String msg = new String(array, 0, length);
    System.out.println(msg);
    }
    }
    catch (IOException e) {
    e.printStackTrace();
    }
    }
    }

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

/*

  • @Description BufferedOutputStream
    */
    public class BufferedOutputStreamTest {
    public static void main(String[] args) {
    // 1. 实例化一个缓冲字节输出流对象
    try (BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(“file\day26\target”))) {
    // 2. 将数据写入到输出流中
    bufferedOutputStream.write(“hello world”.getBytes());
    bufferedOutputStream.flush();
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    }

#### **3.1.3. 缓冲字符流**

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/**

  • @Description
    */
    public class BufferedReaderTest {
    public static void main(String[] args) {
    // 借助一个字符流，实例化一个缓冲字符输入流
    try (BufferedReader bufferedReader = new BufferedReader(new FileReader(“file\day26\src”))) {
    // 从流中读取数据
    char[] array = new char[100];
    int length = 0;
    while ((length = bufferedReader.read(array)) != -1) {
    System.out.print(new String(array, 0, length));
    }
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    }

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/**

  • @Description
    */
    public class BufferedWriterTest {
    public static void main(String[] args) {
    // 借助一个字符输出流，实例化一个缓冲字符输出流对象
    try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(“file\day26\dst”))) {
    bufferedWriter.write(“hello world”);
    bufferedWriter.flush();
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    }

#### **3.1.4. 缓冲流中的特殊方法**


**BufferedReader** 类中多了一个方法 **readLine()**


* 意义: 读取缓冲流中的一行数据， 可以逐行读取。 一直到读取到的数据是null， 表示数据读取完了， 没有下一行数据了。
* 注意事项: readLine() 是逐行读取， 但是， 只能读取到一行中的内容， 并不能读取走换行符。

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

/*

  • @Date 2020/4/26
  • @Description
    */
    public class BufferedReaderSpecial {
    public static void main(String[] args) {
    try (BufferedReader reader = new BufferedReader(new FileReader(“file\day26\src”))) {
    // 1. 定义一个字符串，用来接收每一行读取到的数据
    String line = “”;
    // 2. 循环读取数据
    while ((line = reader.readLine()) != null) {
    // 3. 将读取到的数据输出
    System.out.println(line);
    }
    } catch (IOException e) {
    e.printStackTrace();
    }
    }

**BufferedWriter** 类中多了一个方法 **newLine()**


* 意义： 无参的方法， 写一个换行符。

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/**

  • @Description
    */
    public class BufferedWriterSpecial {
    public static void main(String[] args) {
    try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(“file\day26\dst”))) {
    bufferedWriter.write(“hello world”);
    bufferedWriter.newLine();
    bufferedWriter.write(“你好，世界”);
    bufferedWriter.newLine();
    bufferedWriter.write(“end”);
    } catch (IOException e) {
    e.printStackTrace();
    }
    }
    }

**使用缓冲字符流进行文件的拷贝**

import java.io.*;

/**

  • @Description 使用缓冲字符流实现文本文件的拷贝
    */
    public class BufferedCopy {
    public static void main(String[] args) {
    try (BufferedReader reader = new BufferedReader(new FileReader(“file\day26\src”));
    BufferedWriter writer = new BufferedWriter(new FileWriter(“file\day26\destination”))) {
    String line = “”;
    while ((line = reader.readLine()) != null) {
    writer.write(line);
    writer.newLine();
    }
    writer.flush();
    }
    catch (IOException e) {
    e.printStackTrace();
    }
    }

### **3.2. Scanner类**


#### **3.2.1. 简介**


这个类， 并不是一个IO流。 是一个扫描器， 这个类最主要的作用， 是从一个文件中或者从一个流中浏览数据。 在这个类中封装了若干个方法， 方便了数据的读取。


**3.2.2. API**


![](https://img-blog.csdnimg.cn/bb5aa07e9f6e4ffea242854012a8c3be.png)


**注意事项**


这里nextLine和BufferedReader中的readLine都可以读取一行数据。 但是区别在于： 结束条件不同。


* BufferedReader: 如果读取到的数据是null, 说明没有下一行数据了。
* Scanner: 如果没有下一行了，再去读取，会出现异常。 所以， 此时的结束条件是 hasNextLine() 为false。

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.regex.Pattern;

/**

  • @Description Scanner类的方法
    */
    public class ScannerTest {
    public static void main(String[] args) {
    // 其实，Scanner在使用结束之后，也是需要进行关闭的。 调用close方法。
    try (Scanner scanner = new Scanner(new File(“file\day26\src”))) {
    // 读取文件中的内容
    while (scanner.hasNextLine()) {
    System.out.println(scanner.hasNextLine());
    }
    } catch (FileNotFoundException e) {
    e.printStackTrace();
    }
    }



![img](https://img-blog.csdnimg.cn/img_convert/5414cefb944e33a2251cf20b4ecb539a.png)
![img](https://img-blog.csdnimg.cn/img_convert/7e8c5e1579c8b62a2a2e731931065487.png)
![img](https://img-blog.csdnimg.cn/img_convert/53965455846a75635bb6a7792d7dc711.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**

\day26\\src"))) {
            // 读取文件中的内容
            while (scanner.hasNextLine()) {
                System.out.println(scanner.hasNextLine());
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

[外链图片转存中…(img-OVDzl2uh-1715403828550)]
[外链图片转存中…(img-TrqlSZTS-1715403828550)]
[外链图片转存中…(img-9SoHyMWp-1715403828550)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

2401_84165953
关注
  • 8
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
GB_T15843.6-2018信息技术_安全技术_实体鉴别第6部分：采用人工数据传递的机制.pdf
05-27
GB_T15843.6-2018信息技术_安全技术_实体鉴别第6部分：采用人工数据传递的机制
Java-飞机大战小游戏
03-31
本项目“Java-飞机大战小游戏”将带你深入理解如何利用Java技术来构建一款简单但趣味十足的飞机大战游戏。下面我们将详细探讨其中的关键技术和实现步骤。 首先，游戏的核心是游戏循环（Game Loop），它负责处理游戏...
凯哥带你从零学大数据系列之Java篇---第二十六章 IO流详解_jdkio流
2401_84181273的博客
04-27 957
/ 如果需要以指定的字符集进行文件的读取，需要使用 InputStreamReader(InputStream inputStream, String charsetName)(img-0fOmINHs-1714183345483)](img-H6PBr4UQ-1714183345484)]// PrintStream: 是一个打印流，可以将数据输出到指定位置。// 当前的项目是 utf-8, 读取的文件是 GBK。@Description 使用字节流实现文件的拷贝。// 重定向标准输出流。
凯哥带你从零学大数据系列之Java篇---第二十六章 IO流详解_jdkio流(1)
2401_84165953的博客
05-11 854
/ 如果需要以指定的字符集进行文件的读取，需要使用 InputStreamReader(InputStream inputStream, String charsetName)ObjectInputStream、 ObjectOutputStream， 主要是用来做对象的序列化和反序列化的。// PrintStream: 是一个打印流，可以将数据输出到指定位置。序列化、 反序列化， 是对象的持久化存储的一种常用手段。// 当前的项目是 utf-8, 读取的文件是 GBK。// 重定向标准输出流。
凯哥带你从零学大数据系列之Java篇---第二十六章:IO流详解
关注我！带你一路 "狂飙" 到底！
06-29 565
此时， 在try结构执行结束的时候， 会自动的调用AutoClosable接口实现类中的close方法， 进行流的关闭。从流中流动的数据单位来分， 是一个字节流， 流中流动的数据是以字节为单位的。从流中流动的数据单位来分， 是一个字符流， 流中流动的数据是以字符为单位的。从方向来说， 是一个输入流， 数据是从文件中流动到程序中， 是为了读取文件中的数据的。从方向来说， 是一个输入流， 数据是从文件中流动到程序中， 是为了读取文件中的数据的。流: 指的是一串流动的数据， 在数据在流中按照指定的方向进行流动。
凯哥带你从零学大数据系列之Java篇---第二十五章 文件操作详解
2401_84301352的博客
04-29 325
如果你的程序只需要考虑部署在windows平台， 那么只需要按照windows的规范书写就可以；如果你的程序只需要部署到linux上， 那么只需要按照linux的规范书写就可以。但是， 如果你的程序需要考虑在不同的平台上部署运行， 此时就需要使用以下方法进行分隔符的获取。理论上来讲， 在windows中， 应该使用\作为目录分隔符。在不同的操作系统中， 目录分隔符是不一样的。在不同的操作系统中， 路径分隔符是不一样的。分隔开一个路径中的不同的文件夹， 用来描述层级关系、 包含关系。
大数据最全凯哥带你从零学大数据系列之Java篇---第二十五章 文件操作详解
2401_84181564的博客
05-04 650
如果你的程序只需要考虑部署在windows平台， 那么只需要按照windows的规范书写就可以；但是， 如果你的程序需要考虑在不同的平台上部署运行， 此时就需要使用以下方法进行分隔符的获取。理论上来讲， 在windows中， 应该使用\作为目录分隔符。**绝对路径：**从磁盘的根目录开始， 一层层的向下查找， 直到找到这个文件。在不同的操作系统中， 目录分隔符是不一样的。在windows中， 使用。在不同的操作系统中， 路径分隔符是不一样的。分隔开一个路径中的不同的文件夹， 用来描述层级关系、 包含关系。
凯哥带你从零学大数据系列之Java篇---第二十五章 文件操作详解(2)
2401_84181731的博客
05-15 573
如果你的程序只需要考虑部署在windows平台， 那么只需要按照windows的规范书写就可以；但是， 如果你的程序需要考虑在不同的平台上部署运行， 此时就需要使用以下方法进行分隔符的获取。理论上来讲， 在windows中， 应该使用\作为目录分隔符。**绝对路径：**从磁盘的根目录开始， 一层层的向下查找， 直到找到这个文件。在不同的操作系统中， 目录分隔符是不一样的。在windows中， 使用。在不同的操作系统中， 路径分隔符是不一样的。分隔开一个路径中的不同的文件夹， 用来描述层级关系、 包含关系。
凯哥带你从零学大数据系列之Java篇---第二十五章 文件操作详解(1)
kenzsoft的博客
05-07 800
如果你的程序只需要考虑部署在windows平台， 那么只需要按照windows的规范书写就可以；但是， 如果你的程序需要考虑在不同的平台上部署运行， 此时就需要使用以下方法进行分隔符的获取。理论上来讲， 在windows中， 应该使用\作为目录分隔符。**绝对路径：**从磁盘的根目录开始， 一层层的向下查找， 直到找到这个文件。在不同的操作系统中， 目录分隔符是不一样的。在windows中， 使用。在不同的操作系统中， 路径分隔符是不一样的。分隔开一个路径中的不同的文件夹， 用来描述层级关系、 包含关系。
凯哥带你从零学大数据系列之Java篇---第二十五章 文件操作详解(4)
2401_84186026的博客
05-07 616
如果你的程序只需要考虑部署在windows平台， 那么只需要按照windows的规范书写就可以；如果你的程序只需要部署到linux上， 那么只需要按照linux的规范书写就可以。但是， 如果你的程序需要考虑在不同的平台上部署运行， 此时就需要使用以下方法进行分隔符的获取。理论上来讲， 在windows中， 应该使用\作为目录分隔符。在不同的操作系统中， 目录分隔符是不一样的。在不同的操作系统中， 路径分隔符是不一样的。分隔开一个路径中的不同的文件夹， 用来描述层级关系、 包含关系。
凯哥带你从零学大数据系列之Java篇---第二十五章 文件操作详解(3)
2401_84186026的博客
05-07 408
是对磁盘上的某一个文件、文件夹（目录）的描述。所谓的文件操作， 其实都是需要使用这个类来完成的。
凯哥三论数据中台 外发版.pdf
07-02
凯哥三论数据中台 外发版.pdf
千峰凯哥python第3章 Django
05-15
此文件是凯哥Python基础第三章的讲义文件目录如下 1、Django基本流程走通 2、Django中的模型 3、Django中的视图 4、Django中的模板 5、Django的高级使用 6、Django爱鲜蜂项目第一天 7、Django爱鲜蜂项目第二天 8、...
千峰凯哥python第2章 前端基础
05-15
此文件是凯哥Python基础第四章的讲义文件目录如下 1、html&css;基础 2、html&css;提升 3、JavaScript基础 4、JavaScript提升 5、JavaScript进阶与轮播和飞机大战坦克 6、JQuery基础 7、JQuery提升 8、H5C3基础 9、...
分布式系统常见软件架构模式
Ben的专栏
07-25 1023
简而言之，有效管理数据和通信流对于构建健壮且可扩展的分布式系统至关重要。对等、API 网关、发布-订阅、请求-响应、事件溯源、ETL、批处理、流处理和编排等架构模式提供了有价值的解决方案，以应对系统设计和实现中的各种挑战。通过理解这些软件架构和分布式系统模式及其各自的优势和权衡，架构师和开发人员可以做出明智的决策，设计出满足其应用程序和用户不断变化的需求的系统。
消息队列-rabbitmq（生产者.消费者. 消息.可靠性）
2202_75352238的博客
07-28 794
在我们 生产者发送消息到交换机的时候，假如 我们发送到交换机 ，但是 队列没有收到消息，会返回ack，发送到交换机，然后发送到队列，消费者没有接收到消息返回ack，但是发送到交换机失败，会返回nack。死信交换机 ，都是假如一个定时消息过期了，或者发送延迟消息我们直接把该消息传递到我们绑定的死信交换机中，跟上文 消息发送失败了返回rejct之后，消息发送到err交换机是两种不同的策略。当一条消息发送失败的时候，消费者重新尝试消费消息，达到我们重试的次数之后，消费者返回reject，mq直接删除消息。
Kafka知识总结（选举机制+控制器+幂等性）
月伴飞鱼
07-27 1017
其他Broker启动时也会在Zookeeper中创建临时节点，但是发现节点已经存在，所以它们会收到一个异常，意识到控制器已经存在，那么就会在Zookeeper中创建Watch对象，便于它们收到控制器变更的通知。他只能保证单分区上的幂等性，即一个幂等性Producer只能够保证某个topic的一个分区上不出现重复消息，无法实现多分区的幂等。控制器上保存了最全的集群元数据信息，其他所有 Broker 会定期接收控制器发来的元数据更新请求，从而更新其内存中的缓存数据。目前，当有新 Broker 启动后，它会在。
基于 SASL/SCRAM 让 Kafka 实现动态授权认证
最新发布
zlt2000的博客
07-29 461
本文将从零开始部署ZooKeeper和Kafka并通过配置SASL/SCRAM和ACL（访问控制列表）来增强Kafka的安全性
docker下载jdk镜像文件
08-19
要在Docker中下载JDK镜像文件，您可以使用以下命令： ``` docker pull <镜像名称> ``` 对于OpenJDK的官方镜像，可以使用以下命令来下载： ``` docker pull openjdk ``` 如果您需要特定版本的JDK，可以指定标签，例如： ``` docker pull openjdk:11 ``` 这将下载OpenJDK 11版本的镜像文件。请注意，您需要确保已经安装并配置了Docker。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值