package

Java的类库可以分为以下几种类型(靠应用分类)：

Java标准类库（Java Standard Library）：
- java.lang：包含Java语言的核心类，如基本数据类型的包装类、字符串、异常类等。
- java.util：提供了集合框架（如List、Set、Map等）、日期和时间操作、随机数生成、排序算法、各种实用工具类等。
- java.io：用于进行输入和输出操作的类，包括文件读写、流操作、对象序列化等。
- java.net：用于网络编程的类，包括Socket编程、URL处理、HTTP请求等。
- java.awt和javax.swing：用于创建图形用户界面（GUI）的类库，提供了窗口、按钮、文本框、标签等组件。
Java集合框架（Java Collections Framework）：
- java.util包中的集合框架提供了一组接口和类，用于存储和操作数据集合。常用的集合类包括ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap等。
Java输入输出（Java I/O）：
- java.io包中的类提供了对文件、流和其他I/O操作的支持。常用的类包括File、InputStream、OutputStream、Reader、Writer等。
Java并发编程（Java Concurrency）：
- java.util.concurrent包提供了用于多线程和并发编程的类和接口，如线程池、并发集合、原子操作等。
Java数据库连接（Java Database Connectivity，JDBC）：
- java.sql包提供了与数据库进行交互的类和接口，用于执行SQL查询、事务处理、连接数据库等。
Java图形用户界面（Java GUI）：
- javax.swing包提供了用于创建跨平台图形用户界面的类和组件，如窗口、按钮、文本框、标签等。
第三方类库：
- Apache Commons：Apache软件基金会提供的一组开源类库，包含了各种常用的功能和工具类，如文件操作、字符串处理、日期处理、数学运算等。
- Google Guava：由Google提供的开源Java类库，提供了各种实用的工具类和集合扩展。
- Jackson：用于处理JSON数据的高性能JSON处理库。
- Log4j和SLF4J：用于日志记录的类库，提供了灵活和可扩展的日志记录功能。
- Hibernate：用于对象关系映射（ORM）的框架，简化了Java程序与数据库的交互。
- Spring Framework：一个综合性的Java开发框架，提供了依赖注入、面向切面编程、事务管理等功能。

（靠目录分类）

java.lang：包含 Java 语言的核心类和基本工具类，如 Object、String、Math、Thread 等。
java.util：提供各种实用工具类，如集合框架（Collection、List、Set、Map 等）、日期和时间处理、随机数生成、正则表达式、国际化支持等。
java.io：提供用于输入和输出操作的类，如文件读写、流处理、对象序列化等。
java.net：用于进行网络编程的类，包括网络通信、URL 处理、套接字编程等。
java.awt：抽象窗口工具包，提供创建图形用户界面（GUI）的类和接口。
javax.swing：用于构建 GUI 应用程序的 Swing 组件库，提供更丰富和灵活的界面构建工具。
java.sql：用于数据库访问和管理的类，包括连接数据库、执行 SQL 语句、处理结果集等。
java.security：提供了各种安全相关的类和接口，用于加密、数字签名、访问控制等。
javax.xml：用于 XML 处理的类库，支持 XML 解析、生成、转换等操作。
java.nio：提供了非阻塞式 I/O 操作的类，包括通道、缓冲区、选择器等。
java.math：提供高精度数值计算的类，支持大整数、大浮点数等的运算。
java.util.concurrent：提供并发编程的类和接口，包括线程池、锁、并发集合等。

Scanner主要功能与用法

Scanner类是Java中用于读取输入的工具类，它提供了各种方法来读取不同类型的数据。下面是Scanner类的主要功能和用法的详细说明：

1.读取基本类型

使用Scanner类可以读取各种基本类型的输入数据，例如：

nextInt()：读取一个整数值。
nextDouble()：读取一个双精度浮点数值。
nextFloat()：读取一个单精度浮点数值。
nextLong()：读取一个长整数值。
nextBoolean()：读取一个布尔值。

这些方法会根据输入的数据类型将输入转换为相应的Java基本类型，并返回读取到的值。

例如，以下代码片段演示了如何使用Scanner读取整数值：

Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数值: ");
int num = scanner.nextInt();
System.out.println("输入的整数值为: " + num);

2.设置分隔符

Scanner类允许通过使用useDelimiter()方法来设置输入的分隔符。默认情况下，分隔符是空格。

例如，以下代码片段演示了如何使用逗号作为分隔符读取多个字符串：

