JavaSE 复习 汇总 总结（一篇学完大学java课程）

基本语言特性：

基本数据类型

1. 整型（Integral Types）：

   • byte：8 位，有符号，范围为 -128 到 127。
   • short：16 位，有符号，范围为 -32,768 到 32,767。
   • int：32 位，有符号，范围为 -2^31 到 2^31 - 1。
   • long：64 位，有符号，范围为 -2^63 到 2^63 - 1。

2. 浮点型（Floating-Point Types）：

   • float：32 位，单精度，范围为约 ±3.40282347 × 10^38，带有 7 位有效数字。
   • double：64 位，双精度，范围为约 ±1.79769313486231570 × 10^308，带有 15 位有效数字。

3. 布尔型（Boolean Type）：

   • boolean：表示 true 或 false。

4. 字符型（Character Type）：

   • char：16 位，表示 Unicode 字符，范围为 '\u0000'（即 0）到 '\uffff'（即 65,535）。

这些基本数据类型在 Java 中是直接支持的，它们都有对应的封装类（Wrapper Classes），比如 Integer、Long、Float、Double 等，可以在需要时使用封装类来实现一些额外的功能，比如将基本数据类型转换为对象或者进行数学运算。

数据溢出：

数据溢出是指当计算结果超出了数据类型的表示范围时所产生的错误情况。在计算机中，每种数据类型都有它能够表示的最大值和最小值。如果进行的操作导致结果超出了这个范围，就会发生数据溢出。

在 Java 中，针对基本数据类型的数据溢出有以下情况：

1. 整型溢出：当对整数类型的变量进行算术运算时，如果结果超出了该类型的表示范围，将导致溢出。例如，对于 int 类型的变量，其表示范围为 -2^31 到 2^31 - 1，如果进行了加法运算导致结果大于最大值或小于最小值，则会发生溢出。

2. 浮点数溢出：当对浮点类型的变量进行算术运算时，如果结果超出了该类型的表示范围，将导致溢出。例如，对于 float 类型的变量，其表示范围为约 ±3.40282347 × 10^38，如果进行了乘法运算导致结果超出范围，则会发生溢出。

3. 其他情况：除了算术运算，还有其他情况可能导致数据溢出，例如类型转换。如果将一个超出了目标类型表示范围的值转换为目标类型，也会导致溢出。

数据溢出可能会导致程序行为不可预测，甚至会引发安全漏洞。为了避免数据溢出，可以采取以下措施：

• 在进行计算之前，检查变量的取值范围，以确保不会发生溢出。
• 使用更大范围的数据类型，以便能够容纳计算结果。
• 对可能引发溢出的情况进行异常处理，以避免程序崩溃或安全问题。

变量和常量

变量（Variables）：

1. 可变性：变量的值可以在程序执行过程中改变。
2. 声明：在使用前需要先声明，并且需要指定变量的数据类型。
3. 赋值：可以通过赋值语句给变量赋值。
4. 作用域：变量的作用域通常是在声明它的代码块内部，例如在方法内部或者是类的成员变量。
5. 命名规则：通常遵循标识符命名规则，比如可以由字母、数字、下划线和美元符号组成，但不能以数字开头。

在 Java 中，变量的声明格式为：

data_type var_name;

int x;
double salary;
String name;

 

常量（Constants）：

1. 不可变性：常量的值在程序执行过程中不能改变，一旦赋值就不能再次修改。
2. 声明：常量通常在程序的顶部或者静态块中声明，并且通常使用 final 关键字来指示它是一个常量。
3. 赋值：必须在声明时或者构造函数中为常量赋值，并且不能再次赋值。
4. 作用域：常量的作用域通常是在声明它的代码块内部，与变量相似。
5. 命名规则：命名规则与变量相同，但通常使用大写字母来表示常量。

在 Java 中，常量的声明格式为：

final data_type CONSTANT_NAME = value;

final int MAX_SIZE = 100;
final double PI = 3.14159;
final String APP_NAME = "MyApp";

运算符

算术运算符（Arithmetic Operators）：

用于执行基本的数学运算，如加法、减法、乘法、除法等。

• +：加法
• -：减法
• *：乘法
• /：除法
• %：取模（取余）

取余和取模的细微区别：

在计算中，取余（remainder）和取模（modulo）都是用于计算除法的余数，但它们在处理负数时有不同的结果。

取余（remainder）：

取余操作的结果是保留被除数的符号，并且余数的绝对值小于除数的绝对值。它的计算规则通常是：

𝑎mod  𝑏=𝑎−𝑏⋅⌊𝑎𝑏⌋amodb=a−b⋅⌊ba​⌋

其中，⌊𝑎𝑏⌋⌊ba​⌋ 表示对 𝑎𝑏ba​ 向下取整。

在 Java 中，取余操作使用 % 运算符。例如：

int result = 5 % 2; // 结果为 1 int result2 = -5 % 2; // 结果为 -1 

取模（modulo）：

取模操作的结果与除数的符号相同，并且余数的绝对值小于除数的绝对值。它的计算规则通常是：

𝑎mod  𝑏=𝑎−𝑏⋅⌊𝑎𝑏⌋amodb=a−b⋅⌊ba​⌋

不同于取余的地方在于取模的结果与除数的符号相同，而不是与被除数的符号相同。

在 Java 中，取模操作也使用 % 运算符。例如：

int result = 5 % 2; // 结果为 1 int result2 = -5 % 2; // 结果为 -1 

所以在 Java 中，取余和取模的运算结果在大多数情况下是相同的，但在处理负数时有微小的差异。

关系运算符（Relational Operators）：

用于比较两个值之间的关系，返回一个布尔值。

• ==：等于
• !=：不等于
• >：大于
• <：小于
• >=：大于等于
• <=：小于等于

逻辑运算符（Logical Operators）：

用于在布尔表达式之间执行逻辑运算。

• &&：逻辑与（AND）
• ||：逻辑或（OR）
• !：逻辑非（NOT）

在 Java 中，&& 和 & （|| 和 |）都是逻辑与（逻辑或）运算符，用于在布尔表达式中执行逻辑与操作，但它们之间有一些重要的区别（逻辑或同理）：

1. 短路求值：

   • && 是短路逻辑与运算符。如果第一个操作数为 false，则不会计算第二个操作数，直接返回 false，因为无论第二个操作数是什么，整个表达式的结果都将为 false。
   • & 则不是短路运算符，它会计算两个操作数的值，无论第一个操作数的值是什么。

2. 效率：

   • 由于短路求值的特性，&& 在某些情况下可以提高程序的效率，尤其是在第一个操作数为 false 的情况下，避免了不必要的计算。
   • & 则不具备短路求值的优势，它会始终计算两个操作数的值。

3. 适用性：

   • && 通常用于布尔表达式中，用于判断条件是否满足，并且当第一个条件不满足时，不再进行后续条件的判断，以提高效率。
   • & 则用于需要计算两个操作数的值的情况，不考虑短路求值的情况。

在大多数情况下，推荐使用 &&，因为它在实践中更为常见，而且可以提高程序的效率。只有在需要对两个操作数都进行计算，并且不需要短路求值时，才使用 &。

赋值运算符（Assignment Operators）：

用于给变量赋值。

• =：赋值
• +=：加法赋值
• -=：减法赋值
• *=：乘法赋值
• /=：除法赋值
• %=：取模赋值

自增自减运算符（Increment/Decrement Operators）：

用于增加或减少变量的值。

• ++：自增（加一）
• --：自减（减一）

位运算符（Bitwise Operators）：

用于对二进制位进行操作。

• &：按位与
• |：按位或
• ^：按位异或
• ~：按位取反
• <<：左移位
• >>：右移位
• >>>：无符号右移位

1. 按位与（&）：

   • 将两个操作数的对应位进行与操作，如果两个操作数的对应位都为 1，则结果为 1，否则为 0。

2. 按位或（|）：

   • 将两个操作数的对应位进行或操作，如果两个操作数的对应位至少有一个为 1，则结果为 1，否则为 0。

3. 按位异或（^）：

   • 将两个操作数的对应位进行异或操作，如果两个操作数的对应位不相同，则结果为 1，否则为 0。

4. 按位取反（~）：

   • 对操作数的每一位进行取反操作，即 0 变为 1，1 变为 0。

5. 左移位（<<）：

   • 将操作数的所有位向左移动指定的位数，并在右侧填充 0。相当于将操作数乘以 2 的移动位数次幂。

