【2024秋招】2023-10-9 同花顺后端笔试题

1 Hashmap mp = new hashmap（50）的大小扩充了几次

初时应该就给了这么多空间，在不考虑添加元素，所以扩容为0次

2 算数表达式的中缀为a+b*c-d/e，后缀为abc*+de/-，前缀是？

3 50M电信带宽，计算下带宽理论最快下载速度是多少

带宽通常以"比特/秒"（如Mbps，即百万比特每秒）为单位表示，而文件或数据的大小通常以"字节"为单位表示（如MB，即兆字节）。要注意，1字节等于8比特。

假设你的50M电信带宽是50Mbps（50兆比特每秒）。

理论最快下载速度 = 带宽 / 8

= 50 Mbps / 8
= 6.25 MB/s

因此，理论上，你的下载速度最快可以达到6.25 MB/s。

4 你的服务器被攻击了，黑客把他的程序伪装成服务器上正常的工具程序，如何找到这些程序，请说出你的思路

当服务器受到攻击并且恶意程序伪装成正常的工具程序时，检测和清除这些威胁是一项挑战。以下是一些检测恶意程序的常用方法和思路：

1. 日志审查：

   • 检查系统和应用日志以寻找异常活动或未授权的访问记录。

2. 文件完整性检查器：

   • 使用如Tripwire或AIDE这样的工具来检查系统文件的完整性。这些工具可以检测到文件的任何未授权更改。

3. 进程监视：

   • 使用ps, top, 或htop等工具来查看正在运行的进程，寻找异常或未知的进程。
   • netstat 或 ss 可以用来查看当前的网络连接，以确定是否有异常的外部连接。

4. 系统基线：

   • 如果你有一个系统基线（一个已知的干净、正常的系统状态快照），可以将当前状态与此基线进行比较，找出差异。

5. Rootkit检测工具：

   • 使用如Rkhunter或Chkrootkit这样的工具来检测是否有rootkits存在。

6. 外部扫描：

   • 使用外部系统对你的服务器进行扫描，以确定是否有任何已知的恶意活动或开放的漏洞。

7. 定期更新和打补丁：

   • 确保系统和所有应用程序都是最新的，以减少已知漏洞。

8. 网络流量分析：

   • 使用网络监控工具（如Wireshark）来捕获和分析流量，寻找异常模式或恶意活动。

9. 文件系统审计：

   • 定期检查最近修改或新创建的文件，特别是在关键目录中。

10. 反病毒和反恶意软件扫描：

• 使用反病毒软件来扫描可能的恶意文件或程序。

1. 沙盒技术：

• 在隔离的环境中执行可疑的程序或文件，以观察其行为。

最后，如果你认为服务器已经被感染或渗透，最安全的做法是从已知的干净备份中恢复，并对系统进行全面审计，以确定攻击的来源和范围，并修复任何潜在的安全漏洞。

5 写一个匹配url的正则表达式

匹配URL的正则表达式可以有很多种，根据所需匹配的URL的类型和复杂性。下面是一个常用的，能匹配大部分常见URL的正则表达式：

^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$
1

解释：

• ^: 开始。
• (https?:\/\/)?: 可选的匹配 http:// 或 https://。
• ([\da-z\.-]+): 匹配域名标签（如 “google” 在 “google.com”）。
• \.([a-z\.]{2,6}): 匹配顶级域名（如 “.com”, “.org.cn”）。
• ([\/\w \.-]*)*\/?: 匹配路径、文件名和查询参数。
• $$: 结束。

请注意，这个正则表达式能匹配大部分常见的URL，但对于某些特定情况或特殊的URL可能需要调整或完善。正则表达式可以根据具体需求进行修改或扩展。

6 说一下对象锁和类锁的区别

在Java的多线程编程中，对象锁和类锁是两种常见的同步机制。它们的区别主要如下：

1. 锁的对象不同：

   • 对象锁：是对一个实例对象进行加锁。这通常是通过synchronized关键字在实例方法上实现的，或者通过synchronized(this)在代码块上实现。
   • 类锁：是对一个类的所有对象实例进行加锁。这通常是通过synchronized关键字在静态方法上实现的，或者通过synchronized(ClassName.class)在代码块上实现。

2. 作用范围不同：

   • 对象锁：只影响对该对象实例的访问。即，同一时刻，其他线程仍然可以访问该类的其他实例对象。
   • 类锁：影响对该类的所有对象实例的访问。即，同一时刻，其他线程不能访问该类的任何实例。

