全面Java学习资料合集

本文还有配套的精品资源，点击获取

简介：本资料合集提供了从基础到企业级应用开发的Java学习资源，包括Java基础教程、数据库管理、图形用户界面开发、多线程编程等。涵盖了Java SE的核心概念、Java Web开发技术如JSP和Spring框架，以及用于数据库交互的框架如Hibernate。此外，还包括了C++基础知识、企业级JavaBean（EJB）、面试准备等，旨在帮助开发者全面掌握Java编程，并了解相关技术。

1. Java基础教程

1.1 Java语言概述

Java是一种高级的、面向对象的、跨平台的编程语言，它由Sun Microsystems公司（现为Oracle Corporation的一部分）于1995年发布。Java的设计理念是编写一次代码，到处运行（Write Once, Run Anywhere），这得益于其独特的“Java虚拟机”（JVM）架构，使得Java程序能够在不同的操作系统和硬件平台上运行而无需修改。

1.2 Java的开发环境搭建

要开始Java开发之旅，首先需要搭建一个合适的开发环境。这通常包括安装Java开发工具包（JDK）和集成开发环境（IDE），如Eclipse、IntelliJ IDEA或NetBeans。安装JDK后，配置环境变量 JAVA_HOME 指向JDK的安装目录，并将JDK的 bin 目录添加到系统路径 PATH 中，以便在命令行中使用 java 和 javac 命令。

# 示例：在Windows系统中设置环境变量JAVA_HOME
JAVA_HOME="C:\Program Files\Java\jdk-11.0.6"
PATH="%PATH%;%JAVA_HOME%\bin"

通过上述步骤，你可以确保Java运行时和编译时环境正确配置，为接下来的学习和开发打下坚实的基础。

1.3 Hello World：你的第一个Java程序

任何一个编程语言的学习，都是从编写“Hello World”程序开始的。Java也不例外。创建一个名为 HelloWorld.java 的文件，并输入以下代码：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

在命令行中使用 javac HelloWorld.java 编译代码，然后使用 java HelloWorld 运行编译后的类文件。如果一切顺利，你将在命令行窗口看到输出"Hello, World!"，这标志着你已经成功地完成了Java开发环境的搭建和第一个Java程序的编写。

2. 数据库管理

2.1 数据库的基本概念

2.1.1 数据库的定义和作用

数据库是存储、管理、处理和检索数据的系统。它允许用户和程序通过结构化的方式存储大量信息，并提供快速、可靠的数据访问。数据库的主要目的是确保数据的持久性、一致性和高效性。

数据库的重要性

数据库系统是现代IT基础设施的核心组成部分。它们广泛应用于从简单的个人博客到复杂的电子商务平台、银行系统和社交网络。数据库提供了数据组织、备份和恢复、并发控制以及安全性等功能，这些都是现代应用不可或缺的特性。

数据库的类型

数据库可以分为关系型数据库和非关系型数据库。关系型数据库使用表格形式组织数据，强调数据之间的关系，如MySQL和Oracle。非关系型数据库则更加灵活，适用于处理大量的分布式数据，如MongoDB和Redis。

2.2 SQL语言详解

2.2.1 数据定义语言DDL

数据定义语言DDL用于创建、修改和删除数据库结构。DDL主要包括以下几个方面的命令：

• CREATE ：用于创建新表、数据库或其他数据库对象。
• ALTER ：用于修改现有数据库结构。
• DROP ：用于删除整个表、数据库或数据库对象。

创建和修改表

-- 创建新表
CREATE TABLE IF NOT EXISTS Employees (
    id INT PRIMARY KEY,
    name VARCHAR(100),
    department VARCHAR(100),
    salary DECIMAL(10, 2)
);

-- 修改现有表结构，添加新列
ALTER TABLE Employees ADD COLUMN age INT;

2.2.2 数据操作语言DML

数据操作语言DML用于对数据库中存储的数据进行增删改查操作。主要的DML命令包括：