6. 右移位（>>）：

   • 将操作数的所有位向右移动指定的位数，并根据操作数的符号位在左侧填充符号位（如果为正数则填充 0，如果为负数则填充 1）。相当于将操作数除以 2 的移动位数次幂。

7. 无符号右移位（>>>）：

   • 将操作数的所有位向右移动指定的位数，并在左侧填充 0。不考虑符号位的影响。

这些位运算符通常用于底层的位操作，例如位掩码、位标志等。在一些特定的场景中，它们可以提供高效的计算方式，比如对图像数据、网络协议等进行处理。

条件运算符（Conditional Operator）：

也称为三元运算符，根据条件的结果返回其中的一个值。

• ? :：条件运算符

条件运算符 ? :，也称为三元运算符，是 Java 中唯一的三目运算符，用于根据一个条件来选择两个可能的值之一。它的语法结构如下：

condition ? expression1 : expression2 

解释如下：

• 如果 condition 表达式的值为真（即 true），则整个表达式的值为 expression1。
• 如果 condition 表达式的值为假（即 false），则整个表达式的值为 expression2。

这种条件运算符提供了一种简洁的方式来根据条件选择不同的值，相当于一个简单的 if-else 语句的缩写形式。例如：

int a = 5; int b = 10; int max = (a > b) ? a : b; // 如果 a 大于 b，则取 a，否则取 b

上面的代码中，如果 a 大于 b，则 max 的值为 a，否则为 b。

条件运算符通常在需要根据条件选择不同值的情况下使用，可以减少代码量，使得代码更加简洁和易读。但是过度使用可能会降低代码的可读性，因此需要适度使用。

instanceof 运算符：

用于检查对象是否是特定类的实例。

• instanceof

流程控制（if语句、switch语句、循环等）

if 语句：

if 语句用于根据条件执行代码块。它的基本结构如下：

