首页 > 编程语言 >1.2w+字！Java IO 基础知识总结

1.2w+字！Java IO 基础知识总结

时间：2022-09-18 22:46:02浏览次数：80  
标签：字符 Java 读取 1.2 int write IO new 字节

IO 流简介

IO 即 Input/Output ，输入和输出。数据输入到计算机内存的过程即输入，反之输出到外部存储（比如数据库，文件，远程主机）的过程即输出。数据传输过程类似于水流，因此称为 IO 流。IO 流在 Java 中分为输入流和输出流，而根据数据的处理方式又分为字节流和字符流。

Java IO 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的。

  • InputStream / Reader : 所有的输入流的基类，前者是字节输入流，后者是字符输入流。

  • OutputStream / Writer : 所有输出流的基类，前者是字节输出流，后者是字符输出流。

字节流

InputStream（字节输入流）

InputStream 用于从源头（通常是文件）读取数据（字节信息）到内存中， java.io.InputStream 抽象类是所有字节输入流的父类。

InputStream 常用方法 ：

  • read() ：返回输入流中下一个字节的数据。返回的值介于 0 到 255 之间。如果未读取任何字节，则代码返回 -1 ，表示文件结束。

  • read(byte b[ ])
b
b
-1
b.length
read(b, 0, b.length)

  • read(byte b[], int off, int len)
read(byte b[ ])
off
len

  • skip(long n) ：忽略输入流中的 n 个字节 ,返回实际忽略的字节数。

  • available() ：返回输入流中可以读取的字节数。

  • close() ：关闭输入流释放相关的系统资源。

从 Java 9 开始， InputStream 新增加了多个实用的方法：

  • readAllBytes() ：读取输入流中的所有字节，返回字节数组。

  • readNBytes(byte[] b, int off, int len) ：阻塞直到读取 len 个字节。

  • transferTo(OutputStream out) ：将所有字节从一个输入流传递到一个输出流。

FileInputStream 是一个比较常用的字节输入流对象，可直接指定文件路径，可以直接读取单字节数据，也可以读取至字节数组中。

FileInputStream 代码示例：

  1. try (InputStream fis = new FileInputStream("input.txt")) {
  2.     System.out.println("Number of remaining bytes:"
  3.             + fis.available());
  4.     int content;
  5.     long skip = fis.skip(2);
  6.     System.out.println("The actual number of bytes skipped:" + skip);
  7.     System.out.print("The content read from file:");
  8.     while ((content = fis.read()) != -1) {
  9.         System.out.print((char) content);
  10.     }
  11. } catch (IOException e) {
  12.     e.printStackTrace();
  13. }

input.txt 文件内容：

输出：

  1. Number of remaining bytes:11
  2. The actual number of bytes skipped:2
  3. The content read from file:JavaGuide

不过，一般我们是不会直接单独使用 FileInputStream ，通常会配合 BufferedInputStream （字节缓冲输入流，后文会讲到）来使用。

像下面这段代码在我们的项目中就比较常见，我们通过 readAllBytes() 读取输入流所有字节并将其直接赋值给一个 String 对象。

  1. // 新建一个 BufferedInputStream 对象
  2. BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("input.txt"));
  3. // 读取文件的内容并复制到 String 对象中
  4. String result = new String(bufferedInputStream.readAllBytes());
  5. System.out.println(result);

DataInputStream 用于读取指定类型数据，不能单独使用，必须结合 FileInputStream 。

  1. FileInputStream fileInputStream = new FileInputStream("input.txt");
  2. //必须将fileInputStream作为构造参数才能使用
  3. DataInputStream dataInputStream = new DataInputStream(fileInputStream);
  4. //可以读取任意具体的类型数据
  5. dataInputStream.readBoolean();
  6. dataInputStream.readInt();
  7. dataInputStream.readUTF();

ObjectInputStream 用于从输入流中读取 Java 对象（反序列化）， ObjectOutputStream 用于将对象写入到输出流(序列化)。

  1. ObjectInputStream input = new ObjectInputStream(new FileInputStream("object.data"));
  2. MyClass object = (MyClass) input.readObject();
  3. input.close();

另外，用于序列化和反序列化的类必须实现 Serializable 接口，对象中如果有属性不想被序列化，使用 transient 修饰。

