大数据开发 – 第3页

Flink 1月 6,2025

解决flink toAppendStream doesn’t support consuming update changes which is produced by node GroupAggregate

下面的flink代码：

String sqlQuery = “SELECT MAX(val) AS max_val, MIN(val) AS min_val FROM dataT GROUP BY pid”;

Table resultTable = tableEnv.sqlQuery(sqlQuery);

DataStream resultStream = tableEnv.toAppendStream(resultTable, Row.class);

运行报错：

org.apache.flink.table.api.TableException: toAppendStream doesn’t support consuming update changes which is produced by node GroupAggregate(groupBy=[pid], select=[pid, MAX(val) AS max_val, MIN(val) AS min_val])

原因分析

报错信息提示 toAppendStream doesn't support consuming update changes which is produced by node GroupAggregate，这意味着在当前代码中使用 toAppendStream 方法去转换结果表为 DataStream 时出现了不兼容的情况。
在 Flink 中，当执行包含聚合操作（比如这里的 GROUP BY 以及 MAX、MIN 聚合函数计算）的 SQL 查询时，查询结果可能会产生更新（update）类型的变更，而 toAppendStream 方法只适用于那种仅追加（append-only）类型的结果，也就是结果表中数据只会新增而不会有更新、删除等变更的情况。这里的聚合操作导致了结果存在更新变化，所以调用 toAppendStream 就抛出了异常，它无法处理这种带有更新的数据变更情况。

正确代码修改思路及示例

要解决这个问题，可以使用 toRetractStream 方法来替代 toAppendStream 方法，toRetractStream 方法可以处理包含更新、删除等多种变更类型的数据，它返回的 DataStream 中元素是包含了一个布尔值标志（表示是新增还是撤回操作）以及实际的数据行（对应查询结果行）的二元组形式。
以下是修改后的代码示例：



        // 2. 添加 Source
        DataStream<RunData> dataSource = env.addSource(new TDengineSourceFunction(jdbcUrl, user, password, query));

        // 3. 注册临时表
        tableEnv.createTemporaryView("rundata", dataSource, "pid, val"); // 根据实际字段调整

        // 4. 执行 SQL 查询以计算最大值和最小值
        String sqlQuery = "SELECT MAX(val) AS max_val, MIN(val) AS min_val FROM dataT GROUP BY pid";
        Table resultTable = tableEnv.sqlQuery(sqlQuery);

        // 5. 将结果转换为 DataStream 并打印，这里使用 toRetractStream 替代 toAppendStream
        DataStream<Tuple2<Boolean, Row>> resultStream = tableEnv.toRetractStream(resultTable, Row.class);
        resultStream.print();

        // 6. 触发执行
        env.execute("Flink SQL Max and Min Calculation");
    }
}

作者 east

Flink, tdengine 1月 3,2025

Flink读取TDEngine数据实例，解决com.taosdata.jdbc.rs.RestfulDatabaseMetaData@38af9828 is not serializable. The object probably contains or references non serializable fields错误

用flink读取TDEngine，运行报错：
com.taosdata.jdbc.rs.RestfulDatabaseMetaData@38af9828 is not serializable. The object probably contains or references non serializable fields

这意味着 com.taosdata.jdbc.rs.RestfulDatabaseMetaData 类的对象无法被序列化，而 Flink 的作业中涉及到的某些操作需要将对象传递到不同的任务中，这就要求对象是可序列化的（即实现了 Serializable 接口）。在 Flink 中，所有要在分布式环境中传输或持久化的对象都必须是可序列化的。

RestfulDatabaseMetaData 是 TDengine JDBC 驱动中的一个类，它可能没有实现 Serializable 接口，因此在需要将该类对象传输到其他机器时，Flink 无法进行序列化。

解决方法是

使用 transient 关键字避免对不可序列化对象进行传递。

通过标记 connection、preparedStatement 和 resultSet 为 transient，这些对象不会被 Flink 传递到 Task Manager。

完整可执行代码如下：


import org.apache.flink.streaming.api.functions.source.RichParallelSourceFunction;

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

public class TDengineSourceFunction extends RichParallelSourceFunction<RunData> {