if (condition) { 
// 当条件为真时执行的代码块 } else if (anotherCondition) {
 // 当另一个条件为真时执行的代码块 } else {
 // 当所有条件都不满足时执行的代码块 } 

switch 语句：

switch 语句用于根据表达式的值选择执行不同的代码块。它的基本结构如下：

switch (expression) { 
        case value1: // 当表达式的值等于 value1 时执行的代码块 break; 
        case value2: // 当表达式的值等于 value2 时执行的代码块 break; 
        default: // 当表达式的值与所有 case 值都不匹配时执行的代码块 break; 
} 

循环结构：

循环结构用于重复执行某段代码，直到满足退出条件。Java 中有三种常见的循环结构：

for 循环：

for 循环用于按照指定的次数重复执行代码块。它的基本结构如下：

for (initialization; condition; update) { // 循环体 } 

while 循环：

while 循环用于在条件为真时重复执行代码块。它的基本结构如下：

while (condition) { // 循环体 } 

do-while 循环：

do-while 循环与 while 循环类似，但它会先执行一次循环体，然后在每次循环迭代之前检查条件。它的基本结构如下：

do { // 循环体 } while (condition); 

这些流程控制结构在 Java 中是非常常见的，可以根据不同的需求选择适合的结构来控制程序的执行流程。

面向对象编程：

类和对象

类（Class）：

类是一种模板或蓝图，用于创建对象的定义。它描述了对象的属性和行为。类是一个抽象的概念，它定义了对象的通用特征，但并不直接表示任何特定的对象。类包括两个主要部分：

1. 属性（Fields）：也称为成员变量或实例变量，用于描述对象的状态或特征。

2. 方法（Methods）：用于描述对象的行为或功能。方法定义了可以在对象上执行的操作。

对象（Object）：

对象是类的实例化。它是类的具体实体，具有类定义的属性和行为。可以将对象视为类的实例，每个对象都有自己的状态（即属性的值）和行为（即方法的调用）。对象可以通过 new 关键字来创建，并且可以通过对象的引用来访问其属性和调用其方法。

类是对象的抽象 对象是类的实例：

类是对象的抽象：

• 概念上的模板：类是对具有相似属性和行为的一组对象的抽象描述。它定义了对象的通用特征，包括属性和方法。

• 模板的定义：类定义了对象的结构和行为，但不直接表示任何特定的对象。它可以看作是一种数据类型，描述了对象的结构和行为。

• 抽象性质：类中的属性和方法可以具有抽象性，即它们可以描述对象的通用特征，而不是特定的实例。

对象是类的实例：

• 具体的实体：对象是类的具体实例，它具有类定义的属性和行为。每个对象都是类的一个独立实体。

• 实例化：对象是通过类进行实例化创建的，使用类作为模板创建具体的实体。

• 特定的实例：每个对象都有自己的状态（即属性的值）和行为（即方法的调用）。对象是类的实例化结果，代表了现实世界中的具体事物。

继承

继承是面向对象编程中的重要概念，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。继承是面向对象编程的三大特性之一，另外两个特性是封装和多态。

继承的优点：

1. 代码重用：子类可以重用父类的属性和方法，避免了重复编写相同的代码。
2. 扩展性：子类可以在不改变父类的情况下，新增自己的属性和方法，从而扩展父类的功能。
3. 逻辑层次清晰：通过继承可以建立类之间的层次关系，使得代码更具结构性和可读性。

继承的语法：

在 Java 中，使用 extends 关键字来实现继承。子类继承父类的语法格式如下：

class SubClass extends SuperClass { // 子类的其他属性和方法 } 

示例：

class Animal {
    void eat() {
        System.out.println("Animal is eating.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking.");
    }
}

在上面的示例中，Dog 类继承了 Animal 类。Dog 类继承了 Animal 类的 eat() 方法，同时还定义了自己的 bark() 方法。

继承的特点：

1. 单继承：Java 中不支持多重继承，即一个子类只能继承一个父类。
2. 多层继承：子类可以进一步作为其他类的父类，形成多层继承的层次结构。
3. super 关键字：子类可以使用 super 关键字调用父类的构造方法和成员方法。

在面向对象编程中，超类（Superclass）是指在继承关系中位于更高层次的类，也称为父类（Parent Class）或基类（Base Class）。子类（Subclass）是指继承超类的类。

超类的特点：

1. 提供通用功能：超类通常包含一组通用的属性和方法，它定义了多个子类共享的行为。

2. 作为模板：超类可以被子类用作模板，子类可以继承超类的属性和方法，并在此基础上进行扩展或修改。

3. 层次结构：超类和子类之间可以形成层次结构，子类可以继承超类，而超类本身也可以是另一个超类的子类，从而形成多层继承的关系。

示例：

class Animal {
    void eat() {
        System.out.println("Animal is eating.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking.");
    }
}

在上面的示例中，Animal 类是 Dog 类的超类。Dog 类继承了 Animal 类的 eat() 方法，因此 Animal 类是 Dog 类的超类。

使用 super 关键字访问超类：

子类可以使用 super 关键字来引用其直接超类的属性和方法。通过 super 关键字，子类可以调用超类的构造方法、成员方法和成员变量。

class Animal {
    void eat() {
        System.out.println("Animal is eating.");
    }
}

class Dog extends Animal {
    void eat() {
        super.eat(); // 调用超类的 eat() 方法
        System.out.println("Dog is eating.");
    }
}

在上面的示例中，Dog 类重写了 Animal 类的 eat() 方法，并使用 super.eat() 调用了超类的 eat() 方法。

总结：

超类在面向对象编程中起着重要作用，它提供了通用的功能和行为，子类可以继承超类并在此基础上进行扩展。超类和子类之间形成了继承关系，使得代码更具结构性和可维护性。

总结：

继承是面向对象编程中一种重要的机制，它允许子类继承父类的属性和方法，从而实现代码的重用和扩展。通过继承可以建立类之间的层次结构，使得代码更具结构性和可维护性。

多态

多态（Polymorphism）是面向对象编程中的一个重要概念，它允许使用基类的引用来指向子类的对象，并在运行时确定所调用的方法。多态使得代码更加灵活，可扩展性更强。

多态的特点：

1. 方法重写：子类可以重写（覆盖）超类的方法，从而实现对方法的定制化。

2. 动态绑定：在运行时，Java 虚拟机根据对象的实际类型来调用相应的方法，而不是根据引用变量的类型。

3. 基类引用指向子类对象：可以使用基类的引用来指向子类的对象，从而实现对不同类型对象的统一处理。

示例：

class Animal {
    void makeSound() {
        System.out.println("Animal makes a sound.");
    }
}

class Dog extends Animal {
    void makeSound() {
        System.out.println("Dog barks.");
    }
}

class Cat extends Animal {
    void makeSound() {
        System.out.println("Cat meows.");
    }
}

在上面的示例中，Animal 类有一个 makeSound() 方法，Dog 类和 Cat 类都重写了这个方法。然后可以使用多态来调用这个方法：

Animal dog = new Dog();
Animal cat = new Cat();

dog.makeSound();  // 输出：Dog barks.
cat.makeSound();  // 输出：Cat meows.

在上面的示例中，dog 和 cat 都是 Animal 类型的引用，但它们分别指向了 Dog 类对象和 Cat 类对象。在运行时，虚拟机会根据实际对象的类型来决定调用哪个类的方法。

多态的优点：

1. 简化代码：可以通过统一的接口来操作不同类型的对象，简化了代码的实现和维护。

2. 增加灵活性：可以轻松地扩展和修改程序，使得程序更加灵活和可扩展。

总结：

多态是面向对象编程的一个重要概念，它通过方法重写和动态绑定实现了对不同类型对象的统一处理。多态使得代码更加灵活、简洁和可扩展，提高了程序的可维护性和可读性。

封装

封装（Encapsulation）是面向对象编程中的一个重要概念，它指的是将数据和操作数据的方法打包到一个单元（即类）中，并对外部隐藏对象的工作原理。封装可以实现数据的隐藏和保护，使得对象的内部状态只能通过对象的公有方法进行访问和修改。

封装的特点：

1. 隐藏内部细节：封装将对象的实现细节隐藏起来，只暴露必要的接口给外部使用者，使得外部用户无需了解对象的内部实现细节。

2. 数据保护：通过封装可以限制对对象数据的访问，使得对象的数据只能通过特定的方法进行访问和修改，从而确保数据的安全性。

3. 提高可维护性：封装使得对象的内部实现可以独立地修改，而不会影响到外部用户，从而提高了代码的可维护性。

封装的实现：

在 Java 中，封装通过类的访问修饰符来实现：

• private：私有访问修饰符，只能在类的内部访问。

• protected：受保护访问修饰符，只能在同一个包内或子类中访问。

• public：公有访问修饰符，可以被任意类访问。

• default：默认访问修饰符，只能在同一个包内访问。

示例：

public class Circle {
    private double radius;

    public Circle(double radius) {
        setRadius(radius);
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        if (radius > 0) {
            this.radius = radius;
        } else {
            System.out.println("Invalid radius.");
        }
    }

    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

在上面的示例中，Circle 类封装了一个半径属性 radius，并提供了公有的方法 getRadius() 和 setRadius(double radius) 来访问和修改半径属性。这样就可以确保半径属性的安全性，同时外部用户可以通过公有方法来操作半径属性，而不需要了解具体的实现细节。

封装的优点：

1. 安全性：封装可以保护对象的数据不被不相关的类直接访问和修改，确保数据的安全性。

2. 灵活性：封装使得对象的内部实现可以独立地修改，而不会影响到外部用户，从而提高了代码的灵活性。

3. 可维护性：封装使得对象的内部实现与外部接口分离，使得代码更易于维护和修改。

总结：

封装是面向对象编程的一个重要特性，它通过将数据和操作数据的方法打包到一个单元中，实现了数据的隐藏和保护。封装提高了代码的安全性、灵活性和可维护性，是面向对象编程的基础之一。

抽象类和接口

抽象类（Abstract Class）：

1. 特点：

   • 抽象类是一种类，不能被实例化，只能被继承。
   • 抽象类可以包含抽象方法和非抽象方法。
   • 抽象方法是一种没有具体实现的方法，需要由子类提供具体实现。
   • 子类必须实现所有抽象方法才能被实例化。

2. 用途：

   • 抽象类通常用于定义一些通用的行为和属性，并且要求子类提供具体实现。它们通常用于建模类之间的层次结构，并提供一些通用的行为。

接口（Interface）：

1. 特点：

   • 接口是一种抽象类型，它定义了一组抽象方法和常量。
   • 接口中的方法默认是公有的抽象方法，不需要使用 abstract 关键字。
   • 一个类可以实现多个接口。

2. 用途：

   • 接口用于定义规范和行为，它定义了一个类应该具有的方法和常量，但不提供具体实现。它们通常用于描述对象的行为。

区别：

1. 实现方式：

   • 抽象类是一种普通类，可以包含成员变量、构造方法和非抽象方法。
   • 接口是一种特殊的抽象类，它只包含抽象方法和常量，不能包含成员变量和非抽象方法。

2. 继承关系：

   • 类可以继承一个抽象类，并且可以同时实现多个接口。
   • 一个接口可以继承多个其他接口。

3. 用途：

   • 抽象类通常用于建模类之间的层次结构，提供一些通用的行为和属性。
   • 接口用于定义规范和行为，描述对象的行为。

示例：

// 抽象类
abstract class Shape {
    abstract void draw(); // 抽象方法

    void print() {
        System.out.println("This is a shape.");
    }
}

// 实现抽象类
class Circle extends Shape {
    void draw() {
        System.out.println("Drawing a circle.");
    }
}

// 接口
interface Drawable {
    void draw(); // 抽象方法

    default void print() { // 默认方法
        System.out.println("This is a drawable object.");
    }
}

// 实现接口
class Rectangle implements Drawable {
    public void draw() {
        System.out.println("Drawing a rectangle.");
    }
}

在上面的示例中，Shape 是一个抽象类，它包含一个抽象方法 draw() 和一个非抽象方法 print()。Drawable 是一个接口，它包含一个抽象方法 draw() 和一个默认方法 print()。Circle 类继承了 Shape 抽象类并实现了 draw() 方法，而 Rectangle 类实现了 Drawable 接口并提供了 draw() 方法的具体实现。

核心类库：

字符串操作

字符串操作是在程序中对字符串进行各种处理和操作的过程。在 Java 中，字符串是不可变的，即一旦创建就不能被修改。因此，对字符串的操作通常会返回一个新的字符串对象。常见的字符串操作包括以下几种：

创建字符串：

String str = "Hello, World!"; // 直接赋值 
String str2 = new String("Hello"); // 使用构造函数 

获取字符串长度：

int length = str.length(); // 返回字符串的长度 

拼接字符串：

String concatStr = str.concat(" Welcome"); // 使用 concat 方法拼接字符串 
String plusStr = str + " Welcome"; // 使用加号拼接字符串 

提取子字符串：

String subStr = str.substring(7); // 提取从索引 7 开始到末尾的子字符串 
String subStr2 = str.substring(7, 12); // 提取从索引 7 开始到索引 12 的子字符串 

替换字符串：

String replacedStr = str.replace("World", "Java"); // 替换字符串中的指定内容 

转换大小写：

String lowerCaseStr = str.toLowerCase(); // 将字符串转换为小写 
String upperCaseStr = str.toUpperCase(); // 将字符串转换为大写 

去除空白：

String trimmedStr = str.trim(); // 去除字符串两端的空白字符 

比较字符串：

boolean isEqual = str.equals(str2); // 比较两个字符串是否相等 
int compareResult = str.compareTo(str2); // 比较两个字符串的大小关系 

搜索字符串：

int index = str.indexOf("World"); // 在字符串中查找指定子字符串的索引 
int lastIndex = str.lastIndexOf("l"); // 在字符串中查找指定字符的最后一个索引 

切割字符串：

String[] parts = str.split(","); // 将字符串按指定分隔符切割成数组

集合框架（List、Set、Map等）

集合框架（Collection Framework）是 Java 中用于存储和操作对象集合的一组类和接口。它提供了一种统一的方式来管理和操作集合，包括列表（List）、集（Set）、映射（Map）等。

列表（List）：

列表是有序的集合，允许存储重复元素。Java 中常见的列表实现类包括 ArrayList、LinkedList、Vector 等。

List<String> list = new ArrayList<>(); 
list.add("Apple"); 
list.add("Banana"); 
list.add("Apple"); 

集（Set）：

集是不允许存储重复元素的集合，它不保证元素的顺序。Java 中常见的集实现类包括 HashSet、LinkedHashSet、TreeSet 等。

Set<String> set = new HashSet<>(); 
set.add("Apple"); set.add("Banana"); 
set.add("Apple"); // 不会被添加进集合中 

映射（Map）：

映射是一种键值对的集合，每个键对应一个值，键是唯一的。Java 中常见的映射实现类包括 HashMap、LinkedHashMap、TreeMap 等。

Map<String, Integer> map = new HashMap<>(); 
map.put("Apple", 1); 
map.put("Banana", 2); 

队列（Queue）：

队列是一种先进先出（FIFO）的集合，常用于存储需要按顺序处理的元素。Java 中常见的队列实现类包括 LinkedList、PriorityQueue 等。

Queue<String> queue = new LinkedList<>(); 
queue.add("Apple"); 
queue.add("Banana"); 

栈（Stack）：

栈是一种后进先出（LIFO）的集合，常用于实现算法和数据结构中的操作。Java 中的 Stack 类实现了栈的基本功能。

Stack<String> stack = new Stack<>(); 
stack.push("Apple"); 
stack.push("Banana"); 

Java 的集合框架提供了丰富的类和接口来支持各种类型的集合操作，开发人员可以根据具体需求选择合适的集合类型和实现类来使用。

迭代器（Iterator）是 Java 中用于遍历集合（Collection）对象的接口，它提供了一种统一的方式来访问集合中的元素，而不需要了解底层数据结构的细节。通过迭代器，可以依次访问集合中的每个元素，并且可以在遍历的过程中进行元素的增删改查操作。

迭代器接口（Iterator）：

Java 中的迭代器接口定义在 java.util.Iterator 中，它包含以下几个常用的方法：

• boolean hasNext()：判断集合中是否还有下一个元素。
• E next()：返回集合中的下一个元素，并将指针移动到下一个位置。
• void remove()：从集合中移除上一个 next() 方法返回的元素（可选操作）。

使用迭代器遍历集合：

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
}

迭代器的特点：

1. 封装性：迭代器封装了集合的遍历过程，隐藏了底层数据结构的细节。
2. 遍历顺序：迭代器可以按照集合中元素的顺序依次访问每个元素。
3. 安全性：使用迭代器遍历集合可以避免并发修改异常（ConcurrentModificationException）。

注意事项：

1. 在使用迭代器遍历集合的过程中，如果在遍历过程中修改了集合的结构（如增删元素），会导致并发修改异常。
2. 在遍历集合的过程中，应该使用迭代器的 remove() 方法来安全地移除元素，而不是直接调用集合的 remove() 方法。

迭代器是 Java 集合框架中的重要组成部分，它提供了一种简单而有效的方式来遍历集合中的元素，并且可以在遍历过程中进行增删改查操作，是 Java 中常用的编程工具之一。

 

数组

数组是一种用于存储相同类型数据元素的集合，它是在内存中连续分配的一段存储空间。在 Java 中，数组是对象，它具有固定的长度，一旦创建后大小就不能改变。

创建数组：

在 Java 中，可以使用以下语法来创建数组：

// 声明并初始化数组 
int[] numbers = {1, 2, 3, 4, 5}; 
// 声明数组并指定长度，然后初始化数组元素 
int[] numbers2 = new int[5]; 
numbers2[0] = 1; 
numbers2[1] = 2; 
numbers2[2] = 3; 
numbers2[3] = 4; 
numbers2[4] = 5; 

访问数组元素：

可以使用索引来访问数组元素，索引从 0 开始，最大索引为数组长度减 1。

int firstElement = numbers[0]; // 访问第一个元素 
int lastElement = numbers[numbers.length - 1]; // 访问最后一个元素 

数组的长度：

可以使用 length 属性来获取数组的长度。

int length = numbers.length; // 获取数组的长度 

遍历数组：

可以使用循环语句来遍历数组元素。

for (int i = 0; i < numbers.length; i++) { 
        System.out.println(numbers[i]); 
} 

增强的 for 循环（Enhanced for Loop）也称为 for-each 循环，是 Java 5 中引入的一种简化遍历集合或数组的语法。它提供了一种更加简洁、易读的方式来遍历数组或集合中的元素。

语法：

for (元素类型 变量名 : 集合或数组) { // 循环体，使用变量名访问每个元素 } 

示例：

int[] numbers = {1, 2, 3, 4, 5}; 
for (int number : numbers) { System.out.println(number); } 

上面的示例使用增强的 for 循环遍历了数组 numbers 中的每个元素，并打印了每个元素的值。

特点：

1. 简洁性：增强的 for 循环简化了遍历集合或数组的语法，减少了代码量。

2. 易读性：增强的 for 循环更加直观，使得代码更易于阅读和理解。

3. 安全性：增强的 for 循环可以避免数组越界和空指针异常，提高了代码的安全性。

注意事项：

1. 增强的 for 循环适用于遍历数组和实现了 Iterable 接口的集合类。

2. 在增强的 for 循环中，无法修改集合或数组中的元素，只能访问每个元素的值。

增强的 for 循环是 Java 中常用的语法特性之一，它提供了一种简单而有效的方式来遍历集合或数组中的元素，减少了代码的复杂性和出错的可能性。

多维数组：

Java 支持多维数组，例如二维数组、三维数组等。

// 声明并初始化二维数组 
int[][] matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; // 访问二维数组元素 
int element = matrix[0][0]; // 访问第一行第一列的元素 

注意事项：

1. 数组是固定长度的，一旦创建后长度不能改变。
2. 数组的索引从 0 开始，最大索引为数组长度减 1。
3. 数组可以存储基本数据类型和对象类型。

数组是 Java 中常用的数据结构之一，它提供了一种有效的方式来存储和操作多个相同类型的数据元素。

输入输出（IO）

输入输出（I/O）是计算机程序中非常重要的一部分，它涉及程序与外部环境（如文件、网络、键盘、显示器等）之间的数据传输。在 Java 中，输入输出主要通过输入流（InputStream）、输出流（OutputStream）、读取器（Reader）、写入器（Writer）等类和接口来实现。

输入输出流（IO Stream）：

Java 中的输入输出流是用于处理字节和字符数据的基本工具。输入流用于从外部读取数据，输出流用于向外部写入数据。

字节流（Byte Stream）：

• InputStream：字节输入流的抽象基类。
• OutputStream：字节输出流的抽象基类。

字符流（Character Stream）：

• Reader：字符输入流的抽象基类。
• Writer：字符输出流的抽象基类。

文件输入输出（File IO）：

Java 提供了 File 类来表示文件和目录，同时提供了许多用于文件输入输出的类和接口，如 FileInputStream、FileOutputStream、FileReader、FileWriter 等。

try (FileInputStream fis = new FileInputStream("input.txt");
     FileOutputStream fos = new FileOutputStream("output.txt")) {
    int data;
    while ((data = fis.read()) != -1) {
        fos.write(data);
    }
} catch (IOException e) {
    e.printStackTrace();
}

缓冲输入输出（Buffered IO）：

Java 提供了 BufferedReader 和 BufferedWriter 类来提供缓冲功能，可以提高读写文件的效率。

try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"));
     BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        writer.write(line);
        writer.newLine();
    }
} catch (IOException e) {
    e.printStackTrace();
}

标准输入输出（Standard IO）：

Java 提供了 System.in 和 System.out 对象来表示标准输入流和标准输出流，可以用于从键盘读取输入和向控制台输出数据。

try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
    String line = reader.readLine();
    System.out.println("You entered: " + line);
} catch (IOException e) {
    e.printStackTrace();
}

序列化和反序列化（Serialization）：

Java 提供了对象序列化（Serialization）和反序列化（Deserialization）功能，可以将对象转换成字节流进行存储和传输。

try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("data.ser"));
     ObjectInputStream ois = new ObjectInputStream(new FileInputStream("data.ser"))) {
    MyClass obj1 = new MyClass();
    oos.writeObject(obj1);
    MyClass obj2 = (MyClass) ois.readObject();
} catch (IOException | ClassNotFoundException e) {
    e.printStackTrace();
}

Java 的输入输出系统提供了丰富的功能和灵活的接口，可以满足各种不同场景下的需求，是 Java 程序中不可或缺的一部分。

异常处理

异常处理是编程中常见的一种机制，用于处理程序运行过程中出现的错误和异常情况，以保证程序的稳定性和可靠性。在 Java 中，异常处理主要通过 try-catch 块、throw 语句和 finally 块来实现。

try-catch 块：

try-catch 块用于捕获和处理可能抛出异常的代码块。

try {
    // 可能抛出异常的代码
} catch (ExceptionType1 e1) {
    // 处理 ExceptionType1 类型的异常
} catch (ExceptionType2 e2) {
    // 处理 ExceptionType2 类型的异常
} finally {
    // 可选的 finally 块，用于执行清理操作，无论是否发生异常都会执行
}

throw 语句：

throw 语句用于在代码块中显式地抛出异常。

if (condition) {
    throw new SomeException("Error message");
}

异常类层次结构：

Java 中的异常类都是从 Throwable 类继承而来的，它分为两种类型：

1. 检查型异常（Checked Exception）：需要在代码中显式地处理或声明的异常，如 IOException、SQLException 等。

2. 非检查型异常（Unchecked Exception）：不需要在代码中显式地处理或声明的异常，如 RuntimeException、NullPointerException 等。

finally 块：

finally 块用于执行清理操作，无论是否发生异常都会执行。

try {
    // 可能抛出异常的代码
} finally {
    // finally 块中的代码会在 try 或 catch 块执行完毕后执行
}

自定义异常：

可以通过继承 Exception 或 RuntimeException 类来创建自定义异常类。

class MyException extends Exception {
    public MyException(String message) {
        super(message);
    }
}

示例：

try {
    int result = divide(10, 0);
    System.out.println("Result: " + result);
} catch (ArithmeticException e) {
    System.out.println("Error: " + e.getMessage());
} finally {
    System.out.println("Cleanup code");
}

int divide(int a, int b) throws ArithmeticException {
    if (b == 0) {
        throw new ArithmeticException("Division by zero");
    }
    return a / b;
}

在上面的示例中，try 块中的代码尝试调用 divide 方法进行除法运算，如果除数为 0 则会抛出 ArithmeticException 异常，catch 块捕获并处理异常，finally 块中的代码会在 try 或 catch 块执行完毕后执行。

正则表达式

正则表达式（Regular Expression）是一种强大的模式匹配和文本搜索工具，它用于描述字符串的特征模式，可以用来检查字符串是否匹配某种模式、搜索字符串中的特定内容、替换字符串中的匹配内容等操作。

基本语法：

1. 普通字符：普通字符在正则表达式中表示它们本身，例如 abc 表示匹配字符串中的 "abc"。

2. 字符类：用方括号 [] 表示，表示匹配其中任意一个字符，例如 [abc] 表示匹配字符串中的 "a"、"b" 或 "c" 中的任意一个字符。

3. 量词：用于指定匹配模式的重复次数，例如 * 表示零次或多次、+ 表示一次或多次、? 表示零次或一次、{n} 表示恰好 n 次等。

4. 特殊字符：一些特殊字符在正则表达式中具有特殊的含义，例如 . 表示匹配任意字符、^ 表示匹配字符串的开始、$ 表示匹配字符串的结束等。

5. 分组：用小括号 () 表示，可以将多个表达式组合成一个整体进行匹配，例如 (abc)+ 表示匹配一个或多个 "abc"。

6. 转义字符：使用反斜杠 \ 将特殊字符转义，使其成为普通字符，例如 \. 表示匹配 "."。

Java 中的正则表达式：

在 Java 中，正则表达式的使用主要依赖于 java.util.regex 包中的类。

import java.util.regex.*;

String pattern = "a*b"; // 定义正则表达式模式
String text = "aaab"; // 要匹配的字符串

Pattern p = Pattern.compile(pattern); // 编译正则表达式
Matcher m = p.matcher(text); // 创建 Matcher 对象

if (m.matches()) {
    System.out.println("Match found!");
} else {
    System.out.println("No match found!");
}

常用方法：

• matches()：尝试将整个输入序列与该模式匹配。
• find()：尝试查找与该模式匹配的输入序列的下一个子序列。
• group()：返回由以前匹配操作所匹配的输入子序列。
• replaceAll()：使用给定的替换替换此模式匹配的所有子序列。

示例：

String text = "The quick brown fox jumps over the lazy dog.";
String pattern = "fox";

Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher(text);

while (m.find()) {
    System.out.println("Found match: " + m.group() + " at index " + m.start());
}

上面的示例使用正则表达式 "fox" 在文本中查找匹配的字符串，找到后打印匹配的字符串和位置索引。

正则表达式是一种强大的文本处理工具，在 Java 中广泛应用于字符串匹配、文本搜索、数据验证等场景。熟练掌握正则表达式的基本语法和常用方法能够帮助程序员更高效地进行文本处理工作。

并发编程：

线程创建和管理

在 Java 中，线程创建和管理主要通过 java.lang.Thread 类和 java.lang.Runnable 接口来实现。线程是程序中执行的最小单元，它允许程序同时执行多个任务，提高了程序的并发性和效率。

创建线程：

方法一：继承 Thread 类：

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread running...");
    }
}