OutputStream（字节输出流）

OutputStream 用于将数据（字节信息）写入到目的地（通常是文件）， java.io.OutputStream 抽象类是所有字节输出流的父类。

OutputStream 常用方法 ：

  • write(int b) ：将特定字节写入输出流。

  • write(byte b[ ])
b
write(b, 0, b.length)

  • write(byte[] b, int off, int len)
write(byte b[ ])
off
len

  • flush() ：刷新此输出流并强制写出所有缓冲的输出字节。

  • close() ：关闭输出流释放相关的系统资源。

FileOutputStream 是最常用的字节输出流对象，可直接指定文件路径，可以直接输出单字节数据，也可以输出指定的字节数组。

FileOutputStream 代码示例：

  1. try (FileOutputStream output = new FileOutputStream("output.txt")) {
  2.     byte[] array = "JavaGuide".getBytes();
  3.     output.write(array);
  4. } catch (IOException e) {
  5.     e.printStackTrace();
  6. }

运行结果：

类似于 FileInputStream ， FileOutputStream 通常也会配合 BufferedOutputStream （字节缓冲输出流，后文会讲到）来使用。

  1. FileOutputStream fileOutputStream = new FileOutputStream("output.txt");
  2. BufferedOutputStream bos = new BufferedOutputStream(fileOutputStream)

DataOutputStream 用于写入指定类型数据，不能单独使用，必须结合 FileOutputStream

  1. // 输出流
  2. FileOutputStream fileOutputStream = new FileOutputStream("out.txt");
  3. DataOutputStream dataOutputStream = new DataOutputStream(fileOutputStream);
  4. // 输出任意数据类型
  5. dataOutputStream.writeBoolean(true);
  6. dataOutputStream.writeByte(1);

ObjectOutputStream 用于从输入流中读取 Java 对象（ ObjectInputStream ,反序列化）或者将对象写入到输出流( ObjectOutputStream ，序列化)。

  1. ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream("file.txt")
  2. Person person = new Person("Guide哥", "JavaGuide作者");
  3. output.writeObject(person);

字符流

不管是文件读写还是网络发送接收，信息的最小存储单元都是字节。 那为什么 I/O 流操作要分为字节流操作和字符流操作呢？

个人认为主要有两点原因：

  • 字符流是由 Java 虚拟机将字节转换得到的，这个过程还算是比较耗时。

  • 如果我们不知道编码类型就很容易出现乱码问题。

乱码问题这个很容易就可以复现，我们只需要将上面提到的 FileInputStream 代码示例中的 input.txt 文件内容改为中文即可，原代码不需要改动。

输出：

  1. Number of remaining bytes:9
  2. The actual number of bytes skipped:2
  3. The content read from file:§å®¶å¥½

可以很明显地看到读取出来的内容已经变成了乱码。

因此，I/O 流就干脆提供了一个直接操作字符的接口，方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好，如果涉及到字符的话使用字符流比较好。

字符流默认采用的是 Unicode 编码，我们可以通过构造方法自定义编码。顺便分享一下之前遇到的笔试题：常用字符编码所占字节数？ utf8 :英文占 1 字节，中文占 3 字节， unicode ：任何字符都占 2 个字节， gbk ：英文占 1 字节，中文占 2 字节。

Reader（字符输入流）

Reader 用于从源头（通常是文件）读取数据（字符信息）到内存中， java.io.Reader 抽象类是所有字符输入流的父类。

Reader 用于读取文本， InputStream 用于读取原始字节。

Reader 常用方法 ：

  • read() : 从输入流读取一个字符。

  • read(char[] cbuf)
cbuf
read(cbuf, 0, cbuf.length)

  • read(char[] cbuf, int off, int len)
read(char[] cbuf)
off
len

  • skip(long n) ：忽略输入流中的 n 个字符 ,返回实际忽略的字符数。

  • close() : 关闭输入流并释放相关的系统资源。

InputStreamReader 是字节流转换为字符流的桥梁，其子类 FileReader 是基于该基础上的封装，可以直接操作字符文件。

  1. // 字节流转换为字符流的桥梁
  2. public class InputStreamReader extends Reader {
  3. }
  4. // 用于读取字符文件
  5. public class FileReader extends InputStreamReader {
  6. }