Scanner scanner = new Scanner(System.in);
scanner.useDelimiter(",");
System.out.print("请输入多个字符串，使用逗号分隔: ");
while (scanner.hasNext()) {
    String str = scanner.next();
    System.out.println("读取到的字符串: " + str);
}

3.跳过输入

Scanner类提供了skip()方法，可以跳过输入流中的指定模式。

例如，以下代码片段演示了如何跳过输入流中的一个整数值：

Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数值: ");
scanner.skip("\\d+"); // 跳过一个或多个数字
System.out.print("请输入一个字符串: ");
String str = scanner.nextLine();
System.out.println("输入的字符串为: " + str);

在上述示例中，skip("\\d+")方法将跳过一个或多个数字，然后读取输入流中的下一个字符串。

4.判断下一个元素的数据类型

Scanner类提供了一系列的hasNextXxx()方法，用于判断下一个Token是否是指定的数据类型。

例如，以下代码片段演示了如何使用hasNextInt()方法判断下一个Token是否是一个整数：

Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数值: ");
if (scanner.hasNextInt()) {
    int num = scanner.nextInt();
    System.out.println("输入的整数值为: " + num);
} else {
    System.out.println("输入不是一个整数值。");
}

在上述示例中，hasNextInt()方法用于判断输入的下一个Token是否是一个整数，如果是，则读取该整数值并输出，否则输出错误信息。

5.读取字符串

Scanner类提供了两个方法用于读取字符串：

next()：读取到下一个分隔符（默认为空格）之前的字符串作为一个字符串值。
nextLine()：读取到下一行作为一个字符串值。

例如，以下代码片段演示了如何使用next()方法读取多个字符串：

Scanner scanner = new Scanner(System.in);
System.out.print("请输入多个字符串，使用空格分隔: ");
while (scanner.hasNext()) {
    String str = scanner.next();
    System.out.println("读取到的字符串: " + str);
}

6.关闭资源

使用完Scanner类后，应该调用close()方法关闭Scanner并释放相关资源。

例如，以下代码片段演示了如何关闭Scanner：

Scanner scanner = new Scanner(System.in);
// 使用Scanner读取输入
scanner.close(); // 关闭Scanner

7.其他方法

除了上述提到的方法之外，Scanner类还提供了其他一些方法，例如：

useLocale()：使用指定的区域设置- next(pattern)：根据指定的模式读取输入，并返回匹配该模式的字符串。例如，scanner.next("\\d+")将读取下一个符合正则表达式\d+的字符串。
findInLine(pattern)：根据指定的模式在当前行中查找下一个匹配的字符串，并返回该字符串。例如，scanner.findInLine("Hello")将查找当前行中的下一个出现的”Hello”字符串。
match()：检查输入是否与指定模式匹配，并返回一个匹配结果的MatchResult对象。可以通过该对象获取匹配到的子字符串和捕获组。
input.mark()：标记输入的当前位置，可以通过input.reset()将输入重置到最近的标记位置。
radix()：指定输入数字的基数。默认情况下，Scanner将假设输入的数字为十进制，但可以使用scanner.radix(16)来指定输入为十六进制。

这些方法提供了更灵活的方式来处理输入数据，并根据需要进行匹配、查找和标记操作。

请注意，使用Scanner类时，需要导入java.util.Scanner包。

深入理解异常处理机制

1. 异常的概念和分类

异常是指在程序执行过程中可能出现的错误、故障或异常情况。Java中的异常分为两类：可检查异常（Checked Exception）和不可检查异常（Unchecked Exception）。

可检查异常：继承自Exception类或其子类的异常，编译器会强制要求程序处理这类异常，例如IOException、SQLException等。
不可检查异常：继承自RuntimeException类或其子类的异常，编译器不会强制要求程序处理这类异常，例如NullPointerException、ArrayIndexOutOfBoundsException等。

2. 异常处理的基本原则

在处理异常时，有一些基本原则需要遵循：

捕获和处理异常：使用try-catch语句块来捕获可能抛出的异常，并在catch块中处理异常情况。
抛出异常：当无法处理异常时，可以通过throw语句手动抛出异常，将异常传递给调用者进行处理。
异常链：通过将当前异常作为参数传递给新的异常，可以构建异常链，以提供更多关于异常发生的上下文信息。
finally块：使用finally块来执行无论是否发生异常都需要执行的代码，例如资源释放等。

3. 常见的异常类