// 创建并启动线程
MyThread thread = new MyThread();
thread.start();

方法二：实现 Runnable 接口：

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread running...");
    }
}

// 创建线程，并将 Runnable 对象作为参数传递给 Thread 类
Thread thread = new Thread(new MyRunnable());
thread.start();

线程生命周期：

1. 新建（New）：创建了线程对象，但还未调用 start() 方法。
2. 就绪（Runnable）：线程调用了 start() 方法，处于就绪状态，等待获取 CPU 时间片执行。
3. 运行（Running）：线程获取到 CPU 时间片，开始执行任务。
4. 阻塞（Blocked）：线程被阻塞，暂时无法继续执行，例如等待输入输出、等待锁等。
5. 等待（Waiting）：线程处于等待状态，等待某个条件满足。
6. 超时等待（Timed Waiting）：线程等待一定时间后自动恢复。
7. 终止（Terminated）：线程执行完任务或者出现异常终止。

线程管理：

• sleep() 方法：让当前线程休眠一段时间。

• join() 方法：等待线程执行完毕。

• interrupt() 方法：中断线程的执行。

• yield() 方法：暂停当前正在执行的线程对象，并执行其他线程。

线程同步与互斥：

• synchronized 关键字：同步方法或代码块，确保多个线程访问共享资源时的互斥性。

