海康威视笔试凉经（供大家参考）

选择/多选（就记得这么多了）

线程同步机制

下面是几种常见的线程同步的方式：

1. 互斥锁(Mutex)：采用互斥对象机制，只有拥有互斥对象的线程才有访问公共资源的权限。因为互斥对象只有一个，所以可以保证公共资源不会被多个线程同时访问。比如 Java 中的 synchronized 关键词和各种 Lock 都是这种机制。
2. 读写锁（Read-Write Lock）：允许多个线程同时读取共享资源，但只有一个线程可以对共享资源进行写操作。
3. 信号量(Semaphore)：它允许同一时刻多个线程访问同一资源，但是需要控制同一时刻访问此资源的最大线程数量。
4. 屏障（Barrier）：屏障是一种同步原语，用于等待多个线程到达某个点再一起继续执行。当一个线程到达屏障时，它会停止执行并等待其他线程到达屏障，直到所有线程都到达屏障后，它们才会一起继续执行。比如 Java 中的 CyclicBarrier 是这种机制。
5. 事件(Event) :Wait/Notify：通过通知操作的方式来保持多线程同步，还可以方便的实现多线程优先级的比较操作

Mybatis当中的￥{} 和 # {}

#{}方式能够很大程度防止sql注入(安全)，${}方式无法防止Sql注入

在JDBC能使用占位符的地方,最好优先使用#{}

在JDBC不支持使用占位符的地方,就只能使用${}，典型情况就是 动态参数

#{}实现的是向prepareStatement中的预处理语句中设置参数值，sql语句中#{}表示一个占位符即?

TCP协议

lambda表达式的使用规则

异常是不是对象？

PreparedStatement和Statement的区别

1. Statement：
2. PreparedStatement：

SpringBoot读取配置文件的注解

@PropertySource,@Value,@Environment,@ConfigurationProperties

newInstance属于哪个类

Java窗口函数关键字

窗口函数是 SQL 中一类特别的函数。和聚合函数相似，窗口函数的输入也是多行记录。不 同的是，聚合函数的作用于由 GROUP BY 子句聚合的组，而窗口函数则作用于一个窗口， 这里，窗口是由一个 OVER 子句 定义的多行记录。聚合函数对其所作用的每一组记录输 出一条结果，而窗口函数对其所作用的窗口中的每一行记录输出一条结果。一些聚合函 数，如 sum, max, min, avg,count 等也可以当作窗口函数使用

1.聚合窗口函数

许多常见的聚合函数也可以作为窗口函数使用，包括AVG()、SUM()、COUNT()、MAX()以及MIN()等函数。

2.排名窗口函数

排名窗口函数用于对数据进行分组排名，包括ROW_NUMBER()、RANK()、DENSE_RANK()、PERCENT_RANK()、CUME_DIST()以及NTILE()等函数。

3.取值窗口函数

取值窗口函数用于返回指定位置上的数据行，包括FIRST_VALUE()、LAST_VALUE()、LAG()、LEAD()、NTH_VALUE()等函数

WEB输出值不完全可能会造成哪些漏洞？

跨站脚本攻击（XSS）、跨站请求伪造（CSRF）、SQL注入、HTTP响应拆分、信息泄露、文件包含漏洞；

编程题

table(date, user_id, time) (20230101, 1 , 2023-1-01 9-01- 00 00 00)

找出各个用户一周的活跃天数：

SELECT user_id, COUNT(DISTINCT DATE_FORMAT(time, '%Y-%m-%d')) AS active_days
FROM table
WHERE time >= DATE_SUB(CURDATE(), INTERVAL 1 WEEK)
GROUP BY user_id;

请 使用模板方法设计模式实现下面场景：

A：巡查机房各服务器状态是否存在正常/异常

B：巡查班级同学的出勤 远程视频检查

完成后均需提交结果

abstract class InspectionTemplate {
    // 模板方法，定义了巡查的算法框架
    public final void inspect() {
        startInspection(); // 具体步骤1
        checkStatus();     // 具体步骤2
        submitResult();    // 具体步骤3
    }

    // 具体步骤1：开始巡查
    protected abstract void startInspection();

    // 具体步骤2：检查状态
    protected abstract void checkStatus();

    // 具体步骤3：提交结果
    protected abstract void submitResult();
}

class ServerInspection extends InspectionTemplate {
    // 具体实现步骤1：开始巡查服务器
    @Override
    protected void startInspection() {
        System.out.println("开始巡查服务器状态...");
    }

    // 具体实现步骤2：检查服务器状态
    @Override
    protected void checkStatus() {
        System.out.println("检查服务器状态是否正常/异常...");
        // 具体的检查逻辑
    }

    // 具体实现步骤3：提交服务器巡查结果
    @Override
    protected void submitResult() {
        System.out.println("提交服务器巡查结果...");
        // 具体的提交逻辑
    }
}

class ClassAttendanceInspection extends InspectionTemplate {
    // 具体实现步骤1：开始巡查班级出勤
    @Override
    protected void startInspection() {
        System.out.println("开始巡查班级同学的出勤...");
    }

    // 具体实现步骤2：远程视频检查
    @Override
    protected void checkStatus() {
        System.out.println("远程视频检查同学的出勤情况...");
        // 具体的检查逻辑
    }

    // 具体实现步骤3：提交出勤巡查结果
    @Override
    protected void submitResult() {
        System.out.println("提交出勤巡查结果...");
        // 具体的提交逻辑
    }
}

public class TemplateMethodPatternExample {
    public static void main(String[] args) {
        // 巡查服务器状态
        InspectionTemplate serverInspection = new ServerInspection();
        serverInspection.inspect();

        System.out.println();

        // 巡查班级出勤
        InspectionTemplate classAttendanceInspection = new ClassAttendanceInspection();
        classAttendanceInspection.inspect();
    }
}

三数之和

public class threeSum {

    public static void main(String[] args) {
        int[] array = new int[]  {-1, 0, 1, 2, -1, -4};

        for (int i =0 ; i < threesum(array).size(); i++) {
            System.out.println(threesum(array).get(i));
        }
    }
    public static List<List<Integer>> threesum(int[] numbers) {
        // 1、首先对数组进行排序
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        Arrays.sort(numbers);
        // 2、对数据进行遍历
        for (int i = 0; i < numbers.length; i++) {
            // 因为是排好序的数组，所以i的值必须是小于0的
            if (numbers[i] > 0) {
                return result;
            }
            // 跳过重复值
            if(i > 0 && numbers[i-1] == numbers[i]) {
                continue;
            }
            // 设定双指针
            int a = i + 1;
            int b = numbers.length - 1;
            while(a < b) {
                if (numbers[i] + numbers[a] + numbers[b] < 0) {
                    a++;
                }else if (numbers[i] + numbers[a] + numbers[b] > 0) {
                    b--;
                } else {
                    List<Integer> list = new ArrayList<>();
                    list.add(numbers[i]);
                    list.add(numbers[a]);
                    list.add(numbers[b]);
                    result.add(list);

                    while(a < b && numbers[a + 1] == numbers[a]) a++;
                    while(a < b && numbers[b - 1] == numbers[b]) b--;

                    a++;
                    b--;
                }

            }
        }
        return result;
    }
}