Java提供了一系列常见的异常类，覆盖了各种常见的错误和异常情况。以下是一些常见的异常类及其用途：

Object
    └── Throwable
        ├── Error
        │   ├── LinkageError：链接错误，如类加载失败
        │   │   ├── ClassFormatError：类文件格式错误
        │   │   ├── ExceptionInInitializerError：静态初始化器引发异常
        │   │   └── NoClassDefFoundError：找不到类定义错误
        │   ├── ThreadDeath：线程中断
        │   └── VirtualMachineError：虚拟机错误，表示虚拟机内部的严重问题
        │       ├── InternalError：虚拟机内部错误
        │       ├── OutOfMemoryError：内存不足错误
        │       ├── StackOverflowError：堆栈溢出错误
        │       └── ...
        └── Exception
            ├── RuntimeException：不可检查异常的父类
            │   ├── NullPointerException：空指针异常
            │   ├── ArrayIndexOutOfBoundsException：数组索引越界异常
            │   ├── ArithmeticException：算术异常
            │   ├── IllegalArgumentException：非法参数异常
            │   ├── IllegalStateException：非法状态异常
            │   ├── IndexOutOfBoundsException：索引越界异常
            │   ├── UnsupportedOperationException：不支持的操作异常
            │   └── ...
            ├── InterruptedException：中断异常，表示线程被中断
            ├── ClassNotFoundException：类未找到异常
            ├── CloneNotSupportedException：克隆不支持异常
            ├── IllegalAccessException：非法访问异常
            ├── InstantiationException：实例化异常
            ├── NoSuchFieldException：字段未找到异常
            ├── NoSuchMethodException：方法未找到异常
            ├── ReflectiveOperationException：反射操作异常的父类
            │   ├── InvocationTargetException：反射调用目标异常
            │   └── ...
            ├── IOException：输入/输出异常，指示发生了I/O错误
            │   ├── FileNotFoundException：文件未找到异常
            │   ├── EOFException：文件已结束异常
            │   ├── NotSerializableException：不可序列化异常
            │   ├── UnsupportedEncodingException：不支持的编码异常
            │   ├── InterruptedIOException：中断的I/O异常
            │   └── ...
            ├── AnnotationFormatError：注解格式错误
            ├── AnnotationTypeMismatchException：注解类型不匹配异常
            ├── IncompleteAnnotationException：不完整注解异常
            ├── MirroredTypeException：镜像类型异常
            └── ...

4. 自定义异常

除了使用Java提供的异常类外，开发人员还可以根据需要创建自定义异常类。自定义异常类可以继承自Exception或其子类，并添加额外的属性和行为，以便更好地表示特定的异常情况。

例如，以下是一个自定义异常类的示例：

public class MyException extends Exception {
    private int errorCode;

    public MyException(String message, int errorCode) {
        super(message);
        this.errorCode = errorCode;
    }

    public int getErrorCode() {
        return errorCode;
    }
}

5. 异常处理的最佳实践

在Java中，异常处理是通过使用try-catch块来实现的。try-catch块用于捕获和处理可能会抛出异常的代码段。下面是Java中异常处理的基本结构：
```
try {
    // 可能会抛出异常的代码
} catch (ExceptionType1 e1) {
    // 处理 ExceptionType1 类型的异常
} catch (ExceptionType2 e2) {
    // 处理 ExceptionType2 类型的异常
} finally {
    // 可选的 finally 代码块
}
```
代码块try包含可能会抛出异常的代码。如果在try块中的代码引发了异常，那么异常将被捕获，并且程序会跳转到与异常类型匹配的catch块。在catch块中，你可以编写处理异常的代码逻辑。可以有多个catch块来处理不同类型的异常。最后，你还可以使用可选的finally块，在try-catch块执行完毕后执行一些清理操作，无论是否发生异常.

当异常被捕获后，你可以进行更深入的处理和操作。以下是一些在异常捕获后可用的方法和技巧：
1. 获取异常信息：
  - getMessage(): 通过调用异常对象的getMessage()方法，你可以获取异常的详细描述信息字符串。这个信息通常包含了异常的原因和相关的上下文信息。
  - toString(): 异常对象的toString()方法返回异常的字符串表示形式。这个字符串通常包含了异常的类名和异常消息。
2. 打印异常堆栈跟踪信息：
  - printStackTrace(): 异常对象的printStackTrace()方法用于打印异常的完整堆栈跟踪信息。堆栈跟踪信息包含了异常发生的位置、调用链和相关的方法调用。这对于调试和定位异常发生的原因非常有用。