    private transient Connection connection;        // 使用 transient 避免序列化
    private transient PreparedStatement preparedStatement;
    private transient ResultSet resultSet;
    private String query;
    private volatile boolean isRunning = true;

    private String jdbcUrl;
    private String user;

    private String password;


    public TDengineSourceFunction(String jdbcUrl, String user, String password, String query) {
        this.query = query;
        this.jdbcUrl = jdbcUrl;
        this.user = user;
        this.password = password;

        // JDBC连接参数在open()方法中初始化
    }

    @Override
    public void open(org.apache.flink.configuration.Configuration parameters) throws Exception {
        super.open(parameters);
        Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
        // 在这里初始化数据库连接
        this.connection = DriverManager.getConnection(jdbcUrl, user, password);
        // 准备SQL查询语句
        this.preparedStatement = connection.prepareStatement(query);
        this.resultSet = preparedStatement.executeQuery();
    }

    @Override
    public void run(SourceContext<RunData> sourceContext) throws Exception {
        while (isRunning && resultSet.next()) {
            // 从ResultSet中提取数据并转换为RunData对象
            RunData data = convertResultSetToData(resultSet);
            // 将数据发送到Flink的处理流中
            if (data != null) {
                sourceContext.collect(data);
            }
        }
    }

    @Override
    public void cancel() {
        isRunning = false;
        // 关闭资源
        try {
            if (resultSet != null) resultSet.close();
            if (preparedStatement != null) preparedStatement.close();
            if (connection != null) connection.close();
        } catch (SQLException e) {
            // 处理关闭资源时的异常
            e.printStackTrace();
        }
    }

    private RunData convertResultSetToData(ResultSet resultSet) throws SQLException {
        // 提取单行数据
      
        // 将数据转换为 RunData 对象


      //  return new RunData(......);
        return null;
    }
}

作者 east

Flink 1月 3,2025

解决flink读取TDEngine的数据Could not initialize class com.taosdata.jdbc.TSDBJNIConnector

需要用flink读取TDEngine的数据，用jdbc方式连接，运行报错：Could not initialize class com.taosdata.jdbc.TSDBJNIConnector

JDBC-JNI的方式需要 TDengine-client（使用JDBC-JNI时必须，使用JDBC-RESTful时非必须）,所以采用JDBC-RESTful 的方式，原因是一开始想用
JDBC-JNI 的方式，想改用 JDBC-RESTful 代码没改干净。

通过指定URL获取连接，如下所示：

Class.forName("com.taosdata.jdbc.rs.RestfulDriver");
String jdbcUrl = "jdbc:TAOS-RS://taosdemo.com:6041/test?user=root&password=taosdata";
Connection conn = DriverManager.getConnection(jdbcUrl);

Class.forName("com.taosdata.jdbc.rs.RestfulDriver");String jdbcUrl = "jdbc:TAOS-RS://taosdemo.com:6041/test?user=root&password=taosdata";Connection conn = DriverManager.getConnection(jdbcUrl);

以上示例，使用 JDBC-RESTful 的 driver，建立了到 hostname 为 taosdemo.com，端口为 6041，数据库名为 test 的连接。这个 URL 中指定用户名（user）为 root，密码（password）为 taosdata。

使用 JDBC-RESTful 接口，不需要依赖本地函数库。与 JDBC-JNI 相比，仅需要：

driverClass 指定为“com.taosdata.jdbc.rs.RestfulDriver”；
jdbcUrl 以“jdbc:TAOS-RS://”开头；
使用 6041 作为连接端口。

按上面的方式修改，果然没有再报上面的错误。

作者 east

Flink 1月 3,2025

flink运行报错：java.lang.IllegalStateException: No ExecutorFactory found to execute the application

在本地运行flink代码，报错“
java.lang.IllegalStateException: No ExecutorFactory found to execute the application ”

通常是由于缺少必要的 Flink 依赖项导致的。具体来说，Flink 需要特定的执行器工厂来运行应用程序，而这些依赖项可能未正确包含在您的项目中。

原因分析