FileReader 代码示例：

  1. try (FileReader fileReader = new FileReader("input.txt");) {
  2.     int content;
  3.     long skip = fileReader.skip(3);
  4.     System.out.println("The actual number of bytes skipped:" + skip);
  5.     System.out.print("The content read from file:");
  6.     while ((content = fileReader.read()) != -1) {
  7.         System.out.print((char) content);
  8.     }
  9. } catch (IOException e) {
  10.     e.printStackTrace();
  11. }

input.txt 文件内容：

输出：

  1. The actual number of bytes skipped:3
  2. The content read from file:我是Guide。

Writer（字符输出流）

Writer 用于将数据（字符信息）写入到目的地（通常是文件）， java.io.Writer 抽象类是所有字节输出流的父类。

Writer 常用方法 ：

  • write(int c) : 写入单个字符。

  • write(char[] cbuf)
cbuf
write(cbuf, 0, cbuf.length)

  • write(char[] cbuf, int off, int len)
write(char[] cbuf)
off
len

  • write(String str) ：写入字符串，等价于 write(str, 0, str.length()) 。

  • write(String str, int off, int len)
write(String str)
off
len

  • append(CharSequence csq)
Writer
Writer

  • append(char c)
Writer
Writer

  • flush() ：刷新此输出流并强制写出所有缓冲的输出字符。

  • close() :关闭输出流释放相关的系统资源。

OutputStreamWriter 是字符流转换为字节流的桥梁，其子类 FileWriter 是基于该基础上的封装，可以直接将字符写入到文件。

  1. // 字符流转换为字节流的桥梁
  2. public class InputStreamReader extends Reader {
  3. }
  4. // 用于写入字符到文件
  5. public class FileWriter extends OutputStreamWriter {
  6. }

FileWriter 代码示例：

  1. try (Writer output = new FileWriter("output.txt")) {
  2.     output.write("你好，我是Guide。");
  3. } catch (IOException e) {
  4.     e.printStackTrace();
  5. }

输出结果：

字节缓冲流

IO 操作是很消耗性能的，缓冲流将数据加载至缓冲区，一次性读取/写入多个字节，从而避免频繁的 IO 操作，提高流的传输效率。

字节缓冲流这里采用了装饰器模式来增强 InputStream 和 OutputStream 子类对象的功能。

举个例子，我们可以通过 BufferedInputStream （字节缓冲输入流）来增强 FileInputStream 的功能。

  1. // 新建一个 BufferedInputStream 对象
  2. BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("input.txt"));

字节流和字节缓冲流的性能差别主要体现在我们使用两者的时候都是调用 write(int b) 和 read() 这两个一次只读取一个字节的方法的时候。由于字节缓冲流内部有缓冲区（字节数组），因此，字节缓冲流会先将读取到的字节存放在缓存区，大幅减少 IO 次数，提高读取效率。

我使用 write(int b) 和 read() 方法，分别通过字节流和字节缓冲流复制一个 524.9 mb 的 PDF 文件耗时对比如下：

  1. 使用缓冲流复制PDF文件总耗时:15428 毫秒
  2. 使用普通字节流复制PDF文件总耗时:2555062 毫秒

两者耗时差别非常大，缓冲流耗费的时间是字节流的 1/165。

测试代码如下:

  1. @Test
  2. void copy_pdf_to_another_pdf_buffer_stream() {
  3.     // 记录开始时间
  4.     long start = System.currentTimeMillis();
  5.     try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("深入理解计算机操作系统.pdf"));
  6.          BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("深入理解计算机操作系统-副本.pdf"))) {
  7.         int content;
  8.         while ((content = bis.read()) != -1) {
  9.             bos.write(content);
  10.         }
  11.     } catch (IOException e) {
  12.         e.printStackTrace();
  13.     }
  14.     // 记录结束时间
  15.     long end = System.currentTimeMillis();
  16.     System.out.println("使用缓冲流复制PDF文件总耗时:" + (end - start) + " 毫秒");
  17. }
  18.  
  19. @Test
  20. void copy_pdf_to_another_pdf_stream() {
  21.     // 记录开始时间
  22.     long start = System.currentTimeMillis();
  23.     try (FileInputStream fis = new FileInputStream("深入理解计算机操作系统.pdf");
  24.          FileOutputStream fos = new FileOutputStream("深入理解计算机操作系统-副本.pdf")) {
  25.         int content;
  26.         while ((content = fis.read()) != -1) {
  27.             fos.write(content);
  28.         }
  29.     } catch (IOException e) {
  30.         e.printStackTrace();
  31.     }
  32.     // 记录结束时间
  33.     long end = System.currentTimeMillis();
  34.     System.out.println("使用普通流复制PDF文件总耗时:" + (end - start) + " 毫秒");
  35. }