• volatile 关键字：确保变量的可见性，多个线程对变量的修改对其他线程是可见的。

• Lock 接口：JDK 提供的显式锁，通过 Lock 对象来进行线程的同步和互斥操作。

线程池：

使用线程池可以有效地管理和调度线程，避免频繁地创建和销毁线程对象，提高了系统的性能和资源利用率。

ExecutorService executor = Executors.newFixedThreadPool(5); // 创建固定大小的线程池
executor.execute(new MyRunnable()); // 提交任务给线程池执行
executor.shutdown(); // 关闭线程池

Java 提供了丰富的线程管理和控制功能，能够满足不同场景下的多线程编程需求。合理地使用线程可以提高程序的并发性和性能。

同步和互斥

同步（Synchronization）和互斥（Mutual Exclusion）是多线程编程中常用的概念，用于确保多个线程之间对共享资源的访问的安全性和正确性。

同步（Synchronization）：

在多线程环境下，多个线程可能同时访问共享资源，如果不加以控制，可能会导致数据不一致、逻辑错误等问题。同步机制可以确保多个线程按照一定的顺序访问共享资源，避免出现竞态条件（Race Condition）。

在 Java 中，可以使用以下方式实现同步：

• synchronized 关键字：可以修饰方法或代码块，确保同一时间只有一个线程可以访问被 synchronized 修饰的代码。