• INSERT ：用于向表中插入新的数据行。
• UPDATE ：用于更新表中的现有数据。
• DELETE ：用于删除表中的数据行。

插入、更新和删除数据

-- 向Employees表中插入新数据
INSERT INTO Employees (id, name, department, salary) VALUES (1, 'Alice', 'IT', 7000.00);

-- 更新Employees表中的数据
UPDATE Employees SET salary = 7500.00 WHERE id = 1;

-- 删除Employees表中的数据
DELETE FROM Employees WHERE id = 1;

2.2.3 数据控制语言DCL

数据控制语言DCL用于控制数据库对象的访问权限。主要的DCL命令包括：

• GRANT ：用于授权用户或角色对数据库对象的访问权限。
• REVOKE ：用于撤销已授予的权限。

授权和撤销权限

-- 授予用户SELECT权限
GRANT SELECT ON Employees TO user1;

-- 撤销用户的SELECT权限
REVOKE SELECT ON Employees FROM user1;

2.3 Java与数据库的交互

2.3.1 JDBC驱动的安装和配置

Java数据库连接（JDBC）是一种Java API，用于连接和执行查询数据库。要使用JDBC，首先需要安装相应的JDBC驱动，并在Java项目中进行配置。

安装JDBC驱动

通常，JDBC驱动可以从数据库提供者的官方网站下载。例如，要连接MySQL数据库，可以从[MySQL官网](***下载JDBC驱动。

配置JDBC驱动

在Java项目中，需要将JDBC驱动的jar包添加到项目的类路径中。这样，Java程序就可以加载并使用这个驱动了。

2.3.2 使用JDBC进行数据库操作

使用JDBC进行数据库操作通常涉及以下步骤：

1. 加载并注册JDBC驱动。
2. 建立数据库连接。
3. 创建 Statement 或 PreparedStatement 对象执行SQL语句。
4. 处理查询结果。
5. 关闭连接和释放资源。

加载和注册JDBC驱动

// 加载并注册MySQL JDBC驱动
Class.forName("com.mysql.cj.jdbc.Driver");

建立数据库连接

// 建立数据库连接
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/databaseName", "username", "password");

执行SQL语句

// 创建Statement对象
Statement stmt = conn.createStatement();

// 执行SQL查询
ResultSet rs = stmt.executeQuery("SELECT * FROM Employees");

// 处理查询结果
while (rs.next()) {
    int id = rs.getInt("id");
    String name = rs.getString("name");
    // ...
}

关闭连接和释放资源

// 关闭资源
rs.close();
stmt.close();
conn.close();

2.3.3 高级JDBC特性

JDBC API提供了许多高级特性，如事务处理、批处理和连接池。这些特性可以帮助开发者构建更加健壮和高效的数据库应用程序。

事务处理

事务处理确保了数据库操作的原子性、一致性、隔离性和持久性（ACID属性）。在JDBC中，可以通过 Connection 对象的 setAutoCommit(false) 和 commit() 方法来控制事务。

// 开启事务
conn.setAutoCommit(false);

// 执行SQL操作
// ...

// 提交事务
***mit();

// 回滚事务
conn.rollback();

批处理

批处理允许将多个SQL语句组合在一起执行，这样可以显著提高性能。

// 创建PreparedStatement
PreparedStatement pstmt = conn.prepareStatement("INSERT INTO Employees (name, department, salary) VALUES (?, ?, ?)");

// 添加参数并添加到批处理
pstmt.setString(1, "Bob");
pstmt.setString(2, "HR");
pstmt.setBigDecimal(3, new BigDecimal("5000.00"));
pstmt.addBatch();

// 执行批处理
pstmt.executeBatch();

连接池

连接池是一种管理数据库连接的技术，它维护一组数据库连接，避免频繁地打开和关闭连接，从而提高性能。

// 使用连接池
DataSource ds = new PooledConnection();
Connection conn = ds.getConnection();

// 使用连接进行数据库操作

// 关闭连接
conn.close();

在本章节中，我们介绍了数据库管理的基础知识，包括数据库的基本概念、SQL语言的详细解释以及Java与数据库的交互方法。通过本章节的介绍，读者应该能够理解数据库的核心概念，掌握SQL的基本操作，并能够在Java程序中使用JDBC API进行数据库操作。

3. 图形用户界面开发

3.1 Java图形用户界面基础

3.1.1 AWT和Swing组件概述

Java图形用户界面（GUI）开发经历了从AWT（Abstract Window Toolkit）到Swing的演变。AWT是Java最早的GUI工具包，它使用了本地平台的用户界面元素，这意味着你的应用程序的外观和感觉与操作系统的默认样式一致。然而，这种方式有一个主要的缺点：不同平台上的应用程序外观不一致。为了解决这个问题，Java引入了Swing工具包，它提供了一套完全用Java编写的GUI组件，可以实现跨平台的一致性。

在本章节中，我们将深入探讨AWT和Swing的基本组件，以及它们如何被用来创建现代的桌面应用程序。

AWT和Swing的基本概念

AWT和Swing都是基于事件驱动编程模型的GUI工具包。事件驱动编程是一种程序设计范式，在这种范式中，程序的流程是由事件的发生来控制的。在GUI中，这些事件通常是由用户交互触发的，如点击按钮或按键输入。

AWT组件的局限性

AWT组件受到底层操作系统的限制，这意味着它不能提供比操作系统本身更丰富的界面元素。例如，在Windows系统上，AWT创建的按钮和标签看起来和Windows应用程序的按钮和标签一样，而在Mac系统上则会呈现Mac风格。

Swing组件的跨平台特性

Swing组件不受平台限制，它为开发者提供了更多的自定义选项。Swing组件是轻量级的，它们在Java虚拟机中运行，而不是依赖于本地操作系统的窗口系统。这使得开发者可以创建出外观一致的应用程序，无论用户使用什么操作系统。

AWT和Swing的组件层次

AWT和Swing都遵循了层次化的组件模型。这个模型包括容器组件和轻量级组件。容器组件可以包含其他组件，而轻量级组件则直接参与用户交互。例如， JFrame 是一个容器组件，可以包含其他如 JButton 和 JTextField 的轻量级组件。

3.1.2 常用GUI组件的应用

基本Swing组件的应用

在本章节介绍的Swing组件中，我们将看到如何创建基本的用户界面元素，如按钮、文本框和标签。我们将使用 JButton 、 JTextField 和 JLabel 等类来演示这些基本组件的使用方法。

import javax.swing.*;

public class SimpleGUIApp {
    public static void main(String[] args) {
        // 创建 JFrame 实例
        JFrame frame = new JFrame("Simple GUI Application");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(300, 200);

        // 创建一个按钮组件
        JButton button = new JButton("Click Me");
        button.addActionListener(e -> {
            JOptionPane.showMessageDialog(frame, "Button Clicked!");
        });

        // 创建一个文本框组件
        JTextField textField = new JTextField(10);

        // 创建一个标签组件
        JLabel label = new JLabel("Enter Text:");

        // 将组件添加到 JFrame
        frame.setLayout(new BoxLayout(frame.getContentPane(), BoxLayout.Y_AXIS));
        frame.add(label);
        frame.add(textField);
        frame.add(button);

        // 显示窗口
        frame.setVisible(true);
    }
}

组件布局管理器

Swing使用布局管理器来控制组件的大小和位置。在上面的代码示例中，我们使用了 BoxLayout 布局管理器。Swing提供了多种布局管理器，如 FlowLayout 、 BorderLayout 和 GridBagLayout ，每种布局管理器都有其特定的用途和布局特性。

事件监听器的使用

Swing组件通常与事件监听器配合使用，以响应用户交互。在上面的代码中，我们为按钮添加了一个 ActionListener 来处理按钮点击事件。Swing支持多种类型的事件监听器，包括鼠标事件、键盘事件和焦点事件。

本章节介绍

通过本章节的介绍，我们了解了Java图形用户界面开发的基础知识，包括AWT和Swing组件的概述，以及如何使用这些组件创建基本的GUI应用程序。在接下来的章节中，我们将深入探讨JavaFX，它是Java最新的图形用户界面框架，提供了更强大的功能和更现代化的外观。

3.2 JavaFX入门

3.2.1 JavaFX的特点和优势

JavaFX概述

JavaFX是Java的一个富客户端平台，用于构建丰富的互联网应用程序（RIA）。与AWT和Swing相比，JavaFX提供了更加现代化和丰富的用户界面组件，以及更好的2D和3D图形支持。JavaFX是为了解决Swing的一些局限性而设计的，例如更好的图形渲染和动画支持。

JavaFX的优势

JavaFX的主要优势包括：

• 现代化的UI组件 ：JavaFX拥有更加现代化和自定义的UI组件，如图表、滑动条和日期选择器等。
• CSS支持 ：JavaFX支持CSS，使得开发者可以更容易地自定义应用程序的外观。
• 动画和图形 ：JavaFX提供了强大的动画和图形API，可以轻松创建复杂的动画效果和2D/3D图形。
• 场景图 ：JavaFX使用场景图来管理UI元素，这使得布局和渲染更加高效。

JavaFX的基本组件和布局

JavaFX中的UI组件被称为节点（Node），它们被组织在场景图中。布局管理器在JavaFX中被称为布局面板（Layout Pane），它负责管理子节点的位置和大小。

3.2.2 JavaFX的基本组件和布局

常用JavaFX组件

JavaFX提供了许多现成的组件，如按钮（Button）、文本框（TextField）、标签（Label）、列表视图（ListView）等。这些组件被用于构建用户界面。

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.StackPane;
import javafx.stage.Stage;

public class SimpleJavaFXApp extends Application {
    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(Stage primaryStage) {
        // 创建一个按钮
        Button btn = new Button();
        btn.setText("Say 'Hello World'");

        // 创建根节点
        StackPane root = new StackPane();
        root.getChildren().add(btn);

        // 创建场景
        Scene scene = new Scene(root, 300, 250);

        // 设置舞台
        primaryStage.setTitle("Hello World JavaFX");
        primaryStage.setScene(scene);
        primaryStage.show();
    }
}

JavaFX布局管理器

JavaFX提供了多种布局管理器，如 StackPane 、 HBox 、 VBox 、 GridPane 和 FlowPane 。这些布局管理器用于控制组件的位置和大小。

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class LayoutExample extends Application {
    public static void main(String[] args) {
        launch(args);
    }

    @Override
    public void start(Stage primaryStage) {
        Button btn1 = new Button("Button 1");
        Button btn2 = new Button("Button 2");
        Button btn3 = new Button("Button 3");

        // 使用 HBox 布局
        HBox hbox = new HBox(10); // 间隔为10像素
        hbox.getChildren().addAll(btn1, btn2, btn3);

        // 使用 VBox 布局
        VBox vbox = new VBox(10); // 间隔为10像素
        vbox.getChildren().addAll(btn1, btn2, btn3);

        // 创建根节点
        StackPane root = new StackPane();
        root.getChildren().addAll(hbox, vbox);

        // 创建场景
        Scene scene = new Scene(root, 300, 250);

        // 设置舞台
        primaryStage.setTitle("JavaFX Layout Example");
        primaryStage.setScene(scene);
        primaryStage.show();
    }
}

本章节介绍

通过本章节的介绍，我们了解了JavaFX的基本概念、优势、常用组件和布局管理器。JavaFX为Java开发者提供了一个强大的工具集，用于创建现代化和交互式的桌面应用程序。在接下来的章节中，我们将探讨如何将JavaFX用于实际的实践应用，包括开发简单的桌面应用程序和实现事件处理和动画效果。

4. 多线程编程

多线程编程是Java高级编程中的一个重要组成部分，它允许程序同时执行多个任务，从而提高应用程序的性能和响应速度。在本章节中，我们将深入探讨多线程编程的基础知识，同步机制，以及线程池和并发框架的高级应用。

4.1 多线程基础

4.1.1 线程的概念和生命周期

在Java中，线程是程序执行流的最小单元。一个标准的Java程序运行时至少有一个线程，即主线程。线程的生命周期包括新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Terminated）五个状态。

线程的状态转换图如下所示：

graph LR
    A[新建(New)] --> B[就绪(Runnable)]
    B --> C{是否获得CPU时间}
    C -->|是| D[运行(Running)]
    C -->|否| B
    D -->|时间片用完或被阻塞| B
    D -->|执行完毕| E[死亡(Terminated)]
    D -->|遇到阻塞操作| F[阻塞(Blocked)]
    F -->|阻塞操作完成| B

代码示例：

public class ThreadLifeCycleDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("Thread is running.");
        });

        thread.start(); // 启动线程
        try {
            Thread.sleep(1000); // 稍作等待，以便观察输出
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Thread state: " + thread.getState());
    }
}