如果是调用 read(byte b[]) 和 write(byte b[], int off, int len) 这两个写入一个字节数组的方法的话，只要字节数组的大小合适，两者的性能差距其实不大，基本可以忽略。

这次我们使用 read(byte b[]) 和 write(byte b[], int off, int len) 方法，分别通过字节流和字节缓冲流复制一个 524.9 mb 的 PDF 文件耗时对比如下：

  1. 使用缓冲流复制PDF文件总耗时:695 毫秒
  2. 使用普通字节流复制PDF文件总耗时:989 毫秒

两者耗时差别不是很大，缓冲流的性能要略微好一点点。

测试代码如下：

  1. @Test
  2. void copy_pdf_to_another_pdf_with_byte_array_buffer_stream() {
  3.     // 记录开始时间
  4.     long start = System.currentTimeMillis();
  5.     try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("深入理解计算机操作系统.pdf"));
  6.          BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("深入理解计算机操作系统-副本.pdf"))) {
  7.         int len;
  8.         byte[] bytes = new byte[4 * 1024];
  9.         while ((len = bis.read(bytes)) != -1) {
  10.             bos.write(bytes, 0, len);
  11.         }
  12.     } catch (IOException e) {
  13.         e.printStackTrace();
  14.     }
  15.     // 记录结束时间
  16.     long end = System.currentTimeMillis();
  17.     System.out.println("使用缓冲流复制PDF文件总耗时:" + (end - start) + " 毫秒");
  18. }
  19.  
  20. @Test
  21. void copy_pdf_to_another_pdf_with_byte_array_stream() {
  22.     // 记录开始时间
  23.     long start = System.currentTimeMillis();
  24.     try (FileInputStream fis = new FileInputStream("深入理解计算机操作系统.pdf");
  25.          FileOutputStream fos = new FileOutputStream("深入理解计算机操作系统-副本.pdf")) {
  26.         int len;
  27.         byte[] bytes = new byte[4 * 1024];
  28.         while ((len = fis.read(bytes)) != -1) {
  29.             fos.write(bytes, 0, len);
  30.         }
  31.     } catch (IOException e) {
  32.         e.printStackTrace();
  33.     }
  34.     // 记录结束时间
  35.     long end = System.currentTimeMillis();
  36.     System.out.println("使用普通流复制PDF文件总耗时:" + (end - start) + " 毫秒");
  37. }

BufferedInputStream（字节缓冲输入流）

BufferedInputStream 从源头（通常是文件）读取数据（字节信息）到内存的过程中不会一个字节一个字节的读取，而是会先将读取到的字节存放在缓存区，并从内部缓冲区中单独读取字节。这样大幅减少了 IO 次数，提高了读取效率。

BufferedInputStream 内部维护了一个缓冲区，这个缓冲区实际就是一个字节数组，通过阅读 BufferedInputStream 源码即可得到这个结论。

  1. public
  2. class BufferedInputStream extends FilterInputStream {
  3.     // 内部缓冲区数组
  4.     protected volatile byte buf[];
  5.     // 缓冲区的默认大小
  6.     private static int DEFAULT_BUFFER_SIZE = 8192;
  7.     // 使用默认的缓冲区大小
  8.     public BufferedInputStream(InputStream in) {
  9.         this(in, DEFAULT_BUFFER_SIZE);
  10.     }
  11.     // 自定义缓冲区大小
  12.     public BufferedInputStream(InputStream in, int size) {
  13.         super(in);
  14.         if (size <= 0) {
  15.             throw new IllegalArgumentException("Buffer size <= 0");
  16.         }
  17.         buf = new byte[size];
  18.     }
  19. }