3. 使用场景不同：

   • 对象锁：当需要控制对单个对象实例的访问时使用。
   • 类锁：当需要控制对类的所有实例的访问或对静态资源的访问时使用。

4. 实现方式不同：

   • 对象锁：通常通过以下方式实现：
     • synchronized 修饰非静态方法。
     • synchronized(this) 修饰代码块。
   • 类锁：通常通过以下方式实现：
     • synchronized 修饰静态方法。
     • synchronized(ClassName.class) 修饰代码块。

5. 存储位置：

   • 对象锁：存在于对象的头部。
   • 类锁：存在于类的Class对象的头部。

总的来说，对象锁和类锁是Java中的两种同步机制，但它们的作用范围和使用场景是不同的。选择哪种类型的锁应该基于实际的同步需求来决定。

7 用java实现输出1到999中所有不包含5的整数

以下是一个简单的Java程序，用于输出1到999之间所有不包含数字5的整数：

public class NoFiveNumbers {
    public static void main(String[] args) {
        for (int i = 1; i <= 999; i++) {
            if (!Integer.toString(i).contains("5")) {
                System.out.println(i);
            }
        }
    }
}
1
2
3
4
5
6
7
8
9

此程序将每个整数转换为字符串，并检查它是否包含数字5。如果不包含5，它就会输出该整数。

8 如何理解aop，是否有编写自定义注解的经验，文字描述一下实现过程

理解AOP

AOP（面向切面编程 - Aspect Oriented Programming）是一个编程范式，其目标是解决软件设计中的交叉关注点，即那些分布在多个模块中的功能（如日志、事务管理、安全性等）。AOP使得这些功能可以被模块化，并能在不修改核心逻辑的情况下被应用到代码的不同部分。

关于编写自定义注解：

Java中的注解是一种元数据形式，它们不直接影响代码的逻辑，但可以通过反射被读取，并为工具和库提供额外的信息。

实现一个使用自定义注解和AOP的例子：

1. 定义注解：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LogExecutionTime {
}
1
2
3
4

这是一个简单的注解，可以应用于方法上，以记录方法的执行时间。

1. 编写切面：

使用Spring AOP，我们可以定义一个切面，当调用带有 @LogExecutionTime 注解的方法时，记录其执行时间。

@Aspect
@Component
public class LogExecutionAspect {

    @Around("@annotation(LogExecutionTime)")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        
        Object proceed = joinPoint.proceed();

        long executionTime = System.currentTimeMillis() - start;

        System.out.println(joinPoint.getSignature() + " executed in " + executionTime + "ms");
        return proceed;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1. 使用注解：

应用 @LogExecutionTime 注解于任何你想记录执行时间的方法上：

@Service
public class SomeService {

    @LogExecutionTime
    public void serve() throws InterruptedException {
        Thread.sleep(2000);
    }
}
1
2
3
4
5
6
7
8

1. 配置AOP：

如果你使用的是Spring Boot，只需在pom.xml文件中添加Spring AOP的依赖，并在应用主类上使用@EnableAspectJAutoProxy注解。

总结：

通过结合自定义注解和AOP，你可以轻松地为应用添加跨多个模块的功能，而无需修改核心业务逻辑。这增强了代码的可维护性和可重用性。

9 spring bean如何保持线程安全，为什么

在Spring框架中，Bean的线程安全性主要取决于其作用域和你如何使用这些Bean。下面是关于Spring Bean线程安全性的几点考虑：

1. 默认的Bean作用域 - 单例（Singleton）：

   • 当Bean的作用域为单例时，Spring容器在启动时只为该Bean创建一个实例，并为所有对该Bean的请求返回相同的实例。这意味着，如果Bean的状态在多线程环境中被多个线程共享，那么这个Bean是线程不安全的。
   • 为了确保单例Bean的线程安全性，你应该避免在Bean中使用任何共享状态（例如，成员变量）或确保对共享状态的访问是线程安全的（例如，通过同步）。

2. 原型（Prototype）作用域：

   • 当Bean的作用域为原型时，Spring容器每次请求时都会创建一个新的Bean实例。因此，Bean的状态不会被多个线程共享，但这并不保证Bean引用的其他对象是线程安全的。

3. 请求（Request）和会话（Session）作用域：