缺少 Flink 运行时依赖：
- 您的代码片段看起来是基于 Flink 的流处理 API 编写的。如果项目缺少 Flink 运行时的相关依赖（例如 flink-java, flink-streaming-java, 和 flink-clients），Flink 将无法找到执行器工厂来启动作业。
依赖版本不匹配：
- 如果您使用的 Flink 版本与代码不兼容，也可能导致类似的问题。确保所有 Flink 相关依赖的版本一致。
缺少必要的插件或扩展：
- 某些情况下，特定的 Flink 插件或扩展可能缺失，导致执行器工厂无法加载。

解决方案

确保您的项目中包含了所有必要的 Flink 依赖项。以下是使用 Maven 的示例 pom.xml 配置，确保包含了 Flink 的核心和流处理依赖：

<dependencies>
    <!-- Flink 核心依赖 -->
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-java</artifactId>
        <version>1.16.2</version> <!-- 请根据需要替换为合适的版本 -->
    </dependency>

    <!-- Flink 流处理依赖 -->
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-streaming-java_2.12</artifactId>
        <version>1.16.2</version> <!-- 版本需与 flink-java 一致 -->
    </dependency>

    <!-- Flink 客户端依赖（如果需要远程提交作业） -->
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-clients_2.12</artifactId>
        <version>1.16.2</version>
    </dependency>



    <!-- 如果使用自定义 Source 和 Sink，确保它们所在的依赖已添加 -->
</dependencies>

作者 east

Java, 面试 12月 29,2024

java多线程的实现的各种方法？

在 Java 中，实现多线程主要有以下几种方法：

继承 Thread 类：通过创建一个继承自 Thread 类的子类，并重写 run () 方法来定义线程的执行逻辑。然后创建该子类的实例，并调用 start () 方法启动线程。例如，以下代码创建了一个简单的线程类：

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程正在运行");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

实现 Runnable 接口：创建一个实现 Runnable 接口的类，并重写 run () 方法。然后创建该类的实例，并将其作为参数传递给 Thread 类的构造函数，最后调用 start () 方法启动线程。例如：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程正在运行");
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

使用 Callable 和 Future 接口：Callable 接口类似于 Runnable 接口，但它可以返回一个结果。Future 接口用于获取 Callable 任务的结果。可以通过创建一个实现 Callable 接口的类，并重写 call () 方法来定义线程的执行逻辑和返回结果。然后使用 ExecutorService 提交 Callable 任务，并通过 Future 获取任务的结果。例如：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        return 1 + 1;
    }
}

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<Integer> future = executor.submit(new MyCallable());
        Integer result = future.get();
        System.out.println("结果：" + result);
        executor.shutdown();
    }
}

使用线程池：线程池可以管理和复用线程，减少线程创建和销毁的开销。可以通过使用 ExecutorService 接口和其实现类来创建线程池，并提交任务到线程池中执行。例如：

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

public class Main {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) { executor.execute(() -> {
System.out.println(“线程正在运行”);
});
}
executor.shutdown();
}
}

作者 east

Java, 面试 12月 29,2024

面试必问题：单例模式的5种写法

单例模式主要有以下几种分类：

饿汉式单例：在类加载时就创建单例对象，优点是实现简单，线程安全，缺点是如果单例对象在程序运行过程中一直未被使用，会造成资源浪费。例如：

public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}

懒汉式单例：在第一次调用 getInstance 方法时才创建单例对象，优点是可以延迟加载，节省资源，但是在多线程环境下需要考虑线程安全问题。例如：

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

双重检查锁单例：在懒汉式单例的基础上，通过双重检查锁机制来提高性能并保证线程安全。例如：

public class Singleton {
    private volatile static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

静态内部类单例：利用静态内部类的特性来实现单例，既保证了线程安全，又实现了延迟加载。例如：

public class Singleton {
    private Singleton() {}

    private static class SingletonHolder {
        private static final Singleton instance = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
}

枚举单例：通过枚举类型来实现单例，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。例如：

public enum Singleton {
    INSTANCE;