3. 日志记录：
  - 使用日志记录框架（如log4j、slf4j等）将异常信息记录到日志文件中。这对于后续的故障排除和分析非常重要。你可以选择记录完整的堆栈跟踪信息或只记录异常消息。
4. 异常处理和恢复：
  - 在catch块中，你可以编写逻辑来处理异常，尝试修复错误或采取其他措施。这可能包括重试操作、回滚事务、恢复到备用方案等。
  - 你还可以选择重新抛出异常，将异常传递给上层调用者处理。使用throw语句将捕获的异常重新抛出。
5. 资源释放和清理：
  - 在异常处理过程中，你可以使用finally块来执行资源释放和清理操作。这些操作可能包括关闭文件、释放数据库连接、释放内存等。finally块中的代码无论是否发生异常都会执行。
下面是一个更详细的示例，说明了在异常捕获后的一些操作：
```
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream("nonexistent-file.txt");
            // 执行其他操作，比如读取文件内容
        } catch (FileNotFoundException e) {
            System.out.println("Error: File not found");
            System.out.println("Exception message: " + e.getMessage());
            System.out.println("Exception details: " + e.toString());
            e.printStackTrace();
            
            
            // 获取异常信息并打印
            System.out.println("Error: " + e.getMessage());
            
            // 记录异常到日志文件
            logException(e);
            
            // 执行异常处理逻辑，比如返回默认值
            int defaultValue = 0;
            System.out.println("Using default value: " + defaultValue);
            
            // 重新抛出异常（可选）
            // throw e;
            
            
            
            
        } finally {
            // 关闭文件输入流
            if (fileInputStream != null) {
                try {
                    fileInputStream.close();
                } catch (Exception e) {
                    // 处理关闭文件过程中的异常
                    e.printStackTrace();
                }
            }
            System.out.println("Finally block executed");
        }
    }
}
```
在上面的示例中，我们尝试打开一个不存在的文件，并在catch块中捕获了FileNotFoundException。在catch块中，我们打印了异常消息、字符串表示形式和堆栈跟踪信息。在finally块中，我们关闭了文件输入流，并在关闭过程中处理了可能发生的异常。

这只是异常处理的一些示例。在实际应用中，你可以根据具体场景和需求，结合异常处理的特性和其他相关技术，编写更复杂的异常处理逻辑。

希望这次更详细的解答能够满足你的需求。如果你还有其他问题，请随时提问。

6. 异常处理的层次结构

Java异常体系采用层次结构来组织异常类。所有异常类都直接或间接继承自Throwable类。Throwable类有两个重要的子类：Error和Exception。

Error：表示严重错误和系统故障，通常无法恢复，例如OutOfMemoryError、StackOverflowError等。程序一般不捕获处理Error。
Exception：表示程序运行期间可能出现的异常情况。Exception又分为可检查异常（Checked Exception）和不可检查异常（Unchecked Exception），前文已进行了介绍。

7. 异常处理的工具类

Java还提供了一些异常处理的工具类，以简化异常处理的过程。例如：

try-catch-resources：可以在try块中使用资源，无需手动关闭资源，确保资源的正确关闭。
Objects.requireNonNull()：用于检查参数是否为null，如果为null，则抛出NullPointerException，提供更好的错误信息。

些具类可以提高异常处理的效率和可读性。

8.主动抛出异常throw和throws

当涉及到异常处理时，Java中有两个关键字，throw和throws，它们用于不同的目的。