逻辑分析：

上述代码创建了一个新的线程，并在主线程中打印出该线程的状态。通过启动线程，我们可以观察到线程的状态变化。

4.1.2 创建和管理线程的方法

在Java中，创建线程主要有两种方式：继承Thread类或实现Runnable接口。此外，还可以使用Callable和Future来处理有返回值的线程。

代码示例：

// 继承Thread类
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread created by extending Thread class.");
    }
}

// 实现Runnable接口
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Thread created by implementing Runnable interface.");
    }
}

// 使用Callable和Future
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(() -> "Result from Callable");
System.out.println(future.get()); // 输出Callable的结果
executor.shutdown();

逻辑分析：

第一种方式通过继承Thread类来创建线程，这种方式简单直观，但它不支持继承其他类，限制了Java的单继承特性。第二种方式通过实现Runnable接口来创建线程，这种方式更加灵活，可以继承其他类。第三种方式是Java 5之后引入的，支持线程执行完成后返回结果。

4.2 同步机制

4.2.1 同步代码块和同步方法

同步机制是解决多线程并发访问共享资源时可能产生数据不一致问题的重要手段。Java提供了synchronized关键字来实现同步。

代码示例：

public class SynchronizedExample {
    private int counter = 0;

    public void increment() {
        synchronized (this) {
            counter++;
            System.out.println(Thread.currentThread().getName() + ": " + counter);
        }
    }
}