    public void doSomething() {
        // 单例对象的方法
    }
}

在多线程环境下，保证单例模式的线程安全可以采用以下几种方法：

使用 synchronized 关键字：在获取单例对象的方法上添加 synchronized 关键字，如懒汉式单例中的 getInstance 方法，这样可以保证在同一时刻只有一个线程能够访问该方法，从而避免多个线程同时创建单例对象。但是这种方式会降低性能，因为每次调用该方法都需要获取锁。
双重检查锁机制：在懒汉式单例的基础上，通过双重检查锁机制来减少同步的开销。在第一次检查实例是否为 null 时，如果不为 null，则直接返回实例，不需要获取锁；只有在第一次检查为 null 时，才进入同步块再次检查并创建实例。同时，需要将实例变量声明为 volatile，以保证可见性和禁止指令重排序。
静态内部类：利用静态内部类的特性，在类加载时不会立即初始化内部类，只有在第一次调用 getInstance 方法时，才会加载并初始化内部类，从而创建单例对象。由于类加载过程是线程安全的，所以这种方式可以保证单例的线程安全，并且实现了延迟加载。
枚举：枚举类型在 Java 中是天然的单例，因为 Java 虚拟机在加载枚举类时会保证只有一个实例存在，并且枚举类的实例是线程安全的，所以可以通过枚举来实现单例模式，避免了复杂的线程安全处理。

作者 east

bug清单, 大数据开发 12月 25,2024

解决idea运行scala代码报错：scala: No ‘scala-library*.jar’ in Scala compiler classpath in Scala SDK Maven: org.scala-lang:scala-library:2.11.12

这个错误信息表明，Scala 编译器的 classpath 中缺少必要的 scala-library*.jar 文件，特别是 Scala SDK 所需的 scala-library 版本 2.11.12。错误发生的原因通常是因为项目的构建配置缺失或错误，导致 Scala 编译器无法找到正确的库文件。

分析原因：

Maven 配置问题： 错误信息中提到 Maven: org.scala-lang:scala-library:2.11.12，这表明你的项目在使用 Maven 来管理依赖。可能是 pom.xml 文件中的 Scala 依赖配置不正确，导致缺少 scala-library JAR 文件。
IDE 配置问题： 另一个可能的原因是 IntelliJ IDEA 中的 Scala SDK 配置不完整或错误。Scala SDK 包括了编译器和库，如果 SDK 配置不正确，IDE 就无法正确找到必要的库文件。

解决方案：

1. 检查 `pom.xml` 文件中的 Scala 依赖

确保 pom.xml 中包含了正确版本的 Scala 依赖。如果没有，请添加类似下面的配置：

<dependency>
    <groupId>org.scala-lang</groupId>
    <artifactId>scala-library</artifactId>
    <version>2.11.12</version>
</dependency>

如果你使用的是其他 Scala 版本（如 2.13 或 3.x），需要替换为相应的版本号。

2. 确保项目中配置了正确的 Scala 编译器和 SDK

在 IntelliJ IDEA 中，检查你是否已经配置了 Scala SDK。
- 打开 File -> Project Structure -> Modules -> 选择你的模块 -> Dependencies，确保选择了正确的 Scala SDK。
- 你也可以在 Project Structure 中检查 Scala SDK 的版本是否与你项目中使用的版本匹配。

3. 更新或重新下载 Scala 库

在 IntelliJ IDEA 中，尝试通过右键点击项目根目录并选择 Maven -> Reimport 来重新加载依赖。
如果仍然无法解决问题，可以尝试删除 ~/.m2/repository/org/scala-lang/scala-library/ 下的对应版本文件，然后重新构建项目。

如果上面的方法都没办法解决，可以删除
File>>Project Structure>>Libraries中删除默认的scala编译library，替换成本地的scala-sdk 。

首先在Global Libraries中添加本地scala-sdk

Modules -> 选择你的模块 -> Dependencies，确保选择本地 Scala SDK。

作者 east

Java 12月 22,2024

大厂面试手撕面试题:反转链表中前 K 个节点（亲测可用的java实现)

我们需要反转链表中前 k 个节点，且可能会有多个这样的反转段（每 k 个节点为一组）。如果链表的剩余部分不满 k 个节点，我们就不对其进行反转，直接保留原样。

解题思路：

链表结构：
- 我们有一个单链表，定义为 ListNode 类型。每个节点包含一个值 val 和指向下一个节点的指针 next。
- 目标是反转链表中前 k 个节点，并对每一组长度为 k 的节点进行反转，直到链表遍历完。
关键步骤：
- 判断当前段是否满 k 个节点： 在反转之前，我们必须确认当前的节点数是否足够 k 个。如果不足，直接跳过该段，保持原链表顺序。
- 反转当前 k 个节点： 如果当前段正好有 k 个节点，我们就进行反转。
- 连接反转后的链表： 反转后的链表需要和之前的链表正确连接，以保证链表结构的完整性。
具体步骤：
- 维护一个 dummy 虚拟节点，它的 next 指针指向链表头。这样可以避免链表头部的特殊情况处理，使得头节点的反转与其他节点反转保持一致。
- 使用 prevGroupEnd 指针来标记上一个反转段的最后一个节点，它在反转完成后需要连接到当前反转段的最后一个节点。
- 对每一组长度为 k 的节点进行反转。具体做法是使用 prev 和 curr 两个指针，通过迭代的方式完成每组的反转。
- 完成一组反转后，更新 prevGroupEnd 和 head，继续处理下一组。
终止条件：
- 当链表遍历完，或者剩下的节点不足 k 个时，停止反转操作。

代码详解：

public class Solution {
    