throw关键字：
- throw关键字用于在代码中手动抛出异常。你可以使用throw关键字创建并抛出自定义的异常对象，或者将捕获的异常重新抛出给上层调用者处理。
- 使用throw关键字时，后面跟着要抛出的异常对象。这个异常对象必须是Throwable类或其子类的实例。
- 一旦throw语句执行，程序的控制权将立即转移到异常处理机制，查找适当的异常处理代码块来处理抛出的异常。
下面是一个示例，演示了如何使用throw关键字手动抛出异常：
```
public class ThrowExample {
    public static void main(String[] args) {
        int age = -1;
        try {
            validateAge(age);
        } catch (IllegalArgumentException e) {
            System.out.println("Invalid age: " + e.getMessage());
        }
    }

    public static void validateAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative");
        }
        // 其他验证逻辑...
    }
}
```
在上面的示例中，validateAge方法用于验证年龄是否为负数。如果年龄为负数，就会使用throw关键字抛出IllegalArgumentException异常，并提供异常的详细信息。在main方法中，我们捕获并处理了这个异常。
throws关键字：
- throws关键字用于在方法签名中声明可能抛出的异常。通过在方法声明中使用throws关键字，你可以告诉调用者该方法可能会抛出特定类型的异常，从而提醒调用者处理这些异常。
- 在方法声明中，可以跟随一个或多个异常类型，用逗号分隔。这些异常类型必须是Throwable类或其子类。
- 当一个方法声明使用了throws关键字时，调用该方法的代码必须处理或继续抛出这些异常。
- throws关键字将异常的责任从方法内部转移到了调用者。
下面是一个示例，演示了如何在方法声明中使用throws关键字：
```
import java.io.FileNotFoundException;
import java.io.FileReader;

public class ThrowsExample {
    public static void main(String[] args) {
        try {
            readFile("nonexistent-file.txt");
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        }
    }

    public static void readFile(String filename) throws FileNotFoundException {
        FileReader fileReader = new FileReader(filename);
        // 读取文件内容...
        // 其他操作...
    }
}
```
在上面的示例中，readFile方法声明使用了throws关键字，并指定了FileNotFoundException异常。这告诉调用者该方法可能会抛出FileNotFoundException异常。在main方法中，我们捕获并处理了这个异常。

JAVA IO

Java的IO流是一种用于处理输入和输出数据的机制，它可以让程序从不同的数据源读取数据，或者向不同的数据目标写入数据。Java的IO流有以下几个特点：

Java的IO流是基于字节和字符的，字节流可以操作任何类型的数据，字符流只能操作文本数据。
Java的IO流是单向的，输入流只能从数据源读取数据，输出流只能向数据目标写入数据。
Java的IO流是分层的，节点流可以直接连接到数据源或目标，处理流可以封装节点流或其他处理流，提供更高级的功能。
Java的IO流是抽象的，它使用抽象类和接口来定义不同类型的流，具体的实现类可以根据不同的需求来选择。

流类型	代码示例	作用	底层原理
字节输入流	InputStream in = new FileInputStream(“test.txt”);	用于从数据源读取字节数据	通过系统调用和文件描述符来操作文件
字节输出流	OutputStream out = new FileOutputStream(“test.txt”);	用于向数据目标写入字节数据	通过系统调用和文件描述符来操作文件
字符输入流	Reader reader = new FileReader(“test.txt”);	用于从数据源读取字符数据	通过字节输入流和字符编码转换器来实现
字符输出流	Writer writer = new FileWriter(“test.txt”);	用于向数据目标写入字符数据	通过字节输出流和字符编码转换器来实现
缓冲流	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));	用于提高字节或字符流的读写效率，减少系统调用次数	通过内部维护一个缓冲区来存储临时数据
转换流	InputStreamReader isr = new InputStreamReader(new FileInputStream(“test.txt”), “UTF-8”);	用于将字节流转换为字符流，或者设置字符编码	通过字节输入流和字符编码转换器来实现
数据流	DataInputStream dis = new DataInputStream(new FileInputStream(“test.dat”));	用于读写基本类型和字符串类型的数据，保留了数据类型信息	通过字节输入流和位运算来实现
对象流	ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(“test.obj”));	用于读写对象类型的数据，实现了对象的序列化和反序列化	通过字节输出流和反射机制来实现
文件流	FileInputStream fis = new FileInputStream(“test.txt”);	用于读写文件类型的数据，是最基本的文件操作流	通过系统调用和文件描述符来操作文件
打印流	PrintStream ps = new PrintStream(new FileOutputStream(“test.txt”));	用于格式化输出字节或字符数据，可以重定向标准输出和错误输出	通过字节输出流和字符串拼接来实现

java net

Socket（套接字）是计算机网络编程中的一个核心概念，它提供了一种用于在网络上进行通信的机制。Socket 可以看作是应用程序与网络之间的一个端点，用于发送和接收数据。在 Java 编程中，Socket 类用于实现基于网络的通信，包括客户端和服务器之间的数据传输。

Socket 在网络通信中的作用和一些重要概念如下：