逻辑分析：

在上述代码中，increment方法被synchronized关键字修饰，这意味着每次只有一个线程可以执行这个方法，从而保证了对共享资源counter的访问是线程安全的。

4.2.2 锁机制和并发工具类

除了synchronized关键字，Java并发包中还提供了丰富的并发工具类，如ReentrantLock、Semaphore、CountDownLatch等，它们提供了比synchronized更灵活的锁机制。

代码示例：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            counter++;
            System.out.println(Thread.currentThread().getName() + ": " + counter);
        } finally {
            lock.unlock();
        }
    }
}

逻辑分析：

在这个例子中，我们使用ReentrantLock来替代synchronized关键字。ReentrantLock提供了更多的功能，例如尝试非阻塞获取锁、可中断的锁获取等。

4.3 线程池和并发框架

4.3.1 线程池的创建和使用

线程池是一种线程管理机制，它可以有效减少在创建和销毁线程上所消耗的时间和资源。Java中的线程池是通过Executor框架来实现的。

代码示例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2); // 创建固定大小的线程池

        for (int i = 0; i < 5; i++) {
            executor.submit(() -> System.out.println("Thread pool example: " + Thread.currentThread().getName()));
        }

        executor.shutdown();
    }
}

逻辑分析：

上述代码创建了一个固定大小为2的线程池，并提交了5个任务。由于线程池大小的限制，这些任务将在两个线程中轮换执行。