    public ListNode reverseKGroup(ListNode head, int k) {
        // 如果链表为空或 k 为 1，直接返回头节点
        if (head == null || k == 1) return head;
        
        // 创建一个虚拟节点，用于简化操作
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        
        // prevGroupEnd 用于指向前一组反转后链表的末尾节点
        ListNode prevGroupEnd = dummy;
        
        // 当前头节点 head
        while (head != null) {
            // 找到当前组的最后一个节点
            ListNode groupEnd = head;
            int count = 1;
            // 计算当前组的节点数量
            while (groupEnd != null && count < k) {
                groupEnd = groupEnd.next;
                count++;
            }
            
            // 如果当前组的节点数不足 K 个，不需要反转，直接返回
            if (groupEnd == null) break;
            
            // 反转当前组的节点
            ListNode nextGroupStart = groupEnd.next;  // 保存下一个组的起始节点
            ListNode prev = nextGroupStart;  // prev 初始指向下一组的起始节点
            ListNode curr = head;  // curr 初始指向当前组的头节点
            
            // 反转当前组的节点
            while (curr != nextGroupStart) {
                ListNode temp = curr.next;  // 暂存当前节点的下一个节点
                curr.next = prev;  // 将当前节点的 next 指向 prev（反转）
                prev = curr;  // prev 更新为当前节点
                curr = temp;  // curr 更新为下一个节点
            }
            
            // 将上一组的尾节点连接到当前反转后的组的头节点
            prevGroupEnd.next = groupEnd;
            // 当前组的头节点（反转后）需要指向下一组的起始节点
            head.next = nextGroupStart;
            
            // 更新 prevGroupEnd 和 head，准备处理下一组
            prevGroupEnd = head;
            head = nextGroupStart;
        }
        
        return dummy.next; // 返回新的链表头节点
    }

    // 辅助方法：打印链表
    public void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.val + " ");
            head = head.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        
        // 创建一个链表 1 -> 2 -> 3 -> 4 -> 5
        ListNode head = new ListNode(1);
        head.next = new ListNode(2);
        head.next.next = new ListNode(3);
        head.next.next.next = new ListNode(4);
        head.next.next.next.next = new ListNode(5);
        
        int k = 3;
        
        // 输出原链表
        System.out.print("Original List: ");
        solution.printList(head);
        
        // 调用反转链表前 K 个节点的方法
        ListNode newHead = solution.reverseKGroup(head, k);
        
        // 输出反转后的链表
        System.out.print("List after reversing first " + k + " nodes: ");
        solution.printList(newHead);
    }
}

详细解析：

