面试必背 - Java篇（八）

最新推荐文章于 2024-09-28 19:02:04 发布

摸鱼老师

最新推荐文章于 2024-09-28 19:02:04 发布

阅读量60

点赞数

分类专栏： java 文章标签：面试 java 职场和发展

本文链接：https://blog.csdn.net/qq_35460634/article/details/132548370

版权

java 专栏收录该内容

15 篇文章 2 订阅

订阅专栏

71、阐述JDBC操作数据库的步骤。

JDBC（Java Database Connectivity）是Java语言中用于连接和操作数据库的标准API。下面是JDBC操作数据库的步骤：

加载数据库驱动：使用Class.forName()方法加载数据库驱动类，例如加载MySQL驱动：Class.forName(“com.mysql.jdbc.Driver”);
建立数据库连接：使用DriverManager.getConnection()方法获取数据库连接对象，例如：Connection conn = DriverManager.getConnection(url, username, password);
创建Statement对象：通过Connection对象的createStatement()方法创建Statement对象，用于执行SQL语句，例如：Statement stmt = conn.createStatement();
执行SQL语句：使用Statement对象的executeQuery()方法执行查询语句，或者使用executeUpdate()方法执行更新语句，例如：ResultSet rs = stmt.executeQuery(“SELECT * FROM users”);
处理结果集：如果执行的是查询语句，需要遍历ResultSet对象，获取查询结果，例如：while (rs.next()) { System.out.println(rs.getString(“username”)); }
关闭资源：依次关闭ResultSet、Statement和Connection对象，释放资源，例如：rs.close(); stmt.close(); conn.close();

下面是一个使用JDBC操作MySQL数据库的示例代码及注释：

import java.sql.*;