4.3.2 Fork/Join框架介绍

Fork/Join框架是Java 7引入的一种高效的执行并发任务的框架，特别适用于可以将一个大任务拆分成多个小任务的场景。

代码示例：

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;

public class ForkJoinExample extends RecursiveTask<Integer> {
    private final int threshold = 10;
    private int start;
    private int end;

    public ForkJoinExample(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        if (end - start <= threshold) {
            int sum = 0;
            for (int i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        } else {
            ForkJoinExample subTask1 = new ForkJoinExample(start, (start + end) / 2);
            ForkJoinExample subTask2 = new ForkJoinExample((start + end) / 2 + 1, end);
            subTask1.fork(); // 异步执行子任务
            subTask2.fork();
            return subTask1.join() + subTask2.join(); // 等待子任务完成并合并结果
        }
    }

    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinExample task = new ForkJoinExample(1, 100);
        Integer result = pool.invoke(task);
        System.out.println("Result: " + result);
    }
}

逻辑分析：

在这个例子中，我们创建了一个ForkJoinExample类，它可以递归地将大任务分解为多个小任务，并在ForkJoinPool中执行。这种方式可以充分利用多核处理器的计算能力，提高程序的执行效率。

通过本章节的介绍，我们了解了多线程编程的基础知识，包括线程的概念、生命周期、创建和管理方法，以及同步机制和线程池的高级应用。这些知识对于编写高性能的并发应用程序至关重要。在下一章节中，我们将继续深入探讨Java SE的核心概念，包括集合框架、泛型、注解以及Java的新特性。