虚拟节点 dummy：
- dummy 节点的作用是简化链表头部的操作，避免对链表头的特殊处理。通过将 dummy.next 设置为链表的头节点，我们可以统一处理链表的反转和连接。
变量 prevGroupEnd：
- prevGroupEnd 用于连接每次反转后组的最后一个节点。初始化时，它指向虚拟节点 dummy。
- 在每次反转完成后，prevGroupEnd 被更新为当前反转组的头节点 head。
变量 groupEnd 和 count：
- groupEnd 用于记录当前反转组的最后一个节点。如果当前组不足 k 个节点，则不进行反转。
- count 用来计算当前组的节点数。如果 count 达到 k，则进行反转操作。
反转操作：
- 反转时，通过三个指针 prev（指向反转后的部分），curr（当前处理的节点），和 temp（暂存当前节点的下一个节点）来完成每一组的节点反转。
- 完成反转后，将 prevGroupEnd 的 next 指向当前反转组的尾节点 groupEnd，并将 head.next 指向剩余部分的起始节点。
循环和终止条件：
- 每次反转 k 个节点后，将 head 更新为剩余部分的起始节点，继续进行下一组的处理。
- 当剩余节点不足 k 个时，循环终止。

时间复杂度：

O(n)： 每个节点会被访问并反转一次，总时间复杂度为 O(n)，其中 n 是链表的节点数。

空间复杂度：

O(1)： 只使用了常数的额外空间，除了输入的链表本身。

示例：

对于链表 1 -> 2 -> 3 -> 4 -> 5 和 k = 3，执行反转操作后，链表将变为 3 -> 2 -> 1 -> 4 -> 5。

作者 east

Java 12月 22,2024

大厂面试手撕面试题:删除字符串中的指定字符（亲测可用的java实现)

要求：给定一个字符串 s 和一个字符 t，要求删除字符串中所有出现的字符 t，并返回处理后的新字符串。

Java代码实现：

public class Solution {
    public static String removeCharacter(String s, char t) {
        // 使用 StringBuilder 来构建结果字符串
        StringBuilder result = new StringBuilder();

        // 遍历原字符串，拼接不等于 t 的字符
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) != t) {
                result.append(s.charAt(i));
            }
        }

        // 返回结果字符串
        return result.toString();
    }

    public static void main(String[] args) {
        String s = "hello world";
        char t = 'o';
        
        String result = removeCharacter(s, t);
        System.out.println(result); // 输出 "hell wrld"
    }
}

代码解释：

removeCharacter 方法：
- 输入：一个字符串 s 和一个字符 t。
- 使用 StringBuilder 来构建新的字符串，这样在处理大量字符时会更加高效。
- 遍历原字符串 s，将不等于 t 的字符添加到 StringBuilder 中。
- 最终通过 toString() 返回结果。
main 方法：
- 示例：给定字符串 "hello world"，删除字符 'o' 后，结果是 "hell wrld"。

时间复杂度：

遍历一次字符串，时间复杂度为 O(n)，其中 n 是字符串 s 的长度。

空间复杂度：

由于使用了 StringBuilder 来存储新的字符串，空间复杂度为 O(n)，其中 n 是字符串 s 的长度。

作者 east

Java, 面试 12月 22,2024

大厂面试手撕面试题:一个字符串中最长的没有重复字符的子串（亲测可用的java实现)

要解决 “求解一个字符串中最长的没有重复字符的子串” 的问题，可以使用 滑动窗口（Sliding Window）算法。这个算法通过维护一个动态窗口来跟踪当前没有重复字符的子串，然后逐步扩展窗口来找到最长的子串。

思路：

使用两个指针，left 和 right，表示当前窗口的左右边界。
通过哈希集合（HashSet 或 HashMap）来存储窗口中的字符，确保每个字符在窗口内唯一。
从左到右遍历字符串，每次右指针right向右移动，检查字符是否已经在窗口中存在。如果存在，就将左指针left向右移动，直到窗口中没有重复字符。
更新最长子串的长度。

Java实现：

import java.util.HashSet;