public synchronized void synchronizedMethod() { // 同步代码块 } 

互斥（Mutual Exclusion）：

互斥是一种资源管理技术，用于保护临界区（Critical Section），确保在同一时间只有一个线程可以访问共享资源。互斥锁是实现互斥的一种常见方式，它在一个线程访问共享资源时对其他线程进行阻塞，直到该线程释放资源后其他线程才能继续执行。

在 Java 中，互斥可以通过以下方式实现：

• Lock 接口：JDK 提供的显式锁机制，通过 Lock 对象来控制对共享资源的访问。

Lock lock = new ReentrantLock(); 
lock.lock();// 获取锁 
try { // 访问共享资源 } 
finally { lock.unlock(); // 释放锁 } 

区别：

• 同步是一种更广泛的概念，它可以用于实现互斥，也可以用于协调多个线程的执行顺序。

• 互斥专指保护临界区的访问，确保在同一时间只有一个线程可以访问共享资源。

在多线程编程中，同步和互斥是确保线程安全的重要手段，合理地使用可以避免竞态条件和数据不一致等问题，提高程序的健壮性和可靠性。

线程池

线程池（Thread Pool）是一种管理和复用线程的机制，它能够有效地管理多个线程，并在需要时分配线程执行任务，避免了频繁地创建和销毁线程对象，提高了系统的性能和资源利用率。

在 Java 中，线程池由 java.util.concurrent.ExecutorService 接口和其实现类来实现。

创建线程池：

Java 提供了几种常见的线程池实现：

1. FixedThreadPool：固定大小的线程池，线程数量固定，不会更改。

ExecutorService executor = Executors.newFixedThreadPool(5); 

1. CachedThreadPool：可缓存的线程池，线程数量不固定，会根据任务的数量自动调整线程数量。

ExecutorService executor = Executors.newCachedThreadPool(); 

1. SingleThreadPool：单线程的线程池，只有一个线程在工作，其他任务在队列中等待。

ExecutorService executor = Executors.newSingleThreadExecutor(); 

1. ScheduledThreadPool：可定时执行任务的线程池，可以执行定时任务和周期性任务。

ScheduledExecutorService executor = Executors.newScheduledThreadPool(5); 

提交任务给线程池执行：

executor.submit(new RunnableTask()); 

关闭线程池：

关闭线程池可以通过调用 shutdown() 或 shutdownNow() 方法来实现：

• shutdown()：优雅地关闭线程池，等待所有任务执行完毕后关闭。

• shutdownNow()：立即关闭线程池，不等待正在执行的任务完成。

executor.shutdown(); // 关闭线程池 

线程池的优势：

1. 降低资源消耗：线程池可以复用线程，避免了频繁地创建和销毁线程对象，降低了系统的资源消耗。

2. 提高响应速度：线程池可以有效地管理和调度线程，使得任务可以及时得到处理，提高了系统的响应速度。

3. 提高系统稳定性：线程池可以控制并发的线程数量，避免了系统因为线程过多导致的资源竞争和负载过高的问题，提高了系统的稳定性。

注意事项：

• 使用线程池时需要根据实际情况选择合适的线程池类型和大小，避免线程池过大或过小导致性能问题。

• 线程池使用完毕后应该及时关闭，以释放资源。

并发集合

并发集合是在多线程环境中使用的数据结构，它们提供了线程安全的操作，可以在多个线程同时访问时确保数据的一致性和可靠性。Java 提供了一系列并发集合类，位于 java.util.concurrent 包下。

常见的并发集合类：

1. ConcurrentHashMap：并发安全的哈希表，适用于高并发读写场景。

ConcurrentMap<Key, Value> map = new ConcurrentHashMap<>(); 

1. CopyOnWriteArrayList：并发安全的列表，适用于读操作远远多于写操作的场景。

List<Value> list = new CopyOnWriteArrayList<>(); 

1. CopyOnWriteArraySet：并发安全的集合，基于 CopyOnWriteArrayList 实现。

Set<Value> set = new CopyOnWriteArraySet<>(); 

1. ConcurrentSkipListMap：基于跳表（Skip List）的并发安全的有序映射。

ConcurrentNavigableMap<Key, Value> map = new ConcurrentSkipListMap<>(); 

1. ConcurrentSkipListSet：基于跳表的并发安全的有序集合。

ConcurrentNavigableSet<Value> set = new ConcurrentSkipListSet<>(); 

特点：

• 线程安全：并发集合类通过内部的锁机制或无锁的数据结构实现了线程安全，可以在多线程环境中安全地使用。

• 高效性：并发集合类在保证线程安全的同时，尽可能地提高了性能，减少了线程竞争和锁的争用。

使用注意事项：

• 选择合适的集合：根据实际场景和需求选择合适的并发集合类，避免不必要的资源消耗和性能损失。

• 迭代操作：在迭代并发集合时，需要使用迭代器的安全版本（如 ConcurrentHashMap 的 keySet().iterator()），或者在迭代过程中对集合进行快照，避免并发修改异常。

• 适当性分析：尽管并发集合提供了线程安全的操作，但并不意味着在所有场景下都适合使用。需要根据实际情况分析选择合适的数据结构和并发策略。

并发集合是多线程编程中非常重要的一部分，它提供了一种高效、安全的方式来管理多线程环境下的数据访问，能够有效地提高系统的并发能力和稳定性。

网络编程：

Socket编程

Socket编程是一种用于实现网络通信的编程方式，它允许计算机上的不同进程之间通过网络进行通信，实现数据的传输和交换。在 Java 中，Socket编程主要使用 java.net 包中的类来实现。

客户端-服务器模型：

Socket编程通常基于客户端-服务器模型，其中服务器端监听指定端口，等待客户端连接请求，而客户端向服务器发起连接请求，建立连接后进行数据交换。

创建服务器端：

import java.net.*;
import java.io.*;

public class Server {
    public static void main(String[] args) {
        try (ServerSocket serverSocket = new ServerSocket(8080)) {
            System.out.println("Server started, waiting for client connection...");
            Socket clientSocket = serverSocket.accept();
            System.out.println("Client connected: " + clientSocket.getInetAddress().getHostName());
            
            BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
            
            String message = in.readLine();
            System.out.println("Received message from client: " + message);
            
            out.println("Server received: " + message);
            
            clientSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

创建客户端：

import java.net.*;
import java.io.*;

public class Client {
    public static void main(String[] args) {
        try (Socket socket = new Socket("localhost", 8080)) {
            System.out.println("Connected to server: " + socket.getInetAddress().getHostName());
            
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            
            out.println("Hello, server!");
            
            String response = in.readLine();
            System.out.println("Server response: " + response);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

注意事项：

• 在服务器端，使用 ServerSocket 监听指定端口，并调用 accept() 方法接受客户端连接请求。

• 在客户端，使用 Socket 类指定服务器地址和端口，并调用 connect() 方法连接到服务器。

• 在客户端和服务器端，通过输入输出流进行数据的读写操作。

Socket编程是实现网络通信的基础，能够在不同计算机上的进程之间实现数据的传输和交换，是构建网络应用程序的重要组成部分。

URL处理

在 Java 中，可以使用 java.net.URL 类来处理统一资源定位符（URL），它提供了访问、解析和操作 URL 的方法。

创建 URL 对象：

import java.net.*;

public class Main {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://www.example.com/path/to/resource?param1=value1&param2=value2");
            System.out.println("Protocol: " + url.getProtocol());
            System.out.println("Host: " + url.getHost());
            System.out.println("Port: " + url.getPort());
            System.out.println("Path: " + url.getPath());
            System.out.println("Query: " + url.getQuery());
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }
}

常用方法：

• getProtocol()：获取 URL 的协议部分（如 "http"、"https"）。

• getHost()：获取 URL 的主机名部分。

• getPort()：获取 URL 的端口号部分。

• getPath()：获取 URL 的路径部分。

• getQuery()：获取 URL 的查询字符串部分。

解析 URL 参数：

import java.net.*;

public class Main {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://www.example.com/path/to/resource?param1=value1&param2=value2");
            String query = url.getQuery();
            String[] params = query.split("&");
            for (String param : params) {
                String[] keyValue = param.split("=");
                String key = keyValue[0];
                String value = keyValue.length > 1 ? keyValue[1] : "";
                System.out.println("Parameter: " + key + " = " + value);
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }
}

构建 URL 对象：

try {
    URL baseUrl = new URL("https://www.example.com");
    URL url = new URL(baseUrl, "/path/to/resource?param1=value1&param2=value2");
    System.out.println("Full URL: " + url);
} catch (MalformedURLException e) {
    e.printStackTrace();
}

注意事项：

• 在处理 URL 时，要注意捕获 MalformedURLException 异常，处理 URL 格式不正确的情况。

• 对于查询字符串部分，可以使用 URLDecoder 对其进行解码，例如 URLDecoder.decode(query, "UTF-8")。

URL 类提供了丰富的方法来处理和操作 URL，在网络编程和Web开发中经常用到，能够方便地对 URL 进行解析和构建，进行网络资源的访问和操作。

HTTP客户端和服务器

HTTP（Hypertext Transfer Protocol）是一种用于传输超文本的应用层协议，是互联网上应用最为广泛的协议之一。在 Java 中，可以使用 java.net 包中的类来实现 HTTP 客户端和服务器。

HTTP 客户端：

import java.io.*;
import java.net.*;

public class HttpClientExample {
    public static void main(String[] args) {
        try {
            URL url = new URL("http://www.example.com");
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");

            int responseCode = conn.getResponseCode();
            System.out.println("Response Code: " + responseCode);

            BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            String inputLine;
            StringBuffer response = new StringBuffer();
            while ((inputLine = in.readLine()) != null) {
                response.append(inputLine);
            }
            in.close();

            System.out.println("Response Body: " + response.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

HTTP 服务器：

import java.io.*;
import java.net.*;

public class HttpServerExample {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8080);
            System.out.println("HTTP Server started on port 8080...");

            while (true) {
                Socket clientSocket = serverSocket.accept();
                System.out.println("Client connected: " + clientSocket.getInetAddress().getHostName());

                BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);

                String inputLine;
                while ((inputLine = in.readLine()) != null) {
                    if (inputLine.isEmpty()) {
                        break;
                    }
                    System.out.println("Request: " + inputLine);
                }

                String response = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\nHello, World!";
                out.println(response);

                clientSocket.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

注意事项：

• 在实现 HTTP 客户端时，需要使用 HttpURLConnection 类来建立 HTTP 连接，并设置请求方法（如 GET、POST）和请求头部信息。

• 在实现 HTTP 服务器时，需要使用 ServerSocket 类来监听指定端口，并接受客户端连接请求，然后通过输入输出流来读取请求信息和发送响应信息。

• 实际开发中，可以使用现成的 HTTP 客户端和服务器框架（如 Apache HttpClient、Spring Boot 等），它们提供了更加方便和强大的功能来处理 HTTP 请求和响应。

图形用户界面（GUI）：

AWT（Abstract Window Toolkit）

AWT（Abstract Window Toolkit）是 Java 中用于创建图形用户界面（GUI）的原生界面工具包。它提供了一组组件（如窗口、按钮、文本框等）和布局管理器（如 BorderLayout、FlowLayout 等），可以用于构建交互式的图形用户界面应用程序。

AWT 组件：

AWT 提供了一系列组件类来构建图形用户界面，常见的组件包括：

• Frame：窗口，用于容纳其他组件的顶层容器。

• Panel：面板，用于容纳其他组件。

• Button：按钮，用于触发动作事件。

• Label：标签，用于显示文本或图像。

• TextField：文本框，用于接收用户输入的文本。

• TextArea：文本域，用于显示多行文本。

• Checkbox：复选框，用于选择或取消选择一个或多个选项。

• RadioButton：单选按钮，用于在一组选项中选择一个。

AWT 布局管理器：

AWT 提供了一些布局管理器来帮助开发者实现图形用户界面的布局，常见的布局管理器包括：

• FlowLayout：流式布局，组件按照添加的顺序从左到右依次排列，一行排满后换行。

• BorderLayout：边界布局，组件分为北、南、东、西、中五个区域进行布局。

• GridLayout：网格布局，组件按照指定的行数和列数进行网格布局。

• GridBagLayout：网格包布局，提供了更灵活的网格布局方式。

示例：

import java.awt.*;

public class AwtExample {
    public static void main(String[] args) {
        Frame frame = new Frame("AWT Example");
        frame.setLayout(new FlowLayout());
        
        Label label = new Label("Hello, AWT!");
        Button button = new Button("Click Me");
        
        frame.add(label);
        frame.add(button);
        
        frame.setSize(300, 200);
        frame.setVisible(true);
    }
}

注意事项：

• AWT 是 Java 最早的 GUI 工具包，但它的组件和布局管理器相对简单，功能有限，不支持透明窗口、轻量级组件等现代 GUI 开发的特性。

• 在实际开发中，通常使用 Swing 或 JavaFX 等更为强大和灵活的 GUI 工具包来构建图形用户界面应用程序。

Swing

Swing 是 Java 中用于构建图形用户界面（GUI）的组件库，它提供了丰富的组件和功能，能够创建具有吸引力和交互性的用户界面应用程序。与 AWT 不同，Swing 组件是轻量级的，不依赖于底层操作系统的 GUI 组件，因此在跨平台性和可定制性方面具有更大的优势。

Swing 组件：

Swing 提供了大量的组件类，可以用于构建各种类型的 GUI 应用程序，常见的组件包括：

• JFrame：顶层窗口，用于容纳其他组件。

• JPanel：面板，用于容纳其他组件。

• JButton：按钮，用于触发动作事件。

• JLabel：标签，用于显示文本或图像。

• JTextField：文本框，用于接收用户输入的文本。

• JTextArea：文本域，用于显示多行文本。

• JCheckBox：复选框，用于选择或取消选择一个或多个选项。

• JRadioButton：单选按钮，用于在一组选项中选择一个。

• JComboBox：下拉框，用于选择一个选项。

• JList：列表，用于显示一个列表。

• JTable：表格，用于显示二维表格数据。

Swing 布局管理器：

Swing 提供了一系列布局管理器来帮助开发者实现 GUI 的布局，常见的布局管理器包括：

• FlowLayout：流式布局，组件按照添加的顺序从左到右依次排列，一行排满后换行。

• BorderLayout：边界布局，组件分为北、南、东、西、中五个区域进行布局。

• GridLayout：网格布局，组件按照指定的行数和列数进行网格布局。

• GridBagLayout：网格包布局，提供了更灵活的网格布局方式。

• BoxLayout：盒子布局，组件沿水平或垂直方向排列。

示例：

import javax.swing.*;

public class SwingExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Swing Example");
        JPanel panel = new JPanel();
        
        JLabel label = new JLabel("Hello, Swing!");
        JButton button = new JButton("Click Me");
        
        panel.add(label);
        panel.add(button);
        
        frame.add(panel);
        
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

注意事项：

• Swing 组件和布局管理器提供了丰富的功能和灵活的布局方式，能够满足各种类型的 GUI 应用程序的开发需求。

• Swing 应用程序通常运行在 Java 虚拟机上，可以跨平台运行，具有良好的跨平台性。

• 虽然 JavaFX 已经成为 Java 官方推荐的 GUI 工具包，但 Swing 仍然被广泛应用于许多项目中，因为它简单易学，且具有丰富的第三方库支持。

数据持久化：

JDBC（Java Database Connectivity）

JDBC（Java Database Connectivity）是 Java 提供的用于访问和操作数据库的 API，它允许 Java 应用程序与各种数据库进行通信，执行 SQL 查询、更新数据等操作。JDBC 提供了一种统一的接口，使得 Java 开发者可以使用相同的代码来访问不同类型的数据库，实现了数据库访问的平台无关性。

JDBC 架构：

JDBC 架构主要由以下几个组件组成：

1. JDBC API：定义了一系列的接口和类，用于执行 SQL 操作、连接数据库、处理结果集等。

2. JDBC 驱动程序管理器：负责管理 JDBC 驱动程序，加载和注册驱动程序。

3. JDBC 驱动程序：不同的数据库厂商提供了不同的 JDBC 驱动程序，用于实现与特定数据库的通信。

4. JDBC 连接池：用于管理数据库连接，提高数据库访问的效率和性能。

JDBC 连接流程：

1. 加载驱动程序：通过 Class.forName("com.mysql.cj.jdbc.Driver") 加载数据库驱动程序。

2. 创建连接：使用 DriverManager.getConnection(url, username, password) 方法创建数据库连接。

3. 创建 Statement 对象：使用连接对象的 createStatement() 方法创建 Statement 对象，用于执行 SQL 语句。

4. 执行 SQL 查询：使用 Statement 对象的 executeQuery(sql) 方法执行 SQL 查询操作。

5. 处理结果集：使用 ResultSet 对象处理查询结果。

6. 释放资源：在使用完连接、Statement 和 ResultSet 后，需要手动关闭这些资源，以释放数据库连接和其他资源。

示例：

import java.sql.*;

public class JdbcExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydatabase";
        String username = "username";
        String password = "password";

        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            Connection connection = DriverManager.getConnection(url, username, password);

            Statement statement = connection.createStatement();
            ResultSet resultSet = statement.executeQuery("SELECT * FROM users");

            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                String email = resultSet.getString("email");
                System.out.println("ID: " + id + ", Name: " + name + ", Email: " + email);
            }

            resultSet.close();
            statement.close();
            connection.close();
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }
    }
}

JDBC 连接池：

JDBC 连接池是一种用于管理数据库连接的技术，它可以提高数据库访问的效率和性能，减少连接创建和销毁的开销，避免了频繁地创建和关闭数据库连接。

常见的 JDBC 连接池包括 Apache Commons DBCP、C3P0、HikariCP 等。使用连接池时，需要配置连接池的参数，如最大连接数、最小连接数、连接超时时间等，以及在使用完连接后释放连接资源。

JDBC 是 Java 中与数据库交互的重要工具，它提供了一种简单、灵活的方式来执行 SQL 查询和更新操作，帮助开发者构建稳健、高效的数据库应用程序。

文件操作

文件操作是在计算机中对文件进行创建、读取、写入、删除等操作的过程。在 Java 中，可以使用 java.io 包和 java.nio 包中的类来进行文件操作。

文件创建与删除：

import java.io.File;
import java.io.IOException;

public class FileExample {
    public static void main(String[] args) {
        // 创建文件对象
        File file = new File("example.txt");

        try {
            // 创建新文件
            if (file.createNewFile()) {
                System.out.println("File created: " + file.getName());
            } else {
                System.out.println("File already exists.");
            }

            // 删除文件
            if (file.delete()) {
                System.out.println("File deleted: " + file.getName());
            } else {
                System.out.println("Failed to delete the file.");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文件读取与写入：

import java.io.File;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.IOException;

public class FileReadWriteExample {
    public static void main(String[] args) {
        File file = new File("example.txt");

        try {
            // 写入文件
            FileWriter writer = new FileWriter(file);
            writer.write("Hello, world!");
            writer.close();

            // 读取文件
            FileReader reader = new FileReader(file);
            int character;
            StringBuilder content = new StringBuilder();
            while ((character = reader.read()) != -1) {
                content.append((char) character);
            }
            reader.close();

            System.out.println("File content: " + content.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文件夹操作：

import java.io.File;

public class DirectoryExample {
    public static void main(String[] args) {
        File directory = new File("example_dir");

        // 创建文件夹
        if (directory.mkdir()) {
            System.out.println("Directory created: " + directory.getName());
        } else {
            System.out.println("Failed to create the directory.");
        }

        // 删除文件夹
        if (directory.delete()) {
            System.out.println("Directory deleted: " + directory.getName());
        } else {
            System.out.println("Failed to delete the directory.");
        }
    }
}

注意事项：

• 在进行文件操作时，需要处理可能出现的 IOException 异常。

• 使用 FileReader 和 FileWriter 进行文件读写操作时，需要逐字符或逐行读写，并注意关闭文件流。

• 文件和文件夹的创建和删除操作可能涉及文件权限和文件存在性检查，需要根据实际情况进行处理。

文件操作是 Java 编程中常见的任务之一，掌握文件操作的基本方法和技巧，能够实现对文件的读取、写入、创建和删除等操作，为开发各种类型的应用程序提供了基础支持。

Java虚拟机（JVM）：

类加载机制

类加载机制是 Java 虚拟机（JVM）在运行时加载类文件（*.class）到内存中并对其进行解析、验证、初始化等操作的过程。类加载机制是 Java 程序执行的基础，它负责将编译后的 Java 字节码加载到 JVM 中，并为 Java 程序提供运行时环境。

类加载过程：

类加载过程通常分为加载、验证、准备、解析和初始化五个阶段：

1. 加载（Loading）：类加载器加载类字节码文件到内存中，并创建一个对应的 Class 对象，表示这个类在 JVM 中的数据结构。

2. 验证（Verification）：验证阶段确保类文件的字节流符合 JVM 规范，例如检查文件格式是否正确、语义是否合法等。

3. 准备（Preparation）：准备阶段为类的静态变量分配内存空间，并设置默认初始值。

4. 解析（Resolution）：解析阶段将符号引用（类名、方法名、字段名等符号）转换为直接引用（内存地址或偏移量），以便在运行时能够直接定位到目标。

5. 初始化（Initialization）：初始化阶段对类的静态变量进行初始化赋值，并执行静态代码块（static块）中的代码。

类加载器：

Java 中的类加载器负责将类文件加载到 JVM 中，Java 类加载器主要有以下几种类型：

• 启动类加载器（Bootstrap ClassLoader）：负责加载 Java 核心类库（如java.lang包下的类），是 JVM 内置的类加载器。

• 扩展类加载器（Extension ClassLoader）：负责加载 JVM 扩展类库（如jre\lib\ext目录下的类），是由Java编写的类加载器，是纯Java代码。

• 应用程序类加载器（Application ClassLoader）：也称为系统类加载器，负责加载应用程序的类路径下的类文件。

• 自定义类加载器：开发者可以根据需求自定义类加载器，例如实现热部署、动态加载等功能。

双亲委派模型：

Java 类加载器采用双亲委派模型来加载类文件，即每个类加载器在加载类时首先将加载请求委托给父类加载器，只有在父类加载器无法加载该类时才由子类加载器自行加载。这种模型可以保证类的加载过程是由上至下的，避免了类的重复加载和安全问题。

类加载时机：

Java 类的加载时机主要包括：

• 首次使用时加载：当程序中首次引用某个类时，该类将被加载到内存中并进行初始化。

• 显式加载：通过 Class.forName() 方法显式加载指定的类。

• 动态加载：通过自定义类加载器动态加载类文件。

类加载机制是 Java 虚拟机的核心功能之一，它保证了 Java 程序的运行环境和安全性，了解类加载机制有助于开发者理解 Java 程序的执行过程和解决类加载相关的问题。

内存管理

内存管理是指在程序运行过程中，对内存的分配、使用和释放进行有效管理的过程。在 Java 中，内存管理主要涉及堆内存和栈内存的管理，以及垃圾回收机制。

堆内存管理：

Java 堆内存用于存储对象实例，所有通过 new 关键字创建的对象都存储在堆内存中。堆内存的管理由 Java 虚拟机负责，它主要包括内存分配、垃圾回收等操作。堆内存的特点包括：

• 自动内存管理：Java 虚拟机负责自动分配和回收堆内存，开发者不需要手动管理。

• 动态分配：堆内存的大小在程序运行时可以动态调整，根据程序运行的需要进行分配。

• 对象生命周期管理：堆内存中的对象的生命周期由 Java 虚拟机管理，对象在不再被引用时将被垃圾回收。

栈内存管理：

Java 栈内存用于存储方法调用的信息、局部变量和部分对象引用。栈内存的管理由 JVM 负责，它会为每个线程分配一个栈帧（Stack Frame），用于存储方法调用的信息。栈内存的特点包括：

• 方法调用管理：栈内存保存方法调用的信息，包括方法的参数、局部变量和方法返回值等。

• 后进先出：栈内存采用后进先出（LIFO）的数据结构，方法的调用顺序与调用栈的压栈和弹栈顺序相对应。

• 生命周期短暂：栈内存中保存的数据具有较短的生命周期，方法执行结束后栈帧会被弹出并释放内存。

垃圾回收

垃圾回收是指在程序运行过程中，自动回收不再使用的内存资源的过程。在 Java 中，垃圾回收是由 Java 虚拟机（JVM）自动管理的，它负责在堆内存中回收不再使用的对象，释放其占用的内存空间，以避免内存泄漏和内存溢出等问题。

垃圾回收的原理：

Java 垃圾回收的主要原理是可达性分析（Reachability Analysis），它根据对象的引用关系来判断对象是否可达，从而决定是否对其进行回收。可达性分析算法主要有以下几个步骤：

1. 标记阶段（Marking Phase）：从根对象（如虚拟机栈、本地方法栈、方法区中的静态变量）开始，递归地标记所有与根对象直接或间接相连的对象为可达对象。

2. 清除阶段（Sweeping Phase）：遍历堆内存中的所有对象，对未被标记为可达对象的对象进行回收，并释放其占用的内存空间。

3. 压缩阶段（Compact Phase）（可选）：对堆内存中的对象进行整理，使得内存空间连续，减少内存碎片化的问题。

垃圾回收的触发条件：

Java 垃圾回收通常在以下情况下触发：

• 内存空间不足：当堆内存空间快要用尽时，触发垃圾回收以释放内存空间。

• 系统空闲时间：在系统空闲时间进行垃圾回收，避免影响程序的正常运行。

垃圾回收器：

Java 虚拟机实现了不同的垃圾回收算法和垃圾回收器，常见的垃圾回收器包括：

• Serial GC：串行垃圾回收器，采用单线程进行垃圾回收，适用于单核处理器或小型应用。

• Parallel GC：并行垃圾回收器，采用多线程并行进行垃圾回收，提高垃圾回收效率，适用于多核处理器或大型应用。

• CMS GC：CMS（Concurrent Mark-Sweep）垃圾回收器，采用并发标记和并发清除算法，尽量减少垃圾回收造成的停顿时间。

• G1 GC：G1（Garbage-First）垃圾回收器，采用分代回收和区域化垃圾回收策略，适用于大内存和低停顿时间的应用。

垃圾回收的影响：

• 停顿时间：垃圾回收过程中，会导致程序的停顿，影响程序的响应性能。

• 吞吐量：垃圾回收的频率和效率会影响程序的吞吐量，即单位时间内处理的请求数量。

• 内存占用：垃圾回收会释放不再使用的内存空间，减少内存占用。

垃圾回收是 Java 内存管理的重要组成部分，它可以自动释放不再使用的内存资源，提高程序的运行效率和稳定性。开发者需要了解不同垃圾回收算法和回收器的特点，根据应用场景选择合适的垃圾回收策略，以实现更高效的内存管理。