5. Java SE核心概念

5.1 Java集合框架

5.1.1 集合框架概述

Java集合框架提供了一套性能优化、设计良好的接口和类，用于表示和操作对象集合。在Java中，集合类可以存储数量不确定的多个对象，并提供了丰富的方法来访问这些对象。集合框架的主要目的有两个：一是降低编程的复杂性，二是提高性能。通过使用集合框架，可以更方便地实现数据结构，如链表、栈、队列和散列表等。

集合框架的主要组件包括：

• 接口 ：定义集合的行为，如 Collection 、 List 、 Set 、 Queue 和 Map 。
• 实现类 ：具体实现接口的类，如 ArrayList 、 LinkedList 、 HashSet 、 TreeSet 、 HashMap 和 TreeMap 等。
• 算法 ：在集合框架中，算法用于处理集合数据，如排序和搜索。

集合框架的设计考虑了时间效率和空间效率之间的平衡。例如， ArrayList 提供快速的随机访问，但增加和删除操作可能较慢，而 LinkedList 在插入和删除操作上更有效率，但随机访问较慢。

5.1.2 List、Set和Map接口的实现

List接口

List 接口代表有序集合，可以包含重复元素。它的主要实现类是 ArrayList 和 LinkedList 。

• ArrayList ：基于动态数组实现，允许在列表的任何位置快速插入和删除元素，但插入和删除操作可能需要移动大量元素。
• LinkedList ：基于双向链表实现，每个元素都包含一个前驱和后继引用，适合频繁的插入和删除操作，但在查找元素时效率较低。

Set接口

Set 接口代表无序集合，不允许包含重复元素。它的主要实现类是 HashSet 、 LinkedHashSet 和 TreeSet 。

• HashSet ：基于哈希表实现，提供了快速的插入和查找操作，元素的迭代顺序不确定。
• LinkedHashSet ：继承自 HashSet ，同时维护了一个双向链表来记录插入顺序。
• TreeSet ：基于红黑树实现，可以提供有序的集合，并且可以控制元素的排序。

Map接口