public class LongestSubstring {
    public static int lengthOfLongestSubstring(String s) {
        // 哈希集合用于存储窗口中的字符
        HashSet<Character> set = new HashSet<>();
        
        // 定义左右指针和最大长度
        int left = 0;
        int maxLength = 0;
        
        // 右指针向右移动，遍历字符串
        for (int right = 0; right < s.length(); right++) {
            // 如果右指针指向的字符在集合中，说明有重复字符
            // 移动左指针直到去除重复字符
            while (set.contains(s.charAt(right))) {
                set.remove(s.charAt(left));
                left++;
            }
            
            // 将当前字符加入集合
            set.add(s.charAt(right));
            
            // 更新最大长度
            maxLength = Math.max(maxLength, right - left + 1);
        }
        
        return maxLength;
    }

    public static void main(String[] args) {
        String s = "abcabcbb";
        System.out.println("The length of the longest substring without repeating characters is: " + lengthOfLongestSubstring(s));
    }
}

解释：

HashSet<Character> set = new HashSet<>();：
- 用于存储当前窗口内的字符，确保窗口内的字符唯一。
left 和 right 指针：
- right指针用来遍历字符串。
- left指针控制窗口的起始位置，确保窗口内没有重复字符。
滑动窗口的调整：
- 当遇到重复字符时，移动left指针，直到窗口内不再有重复字符。
- 每次移动时，都会更新maxLength，保持最大窗口的长度。
时间复杂度：
- 最坏情况下，left 和 right 每个指针最多各走一次字符串，因此时间复杂度是 O(n)，其中 n 是字符串的长度。

示例输出：

对于输入 "abcabcbb"，输出结果是：

The length of the longest substring without repeating characters is: 3

该子串是 "abc"，其长度为 3。

作者 east

Java 12月 22,2024

大厂面试手撕面试题:冒泡排序（亲测可用的java实现)

冒泡排序（Bubble Sort）是一种简单的排序算法。它通过重复遍历待排序的列表，比较相邻元素并交换它们的位置，直到整个列表排序完成。每次遍历都会把当前未排序部分的最大值“冒泡”到数组的最后。

思路：

从数组的第一个元素开始，逐个比较相邻的元素。
如果当前元素大于下一个元素，交换它们的位置。
每一轮遍历后，最大的元素会被“冒泡”到数组的末尾。
每次遍历的长度逐渐减少，因为已经排序好的元素已经“浮到”数组的末尾。
直到没有需要交换的元素时，排序完成。

冒泡排序的优化：

如果在某次遍历中没有进行交换，说明数组已经是有序的，可以提前结束排序，避免不必要的遍历。

Java 完整代码实现：

public class BubbleSort {
    public static void main(String[] args) {
        // 测试数组
        int[] arr = {5, 2, 9, 1, 5, 6};
        
        // 调用冒泡排序
        bubbleSort(arr);
        
        // 打印排序后的数组
        System.out.println("Sorted array:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
    
    // 冒泡排序方法
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        
        // 外层循环控制排序的轮数
        for (int i = 0; i < n - 1; i++) {
            boolean swapped = false;  // 标记是否发生了交换
            
            // 内层循环进行相邻元素比较和交换
            for (int j = 0; j < n - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换 arr[j] 和 arr[j + 1]
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = true;
                }
            }
            
            // 如果没有发生交换，说明数组已经有序，提前结束
            if (!swapped) {
                break;
            }
        }
    }
}

代码解释：

主方法 (main)：初始化一个整数数组并调用 bubbleSort 方法进行排序。排序后打印数组。
冒泡排序方法 (bubbleSort)：
- 外层循环控制排序的轮次，每一轮确保将最大的元素“冒泡”到末尾。
- 内层循环执行相邻元素的比较和交换。如果当前元素比下一个元素大，则交换。
- swapped 是一个标记，用来检查在某一轮遍历中是否发生了交换。如果某轮没有交换，说明数组已经是有序的，可以提前结束排序。

时间复杂度：

最坏情况下，时间复杂度为 O(n^2)，即当数组是逆序时。
最好情况下（当数组已经是有序的），时间复杂度为 O(n)，因为只会进行一次遍历且没有发生任何交换。

空间复杂度：

O(1)，因为该算法是原地排序，不需要额外的空间。

作者 east

分类归档大数据开发