客户端和服务器通信： 在网络通信中，通常会有客户端和服务器两个主要角色。客户端发起请求，服务器响应请求。Socket 类允许客户端和服务器通过创建套接字来建立连接并进行双向通信。
套接字类型： 有两种常见的 Socket 类型：Socket 和 ServerSocket。Socket 类用于客户端，它表示一个客户端到服务器的单个连接。ServerSocket 类用于服务器，它监听特定端口，等待客户端连接请求，然后为每个连接创建一个新的 Socket 实例。
套接字通信模式： Socket 可以支持不同的通信模式，包括面向连接的 TCP（Transmission Control Protocol）和无连接的 UDP（User Datagram Protocol）。TCP 提供可靠的、基于流的连接，而 UDP 提供不可靠的、基于数据报的连接。
创建套接字： 在 Java 编程中，可以使用 Socket 或 ServerSocket 类来创建套接字实例。例如，在客户端，可以通过创建 Socket 对象来建立到服务器的连接。
输入输出流： 一旦建立了连接，就可以使用套接字的输入流（InputStream）和输出流（OutputStream）来进行数据传输。通过输入流，可以从套接字接收数据，而通过输出流，可以将数据发送到套接字。
IP 地址和端口号： 在创建套接字时，需要指定要连接的服务器的 IP 地址和端口号。IP 地址标识网络中的主机，端口号标识该主机上的特定服务。
阻塞与非阻塞： 默认情况下，Socket 是阻塞的，这意味着当进行读取或写入操作时，程序会阻塞等待，直到操作完成。可以通过设置超时或使用非阻塞的套接字来实现异步通信。
关闭套接字： 通信结束后，应该关闭套接字以释放资源。可以通过调用 close() 方法来关闭套接字。

在你提供的代码中，Socket 被用于创建客户端，该客户端通过建立到指定服务器的连接，发送数据，接收服务器的响应，然后关闭连接。这个示例展示了一个基本的套接字通信过程。

Socket 类提供了多种方法，用于管理和控制套接字的创建、通信和关闭等操作。以下是 Socket 类的一些主要方法，我会逐一介绍它们的作用和用法。

请注意，以下方法列表可能不包含所有可能的方法，但会涵盖常见的和重要的方法。

构造函数：
- Socket(String host, int port): 创建一个套接字并连接到指定的主机和端口号。
连接管理方法：
- void connect(SocketAddress endpoint): 连接到指定的套接字地址。
- void bind(SocketAddress bindpoint): 绑定本地端口和地址。
- SocketAddress getRemoteSocketAddress(): 获取远程主机的套接字地址。
- SocketAddress getLocalSocketAddress(): 获取本地主机的套接字地址。
数据传输方法：
- InputStream getInputStream(): 获取套接字的输入流，用于从套接字接收数据。
- OutputStream getOutputStream(): 获取套接字的输出流，用于向套接字发送数据。
关闭与释放方法：
- void close(): 关闭连接，释放相关资源。
- void shutdownInput(): 关闭输入流，不再接收数据。
- void shutdownOutput(): 关闭套输出流，不再发送数据。
其他方法：
- void setTcpNoDelay(boolean on): 设置是否启用 TCP 无延迟模式，以减少延迟。
- void setSoTimeout(int timeout): 设置套接字的读取超时时间。
- boolean isConnected(): 检查套接字是否已连接。
- boolean isClosed(): 检查套接字是否已关闭。
- boolean isInputShutdown(): 检查套接字的输入流是否被关闭。
- boolean isOutputShutdown(): 检查套接字的输出流是否被关闭。

这些方法是 Socket 类中的一些重要方法，用于控制套接字的创建、连接、通信和关闭等操作。在实际使用中，根据你的需求，你可能会使用其中的一些方法来管理套接字的行为和状态。如果你想更详细地了解每个方法的参数和用法，请参考 Java 官方文档或相应的网络编程教程。

InputStream

InputStream 是 Java 标准库中的一个抽象类，用于读取字节数据流。它提供了一组用于从输入源（如文件、套接字等）读取字节的方法。以下是关于 InputStream 的详细、全面的说明：

