JavaSE 核心考点复盘：对象创建、String 机制与 IO 流详解

深拷贝则会递归复制所有引用对象，确保新旧对象完全独立，互不影响。实现方式主要有手动复制或使用序列化。

手动复制示例：

class Person {
    String name;
    int age;
    Address address;

    public Person(Person person) {
        this.name = person.name;
        this.age = person.age;
        this.address = new Address(person.address.city);
    }
}

序列化与反序列化：

import java.io.*;

class Person implements Serializable {
    String name;
    int age;
    Address address;

    public Person deepClone() throws IOException, ClassNotFoundException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return (Person) ois.readObject();
    }
}

2. Java 创建对象的四种方式

1. new 关键字：最常见的方式，直接调用构造方法。

   Person person = new Person();
   

2. 反射机制：运行时动态创建，常用于框架开发。

   Class clazz = Class.forName("Person");
   Person person = (Person) clazz.newInstance();
   

3. clone 拷贝：需实现 Cloneable 接口。

   Person person2 = (Person) person.clone();
   

4. 序列化机制：通过字节流恢复对象，需实现 Serializable 接口。

   ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
   oos.writeObject(person);
   ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"));
   Person person2 = (Person) ois.readObject();
   

二、String

1. String、StringBuilder 与 StringBuffer 的区别

String 是不可变的，每次修改都会生成新对象；StringBuilder 是可变的，性能更高但非线程安全；StringBuffer 类似 StringBuilder 但加了同步锁，线程安全。

• String：适用于内容不变的场景，如 HashMap Key。
• StringBuilder：单线程下频繁修改字符串的首选。
• StringBuffer：多线程环境下使用，但现代开发中较少见。

2. String 是不可变类吗？

是的。不可变性带来了安全性、缓存重用（常量池）和哈希值稳定等优势。

如何保证不可变？

1. 内部使用 private final char value[] 存储数据。
2. 不提供修改内容的公共方法，修改操作返回新对象。
3. 类本身声明为 final，防止继承篡改。

三、异常处理

1. Java 中的异常体系

Throwable 是所有错误和异常的基类，分为 Error 和 Exception。

• Error：严重错误，JVM 无法处理（如 OutOfMemoryError）。
• Exception：程序可处理的异常。
  • Checked Exception：编译时必须处理（如 IOException）。
  • Runtime Exception：运行时抛出，编译器不强制处理（如 NullPointerException）。

2. 异常的处理方式

1. 抛出异常：使用 throw 抛出，throws 声明。

   public void test() throws Exception {
       throw new Exception("Error occurred");
   }
   

2. 捕获异常：使用 try-catch-finally。

   try {
       // risky code
   } catch (Exception e) {
       // handle
   } finally {
       // cleanup
   }
   

注意：如果 catch 和 finally 都抛出异常，最终抛出的是 finally 中的异常。若需保留 catch 中的异常，需在 finally 中单独捕获并处理。

四、I/O

1. Java 中 IO 流的分类

• 方向：输入流（Input）、输出流（Output）。
• 单位：字节流（Byte）、字符流（Character）。
• 功能：节点流（Node）、处理流（Processing）、管道流（Pipe）。

IO 流大量使用了装饰器模式，例如 BufferedInputStream 包装 FileInputStream 增加缓冲功能。

缓冲区溢出预防： 写入前检查剩余容量，使用 ByteBuffer.remaining() 判断。

ByteBuffer buffer = ByteBuffer.allocate(1024);
if (buffer.remaining() >= data.length) {
    buffer.put(data);
}

2. 为什么需要字符流？

字符流由 JVM 将字节转换而来，涉及编码处理。直接使用字符流可避免乱码问题，适合文本处理；二进制文件（如图片、视频）则更适合用字节流。

3. BIO、NIO、AIO 的区别

• BIO：阻塞式 I/O，连接少时适用。
• NIO：非阻塞 I/O，多路复用，适合高并发短连接。
• AIO：异步 I/O，回调通知，适合长连接场景。

五、序列化

1. 什么是序列化和反序列化？

序列化是将对象转为字节流以便存储或传输；反序列化则是还原对象的过程。

2. 常见的序列化方式

1. Java 原生序列化：使用 ObjectOutputStream。
2. JSON 序列化：常用 Jackson 等库，轻量且跨语言。
3. ProtoBuff：高效压缩，适合高性能网络传输。

六、网络编程

1. Socket 网络套接字

Socket 是网络通信的端点，基于 TCP/UDP 协议。

TCP 客户端示例：

Socket socket = new Socket("127.0.0.1", 8080);
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
out.println("Hello Server!");

RPC 框架简介： RPC（Remote Procedure Call）允许调用远程方法。常见框架包括 gRPC、Dubbo、Spring Cloud OpenFeign 等，它们屏蔽了底层网络细节。

七、泛型

1. Java 泛型的作用

泛型提高类型安全，避免强制转换和 ClassCastException。

使用方式：

• 泛型类：class Generic<T> { private T key; }
• 泛型接口：interface Generator<T> { T method(); }
• 泛型方法：<T> void print(T[] array)

通配符：

• ?：不确定类型。
• T：具体类型。
• K/V：键值对。
• E：元素。

类型擦除： Java 泛型在编译期进行类型检查，运行时会擦除泛型信息以兼容旧版本 JDK。例如 List<String> 在运行时变为 List。

八、反射

1. 什么是反射？

反射允许在运行时动态获取类的信息（字段、方法、构造器）并操作对象。

应用场景：

• Spring 框架管理 Bean。
• 动态代理（AOP）。
• 测试框架（JUnit）扫描测试方法。
• 通用工具类（如对象拷贝）。

优缺点：

• 优点：动态灵活，支持通用代码。
• 缺点：性能开销大，破坏封装性。

九、Lambda 表达式

1. Lambda 表达式简介

Lambda 简化匿名方法，支持函数式编程。

示例：

// 简化线程创建
new Thread(() -> System.out.println("Hello")).start();

// Stream 流过滤
List<Integer> evenNumbers = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList());

Lambda 表达式让代码更简洁，配合 Stream API 能显著提升数据处理效率。