   • 这些是专为web应用设计的作用域。请求作用域为每个HTTP请求创建一个新的Bean，而会话作用域为每个HTTP会话创建一个Bean。
   • 这些Bean本身不会被多个线程共享，但与单例Bean的交互可能仍需要线程安全性的考虑。

4. 最佳实践：

   • 无状态Bean：确保Bean是无状态的，即不包含任何会被多线程共享的成员变量，是保持线程安全性的最佳实践。
   • 同步：如果必须使用有状态的单例Bean，确保对共享资源的访问是同步的。
   • 使用线程局部变量：为每个线程存储其自己的状态。

5. 为什么：

   • Spring的设计选择，特别是默认的单例作用域，基于性能和内存使用的考虑。频繁地创建和销毁Bean实例会增加系统的开销。
   • 线程安全性是一个复杂的问题，而Spring选择提供灵活性，让开发者决定如何处理它，而不是强制一种特定的方式。

总的来说，保持Spring Bean线程安全主要是开发者的责任。选择合适的Bean作用域，并遵循线程安全的最佳实践，是确保应用线程安全性的关键。

10 创建5个线程，内核线程做2w次累加，最终输出5个线程的累加和

10.1 方法一：使用线程池

为了创建5个线程，并使每个线程内核进行2万次累加，你可以使用Java的Thread类或ExecutorService。下面是一个简单的示例，展示了如何使用ExecutorService来完成这个任务：

import java.util.concurrent.*;

public class ThreadSum {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        List<Future<Integer>> futures = new ArrayList<>();

        // 为每个线程提交一个任务
        for (int i = 0; i < 5; i++) {
            futures.add(executor.submit(new SumTask()));
        }

        // 获取每个线程的结果并累加
        int totalSum = 0;
        for (Future<Integer> future : futures) {
            totalSum += future.get();
        }

        System.out.println("Total sum: " + totalSum);

        executor.shutdown();
    }
}

class SumTask implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 20000; i++) {
            sum += i;
        }
        return sum;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

此代码首先创建一个固定大小的线程池，然后提交5个任务到线程池。每个任务都会进行2万次的累加。最后，主线程等待所有任务完成，并累加每个任务的结果以得到最终总和。

注意：为了简化示例，这里直接使用了future.get()来获取每个任务的结果。在实际应用中，你可能需要考虑其他方法来有效地处理这些结果，特别是在大规模并发环境下。

10.2 使用CompletableFuture

public static void main(String[] args) throws InterruptedException, ExecutionException{

    List>list=new ArrayList<>();

    for (int i = 0; i < 5; i++) {
        list.add(CompletableFuture.supplyAsync(()->{
            Integer sum=0;
            for (int j = 0; j < 2000; j++) {
                sum+=1;
            }
            return sum;
        }));
    }
    int s=0;
    for (Futuref:list){
        s+=f.get();
    }
    System.out.println("s:"+s);

}

import java.util.*;
import java.util.concurrent.*;
import java.util.stream.Collectors;

public class CompletableFutureSum {

    public static void main(String[] args) {
        List> futures = new ArrayList<>();

        // 为每个线程提交一个任务
        for (int i = 0; i < 5; i++) {
            futures.add(CompletableFuture.supplyAsync(() -> {
                int sum = 0;
                for (int j = 0; j < 20000; j++) {
                    sum += j;
                }
                return sum;
            }));
        }

        // 获取每个线程的结果并累加
        int totalSum = futures.stream()
            .map(CompletableFuture::join)
            .mapToInt(Integer::intValue)
            .sum();

        System.out.println("Total sum: " + totalSum);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

11 现有集合Arraylist list =new ArrayLIst，利用反射机制在这个泛型为integer的list中存放一个string对象

利用Java的反射机制，你可以绕过泛型的类型检查，从而在一个设计为存储特定类型元素的ArrayList中存放其他类型的元素。以下是一个示例，展示如何在一个泛型为Integer的ArrayList中存放一个String对象：

import java.lang.reflect.Method;
import java.util.ArrayList;

public class ReflectionList {

    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();

        try {
            Method addMethod = list.getClass().getMethod("add", Object.class);
            addMethod.invoke(list, "This is a string");

            System.out.println(list.get(0));  // 输出: This is a string
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在这个示例中，我们首先创建了一个泛型为Integer的ArrayList。然后，我们使用反射获取add方法，该方法的参数类型为Object。这允许我们调用该方法并传入一个String对象。

需要注意的是，这种操作会破坏泛型的类型安全性，因此在实际应用中应谨慎使用。