缓冲区的大小默认为 8192 字节，当然了，你也可以通过 BufferedInputStream(InputStream in, int size) 这个构造方法来指定缓冲区的大小。

BufferedOutputStream（字节缓冲输出流）

BufferedOutputStream 将数据（字节信息）写入到目的地（通常是文件）的过程中不会一个字节一个字节的写入，而是会先将要写入的字节存放在缓存区，并从内部缓冲区中单独写入字节。这样大幅减少了 IO 次数，提高了读取效率

  1. try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("output.txt"))) {
  2.     byte[] array = "JavaGuide".getBytes();
  3.     bos.write(array);
  4. } catch (IOException e) {
  5.     e.printStackTrace();
  6. }

类似于 BufferedInputStream ， BufferedOutputStream 内部也维护了一个缓冲区，并且，这个缓存区的大小也是 8192 字节。

字符缓冲流

BufferedReader （字符缓冲输入流）和 BufferedWriter （字符缓冲输出流）类似于 BufferedInputStream （字节缓冲输入流）和 BufferedOutputStream （字节缓冲输入流），内部都维护了一个字节数组作为缓冲区。不过，前者主要是用来操作字符信息。

打印流

下面这段代码大家经常使用吧？

  1. System.out.print("Hello！");
  2. System.out.println("Hello！");

System.out 实际是用于获取一个 PrintStream 对象， print 方法实际调用的是 PrintStream 对象的 write 方法。

PrintStream 属于字节打印流，与之对应的是 PrintWriter （字符打印流）。 PrintStream 是 OutputStream 的子类， PrintWriter 是 Writer 的子类。

  1. public class PrintStream extends FilterOutputStream
  2.     implements Appendable, Closeable {
  3. }
  4. public class PrintWriter extends Writer {
  5. }

随机访问流

这里要介绍的随机访问流指的是支持随意跳转到文件的任意位置进行读写的 RandomAccessFile 。

RandomAccessFile 的构造方法如下，我们可以指定 mode （读写模式）。

  1. // openAndDelete 参数默认为 false 表示打开文件并且这个文件不会被删除
  2. public RandomAccessFile(File file, String mode)
  3.     throws FileNotFoundException {
  4.     this(file, mode, false);
  5. }
  6. // 私有方法
  7. private RandomAccessFile(File file, String mode, boolean openAndDelete)  throws FileNotFoundException{
  8.   // 省略大部分代码
  9. }

读写模式主要有下面四种：

  • r : 只读模式。

  • rw : 读写模式

  • rws
rw
rws

  • rwd
rw
rwd

文件内容指的是文件中实际保存的数据，元数据则是用来描述文件属性比如文件的大小信息、创建和修改时间。

RandomAccessFile 中有一个文件指针用来表示下一个将要被写入或者读取的字节所处的位置。我们可以通过 RandomAccessFile 的 seek(long pos) 方法来设置文件指针的偏移量（距文件开头 pos 个字节处）。如果想要获取文件指针当前的位置的话，可以使用 getFilePointer() 方法。

RandomAccessFile 代码示例：

  1. RandomAccessFile randomAccessFile = new RandomAccessFile(new File("input.txt"), "rw");
  2. System.out.println("读取之前的偏移量：" + randomAccessFile.getFilePointer() + ",当前读取到的字符" + (char) randomAccessFile.read() + "，读取之后的偏移量：" + randomAccessFile.getFilePointer());
  3. // 指针当前偏移量为 6
  4. randomAccessFile.seek(6);
  5. System.out.println("读取之前的偏移量：" + randomAccessFile.getFilePointer() + ",当前读取到的字符" + (char) randomAccessFile.read() + "，读取之后的偏移量：" + randomAccessFile.getFilePointer());
  6. // 从偏移量 7 的位置开始往后写入字节数据
  7. randomAccessFile.write(new byte[]{'H', 'I', 'J', 'K'});
  8. // 指针当前偏移量为 0，回到起始位置
  9. randomAccessFile.seek(0);
  10. System.out.println("读取之前的偏移量：" + randomAccessFile.getFilePointer() + ",当前读取到的字符" + (char) randomAccessFile.read() + "，读取之后的偏移量：" + randomAccessFile.getFilePointer());

