【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 你的服务器被攻击了，黑客把他的程序伪装成服务器上正常的工具程序，如何找到这些程序，请说出你的思路
当服务器受到攻击并且恶意程序伪装成正常的工具程序时，检测和清除这些威胁是一项挑战。以下是一些检测恶意程序的常用方法和思路：
-
日志审查：
- 检查系统和应用日志以寻找异常活动或未授权的访问记录。
-
文件完整性检查器：
- 使用如Tripwire或AIDE这样的工具来检查系统文件的完整性。这些工具可以检测到文件的任何未授权更改。
-
进程监视：
- 使用
ps,top, 或htop等工具来查看正在运行的进程，寻找异常或未知的进程。 netstat或ss可以用来查看当前的网络连接，以确定是否有异常的外部连接。
- 使用
-
系统基线：
- 如果你有一个系统基线（一个已知的干净、正常的系统状态快照），可以将当前状态与此基线进行比较，找出差异。
-
Rootkit检测工具：
- 使用如Rkhunter或Chkrootkit这样的工具来检测是否有rootkits存在。
-
外部扫描：
- 使用外部系统对你的服务器进行扫描，以确定是否有任何已知的恶意活动或开放的漏洞。
-
定期更新和打补丁：
- 确保系统和所有应用程序都是最新的，以减少已知漏洞。
-
网络流量分析：
- 使用网络监控工具（如Wireshark）来捕获和分析流量，寻找异常模式或恶意活动。
-
文件系统审计：
- 定期检查最近修改或新创建的文件，特别是在关键目录中。
-
反病毒和反恶意软件扫描：
- 使用反病毒软件来扫描可能的恶意文件或程序。
- 沙盒技术：
- 在隔离的环境中执行可疑的程序或文件，以观察其行为。
最后，如果你认为服务器已经被感染或渗透，最安全的做法是从已知的干净备份中恢复，并对系统进行全面审计，以确定攻击的来源和范围，并修复任何潜在的安全漏洞。
5 写一个匹配url的正则表达式
匹配URL的正则表达式可以有很多种，根据所需匹配的URL的类型和复杂性。下面是一个常用的，能匹配大部分常见URL的正则表达式：
^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$
解释：
^: 开始。(https?:\/\/)?: 可选的匹配 http:// 或 https://。([\da-z\.-]+): 匹配域名标签（如 “google” 在 “google.com”）。\.([a-z\.]{2,6}): 匹配顶级域名（如 “.com”, “.org.cn”）。([\/\w \.-]*)*\/?: 匹配路径、文件名和查询参数。$$: 结束。
请注意，这个正则表达式能匹配大部分常见的URL，但对于某些特定情况或特殊的URL可能需要调整或完善。正则表达式可以根据具体需求进行修改或扩展。
6 说一下对象锁和类锁的区别
在Java的多线程编程中，对象锁和类锁是两种常见的同步机制。它们的区别主要如下：
-
锁的对象不同：
- 对象锁：是对一个实例对象进行加锁。这通常是通过
synchronized关键字在实例方法上实现的，或者通过synchronized(this)在代码块上实现。 - 类锁：是对一个类的所有对象实例进行加锁。这通常是通过
synchronized关键字在静态方法上实现的，或者通过synchronized(ClassName.class)在代码块上实现。
- 对象锁：是对一个实例对象进行加锁。这通常是通过
-
作用范围不同：
- 对象锁：只影响对该对象实例的访问。即，同一时刻，其他线程仍然可以访问该类的其他实例对象。
- 类锁：影响对该类的所有对象实例的访问。即，同一时刻，其他线程不能访问该类的任何实例。
-
使用场景不同：
- 对象锁：当需要控制对单个对象实例的访问时使用。
- 类锁：当需要控制对类的所有实例的访问或对静态资源的访问时使用。
-
实现方式不同：
- 对象锁：通常通过以下方式实现：
synchronized修饰非静态方法。synchronized(this)修饰代码块。
- 类锁：通常通过以下方式实现：
synchronized修饰静态方法。synchronized(ClassName.class)修饰代码块。
- 对象锁：通常通过以下方式实现：
-
存储位置：
- 对象锁：存在于对象的头部。
- 类锁：存在于类的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);
}
}
}
}
此程序将每个整数转换为字符串，并检查它是否包含数字5。如果不包含5，它就会输出该整数。
8 如何理解aop，是否有编写自定义注解的经验，文字描述一下实现过程
理解AOP
AOP（面向切面编程 - Aspect Oriented Programming）是一个编程范式，其目标是解决软件设计中的交叉关注点，即那些分布在多个模块中的功能（如日志、事务管理、安全性等）。AOP使得这些功能可以被模块化，并能在不修改核心逻辑的情况下被应用到代码的不同部分。
关于编写自定义注解：
Java中的注解是一种元数据形式，它们不直接影响代码的逻辑，但可以通过反射被读取，并为工具和库提供额外的信息。
实现一个使用自定义注解和AOP的例子：
- 定义注解：
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LogExecutionTime {
}
这是一个简单的注解，可以应用于方法上，以记录方法的执行时间。
- 编写切面：
使用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;
}
}
- 使用注解：
应用 @LogExecutionTime 注解于任何你想记录执行时间的方法上：
@Service
public class SomeService {
@LogExecutionTime
public void serve() throws InterruptedException {
Thread.sleep(2000);
}
}
- 配置AOP：
如果你使用的是Spring Boot，只需在pom.xml文件中添加Spring AOP的依赖，并在应用主类上使用@EnableAspectJAutoProxy注解。
总结：
通过结合自定义注解和AOP，你可以轻松地为应用添加跨多个模块的功能，而无需修改核心业务逻辑。这增强了代码的可维护性和可重用性。
9 spring bean如何保持线程安全，为什么
在Spring框架中，Bean的线程安全性主要取决于其作用域和你如何使用这些Bean。下面是关于Spring Bean线程安全性的几点考虑：
-
默认的Bean作用域 - 单例（Singleton）：
- 当Bean的作用域为单例时，Spring容器在启动时只为该Bean创建一个实例，并为所有对该Bean的请求返回相同的实例。这意味着，如果Bean的状态在多线程环境中被多个线程共享，那么这个Bean是线程不安全的。
- 为了确保单例Bean的线程安全性，你应该避免在Bean中使用任何共享状态（例如，成员变量）或确保对共享状态的访问是线程安全的（例如，通过同步）。
-
原型（Prototype）作用域：
- 当Bean的作用域为原型时，Spring容器每次请求时都会创建一个新的Bean实例。因此，Bean的状态不会被多个线程共享，但这并不保证Bean引用的其他对象是线程安全的。
-
请求（Request）和会话（Session）作用域：
- 这些是专为web应用设计的作用域。请求作用域为每个HTTP请求创建一个新的Bean，而会话作用域为每个HTTP会话创建一个Bean。
- 这些Bean本身不会被多个线程共享，但与单例Bean的交互可能仍需要线程安全性的考虑。
-
最佳实践：
- 无状态Bean：确保Bean是无状态的，即不包含任何会被多线程共享的成员变量，是保持线程安全性的最佳实践。
- 同步：如果必须使用有状态的单例Bean，确保对共享资源的访问是同步的。
- 使用线程局部变量：为每个线程存储其自己的状态。
-
为什么：
- 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;
}
}
此代码首先创建一个固定大小的线程池，然后提交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);
}
}
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();
}
}
}
在这个示例中，我们首先创建了一个泛型为Integer的ArrayList。然后，我们使用反射获取add方法，该方法的参数类型为Object。这允许我们调用该方法并传入一个String对象。
需要注意的是，这种操作会破坏泛型的类型安全性，因此在实际应用中应谨慎使用。