抽象类特点：
- InputStream 是一个抽象类，不能直接实例化，但可以通过其子类来实现具体的字节输入操作。
基本方法：
- int read() throws IOException: 从输入流中读取一个字节的数据，并返回读取的字节数据。如果到达流的末尾，则返回 -1。这是 InputStream 最基本的读取方法。
- int read(byte[] b) throws IOException: 从输入流中读取最多 b.length 个字节的数据，并将读取的数据存储在给定的字节数组 b 中。返回实际读取的字节数，如果没有更多数据可读，则返回 -1。
- int read(byte[] b, int off, int len) throws IOException: 从输入流中读取最多 len 个字节的数据，从指定的偏移量 off 开始存储到字节数组 b 中。返回实际读取的字节数，如果没有更多数据可读，则返回 -1。
关闭方法：
- void close() throws IOException: 关闭输入流并释放相关的资源。在读取完数据后，应该调用此方法来关闭输入流。
其他方法：
- int available() throws IOException: 返回当前可从输入流中读取的字节数。这个方法可以用来获取当前缓冲区中可供读取的字节数。
- long skip(long n) throws IOException: 跳过并丢弃输入流中的 n 个字节。返回实际跳过的字节数。
- void mark(int readlimit): 标记输入流的当前位置。readlimit 参数表示在标记失效之前，可以不受限制地读取的字节数。
- void reset() throws IOException: 将输入流重新定位到最近的标记位置，即取消先前的标记。
阻塞和非阻塞操作：
- read() 方法通常是阻塞的，如果没有可用的数据，它会一直等待数据到达。
- 非阻塞读取可以通过设置读取超时时间（使用 setSoTimeout() 或类似方法）来实现。在超时时间内如果没有数据可读，会抛出 IOException。
子类实现：
- InputStream 的子类可以是各种数据源，例如文件、网络连接、管道等。常见的子类包括 FileInputStream、ByteArrayInputStream、SocketInputStream 等，它们实现了具体的数据源读取逻辑。
异常处理：
- 在读取数据时，可能会出现各种异常，如 IOException。因此，在使用 InputStream 时，应该进行适当的异常处理。

InputStream 提供了一种通用的接口来读取字节数据，使得读取不同数据源的字节数据变得更加统一和灵活。使用它，你可以从文件、套接字、内存等各种数据源中读取字节数据，并根据需要进行处理。如果你想深入了解特定的 InputStream 子类，可以查阅 Java 官方文档或相关的编程资源。

OutputStream

OutputStream 是 Java 标准库中的一个抽象类，用于写入字节数据流。它提供了一组用于将字节数据写入输出目标（如文件、套接字等）的方法。以下是关于 OutputStream 的详细、全面的说明：

抽象类特点：
- OutputStream 是一个抽象类，不能直接实例化，但可以通过其子类来实现具体的字节输出操作。
基本方法：
- void write(int b) throws IOException: 将一个字节数据写入输出流。数据通过参数 b 传递，只会写入低八位。
- void write(byte[] b) throws IOException: 将字节数组 b 中的所有数据写入输出流。
- void write(byte[] b, int off, int len) throws IOException: 将字节数组 b 中从偏移量 off 开始、长度为 len 的数据写入输出流。
刷新和关闭方法：
- void flush() throws IOException: 刷新输出流，将缓冲区中的数据强制写入目标。
- void close() throws IOException: 关闭输出流并释放相关的资源。在写入完数据后，应该调用此方法来关闭输出流。
其他方法：
- void write(byte[] b) throws IOException: 将字节数组 b 中的所有数据写入输出流。
- void write(byte[] b, int off, int len) throws IOException: 将字节数组 b 中从偏移量 off 开始、长度为 len 的数据写入输出流。
- void flush() throws IOException: 刷新输出流，将缓冲区中的数据强制写入目标。
阻塞和非阻塞操作：
- write() 方法通常是阻塞的，如果输出目标没有足够的空间来接受数据，它会一直等待直到有足够的空间。
- 非阻塞写入可以通过设置写入超时时间（使用 setSoTimeout() 或类似方法）来实现。在超时时间内如果无法写入数据，会抛出 IOException。
子类实现：
- OutputStream 的子类可以是各种输出目标，例如文件、网络连接、管道等。常见的子类包括 FileOutputStream、ByteArrayOutputStream、SocketOutputStream 等，它们实现了具体的数据写入逻辑。
异常处理：
- 在写入数据时，可能会出现各种异常，如 IOException。因此，在使用 OutputStream 时，应该进行适当的异常处理。

OutputStream 提供了一种通用的接口来写入字节数据，使得将字节数据写入不同输出目标变得更加统一和灵活。使用它，你可以将字节数据写入文件、套接字、内存等各种输出目标，并根据需要进行处理。如果你想深入了解特定的 OutputStream 子类，可以查阅 Java 官方文档或相关的编程资源。

Comment