public class JdbcDemo {
    public static void main(String[] args) {
        // 1. 加载数据库驱动
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        // 2. 建立数据库连接
        String url = "jdbc:mysql://localhost:3306/test";
        String username = "root";
        String password = "123456";
        try (Connection conn = DriverManager.getConnection(url, username, password)) {
            // 3. 创建Statement对象
            Statement stmt = conn.createStatement();

            // 4. 执行SQL语句
            String sql = "SELECT * FROM users";
            ResultSet rs = stmt.executeQuery(sql);

            // 5. 处理结果集
            while (rs.next()) {
                System.out.println(rs.getString("username"));
            }

            // 6. 关闭资源
            rs.close();
            stmt.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，我们首先加载了MySQL数据库驱动，然后建立了一个到本地MySQL数据库的连接。接着，我们创建了一个Statement对象，并执行了一个查询语句，获取了users表中的所有数据。最后，我们遍历了查询结果，并关闭了相关资源。

72、 Statement和PreparedStatement有什么区别？哪个性能更好？

Statement 和 PreparedStatement 都是 Java 中用于执行 SQL 查询的接口，但它们之间存在一些关键区别。

预处理：PreparedStatement 可以预编译 SQL 语句，这意味着相同的 SQL 查询只需要编译一次，然后可以多次执行。这在处理大量重复的 SQL 查询时，可以提高性能并减少数据库的负载。相比之下，Statement 每次都需要编译 SQL 查询，即使查询相同。
安全性：PreparedStatement 可以防止 SQL 注入攻击，因为它自动转义参数，而不是将它们直接插入到查询字符串中。而 Statement 则不提供这种保护。
可读性和可维护性：使用 PreparedStatement 可以使代码更清晰、更易于理解和维护，因为你只需要编写 SQL 查询，然后将参数传递给 PreparedStatement。而使用 Statement 则需要手动管理 SQL 查询和参数的拼接。
性能：在大多数情况下，PreparedStatement 的性能与 Statement 相当。但是，如果你需要处理大量的重复查询，或者你的数据库支持预编译查询，那么 PreparedStatement 可能会有更好的性能。

下面是一个简单的代码示例，说明了如何使用 PreparedStatement 和 Statement：

import java.sql.*;

public class Main {
    public static void main(String[] args) {
        try {
            // 加载数据库驱动
            Class.forName("com.mysql.jdbc.Driver");

            // 创建连接
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password");

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

            // 执行查询
            ResultSet rs = stmt.executeQuery("SELECT * FROM users WHERE id = " + 1);
            while (rs.next()) {
                System.out.println(rs.getString("name"));
            }

            // 关闭连接
            rs.close();
            stmt.close();
            conn.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.sql.*;

public class Main {
    public static void main(String[] args) {
        try {
            // 加载数据库驱动
            Class.forName("com.mysql.jdbc.Driver");

            // 创建连接
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password");

            // 创建 PreparedStatement
            PreparedStatement pstmt = conn.prepareStatement("SELECT * FROM users WHERE id = ?");

            // 设置参数
            pstmt.setInt(1, 1);

            // 执行查询
            ResultSet rs = pstmt.executeQuery();
            while (rs.next()) {
                System.out.println(rs.getString("name"));
            }

            // 关闭连接
            rs.close();
            pstmt.close();
            conn.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这两个例子中，第一个使用 Statement，第二个使用 PreparedStatement。

73、使用JDBC操作数据库时，如何提升读取数据的性能？如何提升更新数据的性能？

提升读取数据的性能：

使用批处理：将多个查询合并成一个批处理，这样可以减少与数据库的交互次数，提高性能。
使用缓存：将经常访问的数据缓存在内存中，减少对数据库的访问。
优化SQL语句：避免使用SELECT *，只查询需要的字段；尽量减少JOIN操作；使用索引等。

提升更新数据的性能：

使用事务：将多次更新操作放在一个事务中，这样可以减少提交次数，提高性能。
使用批量更新：一次性更新多条记录，而不是逐条更新。
关闭自动提交：在执行大量更新操作之前，关闭自动提交功能，然后在所有更新操作完成后手动提交。

以下是一个使用JDBC操作数据库的示例代码，包括读取和更新数据的性能优化：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class JdbcDemo {
    private static final String URL = "jdbc:mysql://localhost:3306/test";
    private static final String USER = "root";
    private static final String PASSWORD = "password";

    public static void main(String[] args) {
        try {
            // 加载驱动
            Class.forName("com.mysql.jdbc.Driver");

            // 获取连接
            Connection conn = DriverManager.getConnection(URL, USER, PASSWORD);

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

            // 读取数据
            String sql = "SELECT id, name FROM users";
            PreparedStatement pstmt = conn.prepareStatement(sql);
            ResultSet rs = pstmt.executeQuery();
            while (rs.next()) {
                int id = rs.getInt("id");
                String name = rs.getString("name");
                System.out.println("ID: " + id + ", Name: " + name);
            }

            // 更新数据
            sql = "UPDATE users SET name = ? WHERE id = ?";
            pstmt = conn.prepareStatement(sql);
            pstmt.setString(1, "new_name");
            pstmt.setInt(2, 1);
            pstmt.addBatch();
            pstmt.executeBatch();

            // 提交事务
            conn.commit();

            // 关闭资源
            rs.close();
            pstmt.close();
            conn.close();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，我们使用了批处理来读取数据，以提高性能。同时，我们在执行更新操作之前关闭了自动提交功能，并在所有更新操作完成后手动提交，以提高更新数据的性能。

74、在进行数据库编程时，连接池有什么作用？

连接池的作用是管理数据库连接，避免频繁地创建和销毁连接，从而提高性能。当应用程序需要访问数据库时，可以从连接池中获取一个空闲的连接，使用完毕后再归还给连接池。这样可以避免频繁地创建和销毁连接，降低系统开销。

以下是一个使用Java和JDBC进行数据库编程时，使用连接池的示例代码：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import javax.sql.DataSource;
import org.apache.commons.dbcp2.BasicDataSource;

public class DatabaseDemo {
    public static void main(String[] args) {
        // 创建连接池
        BasicDataSource dataSource = new BasicDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("password");
        dataSource.setInitialSize(5); // 初始化时建立5个连接
        dataSource.setMaxTotal(10); // 连接池最大连接数为10

        try (Connection connection = dataSource.getConnection()) {
            // 使用连接进行数据库操作
            System.out.println("成功获取数据库连接");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，我们使用了Apache Commons DBCP库来创建一个连接池。首先，我们创建了一个BasicDataSource对象，并设置了数据库驱动、连接URL、用户名和密码。然后，我们设置了连接池的初始大小和最大连接数。最后，我们从连接池中获取一个空闲的连接，并使用它进行数据库操作。

75、什么是DAO模式？

DAO模式是一种设计模式，用于将数据访问和业务逻辑分离。它提供了访问关系型数据库系统所需操作的接口，将数据访问和业务逻辑分离对上层提供面向对象的数据访问接口。DAO模式的优势在于它实现了两次隔离。1、隔离了数据访问代码和业务逻辑代码。业务逻辑代码直接调用DAO方法即可，完全感觉不到数据库表的存在。分工明确，数据访问层代码变化不影响业务逻辑代码，这符合单一职能原则，降低了藕合性，提高了可复用性。2、隔离了不同数据库实现。采用面向接口编程，如果底层数据库变化，如由MySQL变成Oracle只要增加DAO接口的新实现类即可，原有MySQL实现不用修改。这符合“开-闭”原则。该原则降低了代码的藕合性，提高了代码扩展性和系统的可移植性。

以下是一个使用Java编写的DAO模式示例代码：

// 数据访问对象接口
public interface UserDao {
    User getUserById(int id);
    void addUser(User user);
    void updateUser(User user);
    void deleteUser(int id);
}

// 数据访问对象实现类
public class UserDaoImpl implements UserDao {
    private static final String DATABASE_URL = "jdbc:mysql://localhost:3306/test";
    private static final String DATABASE_USERNAME = "root";
    private static final String DATABASE_PASSWORD = "password";

    public User getUserById(int id) {
        Connection connection = null;
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            connection = DriverManager.getConnection(DATABASE_URL, DATABASE_USERNAME, DATABASE_PASSWORD);
            String sql = "SELECT * FROM users WHERE id = ?";
            statement = connection.prepareStatement(sql);
            statement.setInt(1, id);
            resultSet = statement.executeQuery();
            if (resultSet.next()) {
                User user = new User();
                user.setId(resultSet.getInt("id"));
                user.setName(resultSet.getString("name"));
                user.setEmail(resultSet.getString("email"));
                return user;
            } else {
                return null;
            }
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (resultSet != null) resultSet.close();
                if (statement != null) statement.close();
                if (connection != null) connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

76、事务的ACID是指什么？

ACID是指数据库管理系统（DBMS）在写入或更新资料的过程中，为保证事务是正确可靠的，所必须具备的四个特性：原子性（atomicity，或称不可分割性）、一致性（consistency）、隔离性（isolation，又称独立性）、持久性（durability）。其中，原子性指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生；一致性指事务前后数据的完整性必须保持一致；隔离性指并发执行的事务之间不能互相干扰；持久性指事务完成后，它对数据库的所有更新将被保存到数据库中。

以下是一个使用Java JDBC实现ACID特性的例子：

public void updateUser(User user) {
    Connection conn = null;
    PreparedStatement pstmt = null;
    try {
        // 开启事务
        conn = dataSource.getConnection();
        conn.setAutoCommit(false);
        // 执行更新操作
        String sql = "UPDATE users SET name=?, email=? WHERE id=?";
        pstmt = conn.prepareStatement(sql);
        pstmt.setString(1, user.getName());
        pstmt.setString(2, user.getEmail());
        pstmt.setInt(3, user.getId());
        pstmt.executeUpdate();
        // 提交事务
        conn.commit();
    } catch (SQLException e) {
        // 回滚事务
        if (conn != null) {
            try {
                conn.rollback();
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        }
        e.printStackTrace();
    } finally {
        // 关闭资源
        if (pstmt != null) {
            try {
                pstmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

77、 JDBC 中如何进行事务处理？

JDBC 中进行事务处理需要使用事务 API，包括以下四个方法：

setAutoCommit(false)：关闭自动提交事务，将事务控制交给程序员。
commit()：提交事务，将对数据库的修改永久保存到数据库中。
rollback()：回滚事务，撤销对数据库的所有修改。
getConnection()：获取与当前事务关联的连接。

以下是一个使用 JDBC 进行事务处理的例子：

public void updateUser(int id, String name, String email) {
    Connection conn = null;
    PreparedStatement pstmt = null;
    try {
        // 开启事务
        conn = dataSource.getConnection();
        conn.setAutoCommit(false);
        // 执行更新操作
        String sql = "UPDATE users SET name=?, email=? WHERE id=?";
        pstmt = conn.prepareStatement(sql);
        pstmt.setString(1, name);
        pstmt.setString(2, email);
        pstmt.setInt(3, id);
        pstmt.executeUpdate();
        // 提交事务
        conn.commit();
    } catch (SQLException e) {
        // 回滚事务
        if (conn != null) {
            try {
                conn.rollback();
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        }
        e.printStackTrace();
    } finally {
        // 关闭资源
        if (pstmt != null) {
            try {
                pstmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

在这个例子中，我们首先通过 dataSource.getConnection() 获取一个数据库连接对象 conn，然后调用 conn.setAutoCommit(false) 关闭自动提交事务，将事务控制交给程序员。接着，我们使用 conn.prepareStatement(sql) 创建一个 PreparedStatement 对象 pstmt，并设置 SQL 语句中的参数值。最后，我们调用 pstmt.executeUpdate() 执行 SQL 语句，完成对数据库的修改操作。如果一切正常，我们调用 conn.commit() 提交事务，将对数据库的修改永久保存到数据库中；否则，我们调用 conn.rollback() 回滚事务，撤销对数据库的所有修改。在 finally 块中，我们关闭 PreparedStatement 和 Connection 对象，释放资源。

78、 JDBC能否处理Blob和Clob？

JDBC 可以处理 Blob 和 Clob 类型的数据。Blob 类型通常用于存储二进制数据，如图像、音频等，而 Clob 类型则用于存储大型文本数据，如 HTML、XML 等。

以下是一个使用 JDBC 处理 Blob 和 Clob 类型数据的例子：

import java.io.*;
import java.sql.*;

public class JdbcBlobClobExample {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement pstmt = null;
        ResultSet rs = null;
        try {
            // 连接数据库
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password");
            // 创建预处理语句
            pstmt = conn.prepareStatement("SELECT id, name, data FROM files WHERE id = ?");
            // 设置参数
            pstmt.setInt(1, 1);
            // 执行查询
            rs = pstmt.executeQuery();
            // 处理结果集
            while (rs.next()) {
                int id = rs.getInt("id");
                String name = rs.getString("name");
                InputStream inputStream = rs.getBlob("data").getBinaryStream();
                BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
                String line;
                while ((line = reader.readLine()) != null) {
                    System.out.println(line);
                }
                reader.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 关闭资源
            try {
                if (rs != null) {
                    rs.close();
                }
                if (pstmt != null) {
                    pstmt.close();
                }
                if (conn != null) {
                    conn.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

在这个例子中，我们首先通过 DriverManager.getConnection() 方法获取一个数据库连接对象 conn，然后创建一个预处理语句 pstmt，并设置 SQL 语句中的参数。接着，我们执行查询并将结果保存在 ResultSet 对象 rs 中。最后，我们遍历结果集，对于每一行数据，我们使用 getBlob() 方法获取 Blob 类型的数据，并使用 getBinaryStream() 方法获取其二进制流。然后，我们使用 BufferedReader 对象读取数据，并将其打印到控制台上。最后，我们关闭所有打开的资源。

79、简述正则表达式及其用途。

正则表达式（Regular Expression）是一种用于匹配字符串的模式，它可以用来检查一个字符串是否符合某种规则、提取符合规则的子串等。正则表达式是由一些特殊字符和普通字符组成的字符串，可以用来描述复杂的字符串匹配模式。

正则表达式的主要用途有：

文本搜索：使用正则表达式可以方便地在文本中查找符合特定模式的字符串。
数据验证：使用正则表达式可以对用户输入的数据进行验证，确保数据的格式正确。
替换操作：使用正则表达式可以方便地替换字符串中符合特定模式的子串。

以下是一个使用Python的re模块进行正则表达式匹配的例子：

import re

# 定义一个正则表达式模式，用于匹配邮箱地址
pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'

# 定义一个待匹配的字符串
text = '我的邮箱地址是example@example.com，请联系我。'

# 使用re模块的search方法进行匹配
result = re.search(pattern, text)

# 判断是否匹配成功
if result:
    print('找到邮箱地址：', result.group())
else:
    print('未找到邮箱地址')

在这个例子中，我们定义了一个正则表达式模式pattern，用于匹配邮箱地址。然后，我们使用re.search()方法在待匹配的字符串text中查找符合该模式的子串。如果匹配成功，我们输出匹配到的邮箱地址；否则，输出未找到邮箱地址的提示。

80、 Java中是如何支持正则表达式操作的？

Java中支持正则表达式操作主要通过java.util.regex包中的Pattern和Matcher类来实现。

以下是一个使用java.util.regex包进行正则表达式匹配的例子：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexDemo {
    public static void main(String[] args) {
        // 定义一个正则表达式模式，用于匹配邮箱地址
        String pattern = "\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\\b";

        // 定义一个待匹配的字符串
        String text = "我的邮箱地址是example@example.com，请联系我。";

        // 使用Pattern类的compile方法编译正则表达式
        Pattern compiledPattern = Pattern.compile(pattern);

        // 使用Pattern类的matcher方法获取一个Matcher对象
        Matcher matcher = compiledPattern.matcher(text);

        // 使用Matcher对象的find方法查找符合正则表达式的子串
        if (matcher.find()) {
            System.out.println("找到邮箱地址：" + matcher.group());
        } else {
            System.out.println("未找到邮箱地址");
        }
    }
}

在这个例子中，我们首先定义了一个正则表达式模式pattern，用于匹配邮箱地址。然后，我们使用Pattern.compile()方法编译这个正则表达式，得到一个Pattern对象。接着，我们使用Pattern.matcher()方法获取一个Matcher对象，该对象可以用来对字符串进行匹配操作。最后，我们使用Matcher.find()方法查找符合正则表达式的子串，并使用Matcher.group()方法获取匹配到的子串。