input.txt 文件内容：

输出：

  1. 读取之前的偏移量：0,当前读取到的字符A，读取之后的偏移量：1
  2. 读取之前的偏移量：6,当前读取到的字符G，读取之后的偏移量：7
  3. 读取之前的偏移量：0,当前读取到的字符A，读取之后的偏移量：1

input.txt 文件内容变为 ABCDEFGHIJK 。

RandomAccessFile 的 write 方法在写入对象的时候如果对应的位置已经有数据的话，会将其覆盖掉。

  1. RandomAccessFile randomAccessFile = new RandomAccessFile(new File("input.txt"), "rw");
  2. randomAccessFile.write(new byte[]{'H', 'I', 'J', 'K'});

假设运行上面这段程序之前 input.txt 文件内容变为 ABCD ，运行之后则变为 HIJK 。

RandomAccessFile 比较常见的一个应用就是实现大文件的 断点续传 。何谓断点续传？简单来说就是上传文件中途暂停或失败（比如遇到网络问题）之后，不需要重新上传，只需要上传那些未成功上传的文件分片即可。分片（先将文件切分成多个文件分片）上传是断点续传的基础。

RandomAccessFile 可以帮助我们合并文件分片，示例代码如下：

我在《Java 面试指北》中详细介绍了大文件的上传问题。

RandomAccessFile 的实现依赖于 FileDescriptor (文件描述符) 和 FileChannel （内存映射文件）。

··········  END  ··············

来源：https://blog.csdn.net/lt_xiaodou/article/details/126666019

标签：字符,Java,读取,1.2,int,write,IO,new,字节
From： https://www.cnblogs.com/konglxblog/p/16706089.html

相关文章

  • Java安全之freemaker模版注入
    Java安全之freemaker模版注入freemaker简介FreeMarker是一款模板引擎：即一种基于模板和要改变的数据，并用来生成输出文本(HTML网页，电子邮件，配置文件，源代码等)的通用工具......
  • Javaweb-JSON格式的应用
    1什么是json客户端向服务器发送JSON格式的数据JSON是一种数据格式（JSON，即JavaScriptObjectNotation，是js中对象的表示方法）JSON格式表示两个学员信息的代码如下：[{sid......
  • 如何解决java.sql.SQLException: Column ' XXX ' not found
      在我们编写代码时,可能会遇到这种报错,报错的意思是找不到列XXX(questionId).出现这种报错的可能原因有三个:1.数据库表里缺少XXX(questionId)这一列. 解决方......
  • Java学习之静态方法static
      测试square方法将static删除后产生的问题会报错  所以main方法是一个静态方法，只能调用静态方法，所以平方数方法必须用static修饰......
  • java 一个对象的内存图
     面向对象-07-三种情况的对象内存图_哔哩哔哩_bilibili ......
  • Visual Studio 运行方式
    1、点击IISExpress运行实际上它开的是一个IISExpress服务器，就是说有一个小的代理服务器帮咱们运行，运行后就会启动一个IISExpress小型服务器，启动之后就会将Swagger运行......
  • Javaweb学习笔记第八弹
    继续MyBatis学习SQL语句警告提示问题产生原因：IDEA和数据库没有建立连接，不识别表的信息解决方式：在IDEA中配置MySQL数据库连接在IDEA的Maven项目中，如果想要直接通过IDEA......
  • Solution Set - HYBC #3
    教练起的什么怪名字。目录LJY的机器人LJY调代码LJY与铜制人偶LJY与任务计划LJY与攻城游戏LJY与涅奥的考验LJY的水紫题库爪仑组的题，很厉害。LJY的机器人原题CF......
  • springboot Condition 动态value
    packagecom.example.demo.condtion;importorg.springframework.context.annotation.Conditional;importjava.lang.annotation.*;@Target({ElementType.TYPE,Ele......
  • Java基础（四）—— HashCode和Equals
    正如标题所言，今天我们来讲讲hashCode和equals。或许有些人会奇怪了，这两个东西为什么要放在一起来讲呢？这是因为按照JDK规范：如果两个对象根据equals方法比较是相等的，那么调......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99