Map 接口代表键值对集合，每个键映射到一个值。它的主要实现类是 HashMap 、 LinkedHashMap 和 TreeMap 。

• HashMap ：基于哈希表实现，提供了快速的插入和查找操作，键的迭代顺序不确定。
• LinkedHashMap ：继承自 HashMap ，同时维护了一个双向链表来记录插入顺序，元素的迭代顺序与插入顺序一致。
• TreeMap ：基于红黑树实现，可以提供有序的键集合，并且可以控制键的排序。

示例代码

import java.util.*;

public class CollectionDemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list); // [1, 2, 3]

        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(2);
        set.add(3);
        System.out.println(set); // [1, 2, 3]

        Map<String, Integer> map = new HashMap<>();
        map.put("One", 1);
        map.put("Two", 2);
        map.put("Three", 3);
        System.out.println(map); // {One=1, Two=2, Three=3}
    }
}

通过本章节的介绍，我们了解了Java集合框架的基本概念和主要接口的实现类。在实际开发中，选择合适的集合类型可以极大地提高代码的效率和可读性。接下来，我们将深入探讨Java中的泛型和注解，这是Java SE核心概念中的重要组成部分。

6. Java Web开发技术

6.1 Java Web基础知识

6.1.1 Web应用的组成和运行原理

在深入探讨Java Web开发技术之前，我们需要了解Web应用的基本组成和运行原理。Web应用主要由前端（客户端）和后端（服务器端）组成。前端通常包括HTML、CSS和JavaScript等技术，负责展示和用户交互。后端则包括服务器、应用程序服务器和数据库等，负责处理业务逻辑和数据存储。

Web应用的运行原理涉及到客户端与服务器之间的交互。当用户在浏览器输入URL并请求访问某个Web页面时，浏览器会向服务器发送HTTP请求。服务器接收到请求后，会通过各种Web容器（如Tomcat、Jetty等）处理请求，并返回相应的HTML内容。浏览器接收到这些内容后，会解析并渲染页面，最终展示给用户。

6.1.2 Servlet和JSP基础

Servlet是Java EE的核心技术之一，它是一个运行在服务器端的Java应用程序，用于扩展服务器的功能。Servlet可以通过HTTP协议接收客户端请求，并生成响应数据。JSP（Java Server Pages）则是一种基于Java的模板技术，它允许开发者在HTML页面中嵌入Java代码，从而实现动态内容的生成。

在实际开发中，Servlet通常用于处理业务逻辑，而JSP则用于生成最终的HTML页面。例如，当用户提交表单数据时，表单数据会被发送到一个Servlet处理。Servlet处理完毕后，可以通过JSP生成动态的响应页面返回给用户。

以下是一个简单的Servlet示例代码，展示了如何处理用户的GET请求并返回响应：

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        out.println("<h1>Hello, Web!</h1>");
    }
}

在JSP中，可以使用以下代码嵌入Java代码：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Hello JSP</title>
</head>
<body>
    <h2>Hello, JSP!</h2>
    <% String name = request.getParameter("name");
       if (name != null) { %>
           <p>Welcome, <%= name %>!</p>
       <% } %>
</body>
</html>

在这个JSP示例中，如果客户端请求中包含了 name 参数，那么页面将展示欢迎信息。

请注意，以上内容仅为章节的部分内容，接下来将继续深入探讨Spring框架和Java Web实战项目。

本文还有配套的精品资源，点击获取

简介：本资料合集提供了从基础到企业级应用开发的Java学习资源，包括Java基础教程、数据库管理、图形用户界面开发、多线程编程等。涵盖了Java SE的核心概念、Java Web开发技术如JSP和Spring框架，以及用于数据库交互的框架如Hibernate。此外，还包括了C++基础知识、企业级JavaBean（EJB）、面试准备等，旨在帮助开发者全面掌握Java编程，并了解相关技术。

本文还有配套的精品资源，点击获取