02-13 23:20 西安石油大学后端发布于陕西

关注

华勤技术面经汇总

前言

在当今竞争激烈的就业市场中，对于求职者而言，充分了解目标公司以及做好面试准备至关重要。华勤技术股份有限公司作为全球智能硬件平台型企业，在行业内占据重要地位，其招聘的软件开发相关岗位吸引着众多求职者。

本资料整合了华勤技术的公司概况与多场面试面经，详细介绍了公司的发展历程、业务范围、核心优势等信息，让你对公司有全面且深入的认识。同时，面经部分涵盖了Java技术知识、项目经验、个人情况等多方面的面试问题及解答，无论是想了解华勤技术的潜在求职者，还是希望提升Java技术面试能力的开发者，都能从中获取有价值的信息。

阅读指导

快速了解公司：若你想在短时间内对华勤技术有一个整体认知，可直接阅读“公司简介”部分。这里系统介绍了公司从创立到上市的发展历程，各阶段的重要事件和里程碑；详细说明了公司在智能终端、智能穿戴、AIoT等多个领域的业务布局；阐述了研发、供应链管理和服务等方面的核心优势，以及在行业内的市场地位和所获荣誉。通过这部分内容，你能迅速把握公司的基本情况和发展态势。
系统学习面试知识：“面试知识整理”板块聚焦于Java技术相关的面试考点，包含事务类型、索引类型、Java特性、反射和Redis应用等内容。每个知识点都配有详细的解释和示例代码，适合你进行系统的技术学习和巩固。如果你对某个具体知识点有疑问，可通过目录快速定位到相关内容，深入钻研。
针对性准备面试：不同岗位和轮次的面试侧重点有所不同。如果你即将参加华勤暑期实习Java岗的面试，“华勤暑期实习Java岗面经”会是你的重点阅读对象，其中的一面和二面问题及解答，紧密围绕该岗位可能考察的技术和非技术问题展开，能帮助你有针对性地准备。同理，“20220930开发工程师一面面经”“9.20一面”“华勤技术面经”“校招Java岗二面、三面”等部分，分别针对不同岗位和面试轮次，你可根据自身情况进行有针对性的阅读和学习，提前模拟面试场景，提升应对能力。

公司简介

华勤技术股份有限公司是一家全球智能硬件平台型企业，以下将从其发展历程、业务范围、核心优势等维度展开详细介绍：

发展历程
业务范围
核心优势
市场地位
企业荣誉

华勤技术有限公司面试面经整理

1、事务类型(JDBC事务、JTA(Java Transaction APl)事务、容器事务)

2、索引类型（唯一索引、主键索引、联合索引、全文索引）、最左匹配、联合索引

3、java特性

4、反射

5、Redis)应用

6、缓存穿诱、缓存击穿、缓存雪崩

7、JVM

8、redis?实现session

一、事务类型

JDBC事务

try (Connection connection = DriverManager.getConnection(url, user, password)) {
    connection.setAutoCommit(false);
    try (Statement statement = connection.createStatement()) {
        statement.executeUpdate("INSERT INTO table1 (column1) VALUES ('value1')");
        statement.executeUpdate("UPDATE table2 SET column2 = 'new_value' WHERE condition");
        connection.commit();
    } catch (SQLException e) {
        connection.rollback();
        e.printStackTrace();
    }
} catch (SQLException e) {
    e.printStackTrace();
}

JTA（Java Transaction API）事务

import javax.transaction.UserTransaction;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

public class JTATransactionExample {
    public static void main(String[] args) {
        try {
            InitialContext context = new InitialContext();
            UserTransaction userTransaction = (UserTransaction) context.lookup("java:comp/UserTransaction");
            userTransaction.begin();
            // 假设这里有两个不同数据源的操作
            Connection connection1 = DriverManager.getConnection("jdbc:mysql://host1:port1/database1", "user1", "password1");
            Statement statement1 = connection1.createStatement();
            statement1.executeUpdate("INSERT INTO table1 (column1) VALUES ('value1')");
            Connection connection2 = DriverManager.getConnection("jdbc:mysql://host2:port2/database2", "user2", "password2");
            Statement statement2 = connection2.createStatement();
            statement2.executeUpdate("UPDATE table2 SET column2 = 'new_value' WHERE condition");
            userTransaction.commit();
        } catch (NamingException | SQLException | javax.transaction.SystemException e) {
            try {
                // 如果出现异常，回滚事务
                ((UserTransaction) new InitialContext().lookup("java:comp/UserTransaction")).rollback();
            } catch (NamingException | javax.transaction.SystemException ex) {
                ex.printStackTrace();
            }
            e.printStackTrace();
        }
    }
}

容器事务

import javax.ejb.Stateless;
import javax.ejb.TransactionAttribute;
import javax.ejb.TransactionAttributeType;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

@Stateless
public class ContainerTransactionExampleBean {
    @PersistenceContext
    private EntityManager entityManager;

    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public void addEntity() {
        // 这里的操作会在容器管理的事务中执行
        MyEntity entity = new MyEntity();
        entity.setName("New Entity");
        entityManager.persist(entity);
    }
}

二、索引类型

唯一索引

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    email VARCHAR(255) UNIQUE,
    username VARCHAR(255)
);

主键索引

CREATE TABLE products (
    product_id INT AUTO_INCREMENT PRIMARY KEY,
    product_name VARCHAR(255),
    price DECIMAL(10, 2)
);

联合索引

CREATE TABLE orders (
    order_id INT AUTO_INCREMENT PRIMARY KEY,
    customer_id INT,
    order_date DATE,
    CREATE INDEX idx_customer_order_date ON orders (customer_id, order_date);
);

全文索引

SELECT * FROM articles WHERE MATCH(content) AGAINST ('keyword' IN NATURAL LANGUAGE MODE);

最左匹配

SELECT * FROM test_table WHERE a = 1 AND b = 2;

以下查询不能有效利用索引：

SELECT * FROM test_table WHERE b = 2 AND c = 3;

三、Java特性

面向对象特性（封装、继承、多态）

class BankAccount {
    private double balance;
    public double getBalance() {
        return balance;
    }
    public void setBalance(double newBalance) {
        if (newBalance >= 0) {
            balance = newBalance;
        }
    }
}

继承

class Animal {
    public void move() {
        System.out.println("Animal is moving");
    }
}
class Dog extends Animal {
    @Override
    public void move() {
        System.out.println("Dog is running");
    }
}

多态

class Shape {
    public void draw() {
        System.out.println("Drawing a shape");
    }
}
class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}
Shape shape = new Circle();
shape.draw(); // 输出 "Drawing a circle"

Java语言的跨平台性

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

编译后得到HelloWorld.class文件，将这个文件复制到不同的操作系统上，只要有合适的JVM，就可以通过java HelloWorld命令来运行。

四、反射

背景：反射是Java语言的一个高级特性，它允许程序在运行时动态地获取类的信息，包括类的成员（属性、方法、构造函数等），并且可以动态地创建对象、调用方法和访问属性。
细节：
示例：

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

class MyClass {
    private int value;
    public MyClass() {
    }
    public void setValue(int newValue) {
        value = newValue;
    }
    public int getValue() {
        return value;
    }
}
public class ReflectionExample {
    public static void main(String[] args) throws Exception {
        // 获取类对象
        Class<?> clazz = Class.forName("MyClass");
        // 创建对象
        Constructor<?> constructor = clazz.getConstructor();
        MyClass myObject = (MyClass) constructor.newInstance();
        // 调用方法
        Method setValueMethod = clazz.getMethod("setValue", int.class);
        setValueMethod.invoke(myObject, 10);
        Method getValueMethod = clazz.getMethod("getValue");
        int result = (Integer) getValueMethod.invoke(myObject);
        System.out.println("Value: " + result);
        // 访问属性
        Field field = clazz.getDeclaredField("value");
        field.setAccessible(true);
        int fieldValue = field.getInt(myObject);
        System.out.println("Field value: " + fieldValue);
    }
}

五、Redis应用

缓存数据

import redis.clients.jedis.Jedis;
import java.util.HashMap;
import java.util.Map;

class ProductService {
    private Jedis jedis;
    public ProductService() {
        jedis = new Jedis("localhost", 6379);
    }
    public Map<String, String> getProductInfo(int productId) {
        String cacheKey = "product:" + productId;
        Map<String, String> productInfo = jedis.hgetAll(cacheKey);
        if (productInfo.isEmpty()) {
            // 如果缓存中没有，从数据库中读取
            // 假设这里有从数据库读取数据的方法
            productInfo = getProductInfoFromDB(productId);
            // 将数据存入缓存，设置过期时间为1小时（3600秒）
            jedis.hmset(cacheKey, productInfo);
            jedis.expire(cacheKey, 3600);
        }
        return productInfo;
    }
    private Map<String, String> getProductInfoFromDB(int productId) {
        // 模拟从数据库读取数据
        Map<String, String> productInfo = new HashMap<>();
        productInfo.put("name", "Product " + productId);
        productInfo.put("price", "100.00");
        return productInfo;
    }
}

分布式锁

import redis
import time

r = redis.Redis(host='localhost', port=6379)

def acquire_lock(lock_name, acquire_timeout=10):
    end_time = time.time() + acquire_timeout
    while time.time() < end_time:
        if r.setnx(lock_name, "locked"):
            r.exp

华勤—暑期实习

(应用软件开发—Java岗)

6.15 一面 40 min

1、说说你对Linux的了解

2、Linux常用命令

3、有使用过多线程技术吗，说说你对多线程的理解

4、创建线程池的方法

5、线程池的类型有哪些

6、如何破坏、预防死锁

7、为什么要使用单例模式，你是怎么实现单例模式的（提了一下项目里有用到单例模式）

8、单例模式加锁会导致死锁吗，怎么在并发情况下创建单例而不会造成死锁的发生

9、说一下你平时写代码遇到过哪些异常，异常的类型有哪些，非运行时异常下具体有哪些异常，运行时异常下具体有哪些异常

10、说一下你知道的数据结构有哪些

11、如何选择使用hashMap还是hashTable

12.、如何选择使用List类型的集合

13、平时有对自己写的程序进行性能调优吗

14、在学校遇到过什么很困难的问题吗，怎么解决的

15、对其他行业有了解吗？你觉得其他行业目前的发展前景怎么样

16、有没有考虑转安卓方向（因为我简历上写的是Java后端开发）

17、反问

对于现在找实习工作阶段有什么学习建议吗？
请您评价一下我今天的面试情况，有什么需要改进的吗？

1. 说说你对 Linux 的了解

核心功能：阐述Linux是一种开源的操作系统，具备多用户、多任务特性，允许多个用户同时使用系统资源，并且能同时运行多个程序。强调其稳定性和可靠性，常用于服务器领域，为互联网服务提供坚实基础。
应用场景：列举Linux在服务器端的广泛应用，如网站服务器、数据库服务器、邮件服务器等。提及它在嵌入式系统中的应用，如智能家居设备、工业控制等领域，因其开源和可定制性，能够满足不同硬件平台的需求。
与其他系统对比：简要对比Linux与Windows等操作系统，指出Linux在开源性、安全性、命令行操作等方面的特点，突出其在特定场景下的优势。

2. Linux常用命令

文件操作命令：介绍ls（用于列出目录内容）、cd（切换目录）、mkdir（创建目录）、rm（删除文件或目录）、cp（复制文件或目录）、mv（移动或重命名文件或目录）等命令的基本用法和常用参数。
文本处理命令：讲解cat（查看文件内容）、grep（在文件中搜索指定字符串）、sed（文本流编辑器，常用于批量替换文本）、awk（文本处理工具，擅长按字段处理文本）等命令在处理文本文件时的作用和使用方式。
系统管理命令：提及top（实时查看系统进程状态）、ps（查看当前系统进程）、df（查看磁盘空间使用情况）、du（查看目录或文件大小）、chmod（修改文件或目录权限）等命令在系统管理和维护中的重要性。

3. 有使用过多线程技术吗，说说你对多线程的理解

定义与概念：解释多线程是指在一个程序中可以同时运行多个线程，每个线程独立执行不同的任务，它们共享进程的资源，如内存空间、文件描述符等。强调多线程能够提高程序的并发处理能力，充分利用CPU资源。
优势：阐述多线程可以提升程序的响应速度，例如在图形界面应用中，将耗时操作放在单独线程执行，避免主线程阻塞，保证界面的流畅交互。同时，多线程能提高程序的整体性能，特别是在处理大量数据或需要同时处理多个任务的场景下。
挑战：指出多线程编程面临的挑战，如线程安全问题，由于多个线程同时访问共享资源可能导致数据不一致；资源竞争问题，可能出现死锁等情况；以及线程上下文切换带来的开销。

4. 创建线程池的方法

使用 Executors 工具类：介绍Executors类提供的静态方法，如Executors.newFixedThreadPool(int nThreads)创建固定大小的线程池，Executors.newCachedThreadPool()创建可缓存的线程池，Executors.newSingleThreadExecutor()创建单线程线程池等。说明这些方法的参数含义和使用场景。
直接使用 ThreadPoolExecutor 类：讲解通过ThreadPoolExecutor类的构造函数创建线程池的方式，详细介绍构造函数中各个参数的意义，包括核心线程数、最大线程数、存活时间、时间单位、任务队列等。解释如何根据实际需求合理设置这些参数。

5. 线程池的类型有哪些

FixedThreadPool：固定大小的线程池，核心线程数和最大线程数相等。当线程池中的线程都处于忙碌状态时，新任务会被放入任务队列等待处理。适用于任务量比较稳定，且对响应时间有一定要求的场景。
CachedThreadPool：可缓存的线程池，核心线程数为0，最大线程数为Integer.MAX_VALUE。线程池会根据任务的需求动态创建和回收线程，如果线程空闲时间超过60秒，就会被回收。适用于任务量波动较大，且执行时间较短的场景。
SingleThreadExecutor：单线程线程池，只有一个核心线程，所有任务按照顺序依次执行。适用于需要保证任务顺序执行，且不需要并发处理的场景。
ScheduledThreadPool：定时线程池，用于执行定时任务或周期性任务。可以设置任务的延迟执行时间或执行周期。适用于需要定时执行某些任务的场景，如定时数据备份、定时任务调度等。

6. 如何破坏、预防死锁

破坏死锁的四个必要条件：
预防死锁的其他方法：设置合理的超时时间，当线程等待资源超过一定时间后，自动释放已占有的资源并重新尝试获取；使用资源分配图算法，如银行家算法，在每次资源分配前检查是否会导致死锁，确保系统始终处于安全状态。

7. 为什么要使用单例模式，你是怎么实现单例模式的

使用单例模式的原因：强调单例模式确保一个类在系统中只有一个实例，并提供全局访问点。在需要共享资源，如数据库连接池、线程池、日志记录器等场景下，使用单例模式可以避免资源的重复创建和浪费，保证资源的一致性和高效利用。同时，单例模式可以方便地进行全局状态管理，例如在整个应用程序中共享用户登录状态等信息。
实现方式：

public class HungrySingleton {
    private static final HungrySingleton instance = new HungrySingleton();
    private HungrySingleton() {}
    public static HungrySingleton getInstance() {
        return instance;
    }
}

这种方式简单直接，线程安全，但可能会造成资源浪费，因为即使单例实例在整个应用程序中未被使用，也会在类加载时创建。 - 懒汉式单例（线程不安全）：在第一次调用getInstance方法时才创建单例实例。代码示例如下：

public class LazySingleton {
    private static LazySingleton instance;
    private LazySingleton() {}
    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

这种方式延迟了实例的创建，但在多线程环境下不安全，可能会创建多个实例。 - 懒汉式单例（线程安全）：通过双重检查锁（Double-Checked Locking）机制确保线程安全。代码示例如下：

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

这里使用volatile关键字保证了可见性，防止指令重排序导致的线程安全问题。 - 静态内部类单例：利用静态内部类的特性实现线程安全的懒加载。代码示例如下：

public class StaticInnerClassSingleton {
    private StaticInnerClassSingleton() {}
    private static class SingletonHolder {
        private static final StaticInnerClassSingleton instance = new StaticInnerClassSingleton();
    }
    public static StaticInnerClassSingleton getInstance() {
        return SingletonHolder.instance;
    }
}

这种方式既保证了线程安全，又实现了懒加载，且代码简洁。 - 枚举单例：使用枚举类型实现单例模式，这是最简洁且线程安全的方式，同时还能防止反序列化重新创建实例。代码示例如下：

public enum EnumSingleton {
    INSTANCE;
    // 可以在这里添加其他业务方法
}

8. 单例模式加锁会导致死锁吗，怎么在并发情况下创建单例而不会造成死锁的发生

单例模式加锁与死锁关系：解释单例模式中加锁本身不会直接导致死锁，但如果在加锁过程中存在不合理的资源获取顺序或嵌套锁使用不当，可能会引发死锁。例如，在一个单例类中，getInstance方法获取锁后，又调用其他方法获取另一个锁，而其他线程在相反的顺序下获取这两个锁，就可能导致死锁。
避免死锁的方法：

9. 说一下你平时写代码遇到过哪些异常，异常的类型有哪些

异常类型概述：首先介绍Java中的异常分为受检异常（Checked Exception）和非受检异常（Unchecked Exception）。受检异常是编译器要求必须处理的异常，通常表示程序运行环境中可能出现的外部问题，如文件不存在、网络连接失败等；非受检异常包括运行时异常（Runtime Exception）和错误（Error），运行时异常通常是由程序逻辑错误引起的，如空指针异常、数组越界异常等，错误一般表示系统级别的问题，如内存溢出、栈溢出等，应用程序通常无法处理这类错误。
常见异常举例：

String str = null;
int length = str.length(); // 这里会抛出NullPointerException

    - **ArrayIndexOutOfBoundsException**：当数组访问越界时抛出。例如：

int[] arr = new int[5];
int value = arr[5]; // 这里会抛出ArrayIndexOutOfBoundsException，因为数组下标从0到4

    - **ClassCastException**：当进行类型转换时，如果对象的实际类型与目标类型不兼容，就会抛出该异常。例如：

Object obj = new Integer(10);
String str = (String) obj; // 这里会抛出ClassCastException，因为Integer不能转换为String

- **受检异常**：
    - **IOException**：是所有输入输出操作相关异常的父类，例如当读取一个不存在的文件时会抛出`FileNotFoundException`，它是`IOException`的子类。示例代码：

import java.io.FileReader;
import java.io.IOException;

public class IOExceptionExample {
    public static void main(String[] args) {
        try {
            FileReader reader = new FileReader("nonexistentfile.txt");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

    - **SQLException**：在进行数据库操作时，如果出现错误，如SQL语句语法错误、数据库连接失败等，会抛出该异常。例如：

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

public class SQLExceptionExample {
    public static void main(String[] args) {
        try {
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/nonexistentdb", "user", "password");
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

10. 说一下你知道的数据结构有哪些

线性结构：
非线性结构：

11. 如何选择使用 HashMap 还是 Hashtable

线程安全性：强调Hashtable是线程安全的，它的所有方法都被synchronized关键字修饰，适用于多线程环境下需要保证数据一致性的场景。而HashMap是非线程安全的，在单线程环境或多线程环境下使用时，如果需要保证线程安全，需要额外的同步措施，如使用Collections.synchronizedMap方法将其包装成线程安全的映射。
性能：由于Hashtable的方法都进行了同步，在多线程环境下会存在锁竞争，导致性能下降。而HashMap在单线程环境下性能更好，因为它没有同步开销。在多线程环境下，如果对性能要求较高且可以通过其他方式保证线程安全（如使用线程局部变量、分段锁等），则可以考虑使用HashMap。
键值是否允许为 null：说明HashMap的键和值都允许为null，但只能有一个键为null。而Hashtable的键和值都不允许为null，如果试图插入null键或值，会抛出NullPointerException。因此，如果需要存储null键或值，应选择HashMap。

12. 如何选择使用 List 类型的集合

ArrayList：如果需要频繁的随机访问操作，如根据索引获取元素，ArrayList是较好的选择。因为它基于数组实现，元素在内存中连续存储，随机访问时间复杂度为O(1)。但在插入和删除操作（非末尾位置）时，需要移动大量元素，效率较低，时间复杂度为O(n)。适用于数据量相对稳定，且主要操作是读取数据的场景。
LinkedList：当需要频繁的插入和删除操作时，LinkedList更合适。它基于链表实现，插入和删除操作只需修改节点的引用，时间复杂度为O(1)。但随机访问效率低，需要从头遍历链表查找元素，时间复杂度为O(n)。适用于需要频繁进行数据添加和删除的场景，如实现队列、栈等数据结构。
Vector：Vector是线程安全的，类似于ArrayList，但它的所有方法都被synchronized关键字修饰。在多线程环境下，如果需要保证线程安全且对性能要求不是特别高，可以选择Vector。不过由于同步带来的性能开销，在单线程环境下一般不建议使用。

13. 平时有对自己写的程序进行性能调优吗

调优经历概述：若有实际调优经历，先简要介绍项目背景与调优目标。比如在一个处理海量用户数据报表生成的Java应用中，原本程序生成报表耗时长达数分钟，严重影响用户体验，且内存占用持续攀升，因此急需性能优化。
具体调优方法：

14. 在学校遇到过什么很困难的问题吗，怎么解决的

问题描述：选择一个具有代表性的学术或项目问题，如在开发一个校园管理系统时，遇到了数据库事务一致性难以保证的问题。在多用户并发操作数据库时，出现数据更新丢失、脏读等情况，严重影响系统的数据准确性。
解决过程：

15. 对其他行业有了解吗？你觉得其他行业目前的发展前景怎么样

举例行业及分析：

16. 有没有考虑转安卓方向（因为我简历上写的是Java后端开发）

回复思路：如果对安卓方向有兴趣，可以这样回答：表达对安卓开发方向的兴趣由来已久，自己了解到Java在安卓开发中有着广泛应用，且安卓平台丰富的应用场景和庞大的用户群体很有吸引力。虽然目前主要专注于Java后端开发，但已经利用业余时间学习了安卓开发的基础知识，如安卓四大组件、布局管理、界面交互等，并且尝试开发了一些简单的安卓应用，积累了初步的实践经验。未来希望能够在巩固Java后端开发能力的同时，深入学习安卓开发，将前后端技能结合，打造出更完整、用户体验更好的应用。

如果对安卓方向兴趣不大，可以这样回复：首先感谢面试官的提问与关注，表明自己目前对Java后端开发方向充满热情，并且致力于在该领域深入发展。在学习和实践过程中，发现后端开发涉及到系统架构设计、数据库优化、性能调优等多个复杂且具有挑战性的方面，非常吸引自己深入钻研。虽然了解安卓开发也是基于Java语言，但目前更希望将精力集中在后端技术栈的拓展与提升上，为构建稳定、高效的后端服务贡献力量，暂不考虑转向安卓方向。

17. 反问环节

对于现在找实习工作阶段有什么学习建议吗？
请您评价一下我今天的面试情况，有什么需要改进的吗？

6.16 二面（部门总管面） 15 min

1、自我介绍

2、我对你的第二个项目比较感兴趣，简要介绍一下这个项目

3、你在做这个项目的时候遇到了什么问题，如何解决的

4、你对我们这个部门有什么了解吗

5、你对华勤集团有什么了解吗

6、你在学校学习过程中遇到过什么比较困难的问题，如何解决的

7、对自己有什么规划

8、如果给你发offer的话，大概什么时候可以到岗

9、反问

你们部门主要使用的技术栈
如果今天面试过了，后面还有后续的面试吗（我们这边需要进行综合评估，过了后面会有hr联系你）
评价一下我今天的面试，以及面试建议

实习面经（拷打项目）

华勤技术开发工程师一面面经20220930

base 无锡

面试官人很nice

1、自我介绍

2、英语四六级分数

3、介绍项目

4、遇到的困难（我说的非常笼统，面试官让说的详细一些）

5、做完项目收获

6、为什么不做深度学习

7、说一下实习

8、对Java语言的理解（我说了三大特性）

9、常用的集合类以及他们的子类

10、多线程的创建方式

继承 Thread 类创建线程 

实现 Runnable 接口创建线程 

使用 Callable接口

使用线程池例如用 Executor 框架

11、Java内存区域，分别是存放什么的（直接内存）

12、OOM会出现在哪里

13、并发编程的三大特性：原子性、可见性、有序性

14、string,stringbuilder和stringbuffer的区别

15、不同操作系统的调度算法是一样的吗

（不会）

毫无疑问，不同的环境需要不同的调度算法。之所以出现这种情形，是因为不同的应用领域（以及不同的操作系统）有不同的目标。换句话说，在不同的系统中，调度程序的优化是不同的。这里有必要划分出三种环境：

1) 批处理。
2) 交互式。
3) 实时。

批处理系统在商业领域仍在广泛应用，用来处理薪水册、存货清单、账目收入支出、利息计算（在银行）和其他的周期性的作业。在批处理系统中，不会有用户不耐烦地在终端旁等待一个短请求的快捷响应。因此，非抢占式算法，或对每个进程都有长时间周期的抢占式算法，通常都是可接受的。这种处理方式减少了进程的切换从而改善了性能。

在交互式用户环境中，为了避免一个进程霸占CPU拒绝为其他进程服务，抢占是必需的。即便没有进程想永远运行，但是，某个进程由于一个程序错误也可能无限期地排斥所有其他进程。为了避免这种现象发生，抢占也是必要的。服务器也归于此类，因为通常它们要服务多个突发的（远程）用户。

然而在实时系统中，抢占有时是不需要的，因为进程了解它们可能会长时间得不到运行，所以通常很快地完成各自的工作并阻塞。实时系统与交互式系统的差别是，实时系统只运行那些用来推进现有应用的程序，而交互式系统是通用的，它可以运行任意的非协作甚至是有恶意的程序。

16、说一下调度算法和内存管理机制

17、CPU上运行的是进程还是线程

18、进程和线程的区别

19、学校成绩排名

20、优点缺点

反问

作者：棒棒的Feel链接：https://www.nowcoder.com/discuss/405409613804314624?sourceSSR=enterprise来源：牛客网

对Java语言的理解
常用的集合类以及它们的子类
多线程的创建方式

继承Thread类创建线程

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接口创建线程

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("通过Runnable接口实现的线程执行内容");
    }
}
public class Main {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

使用Callable接口

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
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 {
        MyCallable callable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
        System.out.println(futureTask.get());//获取call方法的返回值
    }
}

使用线程池（例如用Executor框架）

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            executorService.execute(() -> {
                System.out.println("线程池中的线程执行任务");
            });
        }
        executorService.shutdown();
    }
}

Java内存区域，分别是存放什么的（包括直接内存）

程序计数器（PC寄存器）：是一块较小的内存空间，它可以看作是当前线程所执行的字节码的行号指示器。在多线程环境下，每个线程都有自己独立的程序计数器，用于记录当前线程执行到的位置，保证线程切换后能恢复到正确的执行位置。
Java虚拟机栈（JVM Stack）：每个线程都有一个独立的虚拟机栈，它是由栈帧组成的。栈帧用于存储局部变量表、操作数栈、动态连接、方法出口等信息。当一个方法被调用时，一个新的栈帧就会被压入栈中；当方法执行完成后，栈帧就会被弹出。例如，一个方法中有局部变量，这些局部变量就存储在栈帧的局部变量表中。
本地方法栈（Native Method Stack）：与Java虚拟机栈类似，但是它是为本地方法（用非Java语言编写的方法，如C或C++编写的方法，通过JNI调用）服务的。当本地方法被调用时，会在本地方法栈中创建栈帧来存储相关信息。
堆（Heap）：是Java虚拟机所管理的内存中最大的一块，它是被所有线程共享的。几乎所有的对象实例和数组都在堆中分配内存。例如，通过new关键字创建的对象都会在堆中分配空间。垃圾回收器主要就是管理堆内存，回收不再使用的对象所占用的空间。
方法区（Method Area）：它是各个线程共享的内存区域，用于存储已被虚拟机加载的类信息（包括类的版本、字段、方法、接口等信息）、常量、静态变量、即时编译器编译后的代码等。例如，一个类的static变量就存储在方法区中。
运行时常量池（Runtime Constant Pool）：是方法区的一部分，它用于存放编译期生成的各种字面量和符号引用。在类加载后，这些字面量和符号引用会被放入运行时常量池中。例如，字符串常量就存储在运行时常量池中，当程序中出现相同的字符串常量时，会直接从常量池中获取，而不是重新创建。
直接内存（Direct Memory）：不是Java虚拟机运行时数据区的一部分，它是在Java堆外的、直接受操作系统管理的内存。NIO（New Input/Output）中的ByteBuffer可以使用直接内存，通过ByteBuffer.allocateDirect()方法来分配直接内存。它可以避免在Java堆和本地堆之间的数据拷贝，提高数据传输的效率，例如在进行网络通信或者文件读写等大数据量的操作时使用。

OOM（内存溢出）会出现在哪里

堆内存溢出（OutOfMemoryError: Java heap space）：当在堆中创建的对象太多，并且这些对象没有被及时回收，导致堆内存不够用时就会出现堆内存溢出。例如，一个程序不断地创建新的对象，并且这些对象的生命周期很长，没有被垃圾回收，就会使堆内存耗尽。常见的场景是在处理大量数据时，如读取一个非常大的文件内容到内存中的对象列表中，如果列表不断增长而不释放空间，就会导致堆溢出。
栈内存溢出（StackOverflowError）：每个线程都有自己的栈空间，当一个方法不断地递归调用自身，并且没有终止条件，栈帧就会不断地压入栈中，最终导致栈内存溢出。例如，下面的代码就会导致栈溢出：

public class Main {
    public static void recursiveMethod() {
        recursiveMethod();
    }
    public static void main(String[] args) {
        recursiveMethod();
    }
}

方法区内存溢出（OutOfMemoryError: PermGen space或OutOfMemoryError: Metaspace）：在Java 8之前是PermGen空间，Java 8之后是Metaspace。当加载的类太多，或者常量池中的常量太多（如大量使用动态代理生成类、加载了大量的第三方库等情况），就会导致方法区内存溢出。例如，一个应用程序使用了很多自定义的类加载器，并且每个类加载器都加载了大量的类，就可能导致方法区内存不足。

并发编程的三大特性：原子性、可见性、有序性

原子性：是指一个操作或者多个操作要么全部执行，要么全部不执行，不会被其他线程干扰。在Java中，i++这样的操作不是原子性的，它实际上包含了读取i的值、加1、再将新值赋给i这三个步骤。可以通过synchronized关键字或者java.util.concurrent.atomic包中的原子类（如AtomicInteger）来保证操作的原子性。例如，AtomicInteger atomicInteger = new AtomicInteger(0); atomicInteger.incrementAndGet();这个操作是原子性的，在多线程环境下可以保证对变量的操作是安全的。
可见性：是指当一个线程修改了共享变量的值，其他线程能够立即看到这个修改后的新值。在Java中，由于每个线程都有自己的工作内存，变量的值可能会被缓存在工作内存中。volatile关键字可以保证变量的可见性。例如，一个volatile变量，当一个线程修改了它的值，这个新值会立即刷新到主内存中，并且其他线程读取这个变量时会从主内存中重新读取，而不是使用自己工作内存中的旧值。
有序性：是指程序执行的顺序按照代码的先后顺序执行。在Java中，为了提高程序的执行效率，编译器和处理器可能会对指令进行重排序。但是在多线程环境下，这种重排序可能会导致程序出现错误。例如，double - checked locking模式如果没有正确处理，就可能因为指令重排序而出现问题。可以通过synchronized关键字或者volatile关键字来保证一定程度的有序性。

string、stringbuilder和stringbuffer的区别

String：是不可变的字符序列。一旦创建，就不能修改它的值。例如，String str = "abc"; str = str + "def";看起来好像是修改了str的值，但实际上是创建了一个新的String对象，原来的str对象并没有改变。因为它的不可变性，所以在多线程环境下是安全的，多个线程同时访问一个String对象不会导致数据不一致。但是频繁地对String进行拼接操作会产生大量的临时对象，影响性能。
StringBuilder：是可变的字符序列，它是非线程安全的。它提供了高效的字符串拼接和修改功能。例如，StringBuilder sb = new StringBuilder(); sb.append("abc"); sb.append("def");可以高效地拼接字符串，不会像String那样每次拼接都创建新对象。在单线程环境下，使用StringBuilder进行字符串操作效率更高。
StringBuffer：也是可变的字符序列，它是线程安全的。它的方法是同步的，例如，在多线程环境下，如果多个线程需要对一个字符序列进行操作，使用StringBuffer可以保证数据的安全性。但是由于它的同步机制，在性能上可能会比StringBuilder稍差一些。

不同操作系统的调度算法是不一样的（前面已经详细阐述）
调度算法和内存管理机制

调度算法
最短作业优先（SJF）：优先选择估计运行时间最短的作业投入运行。这种算法可以使作业的平均周转时间最短。例如，有作业J1（执行时间为4）、J2（执行时间为2）、J3（执行时间为3），按照SJF算法，执行顺序是J2、J3、J1，这样可以减少作业的等待时间，提高系统的吞吐量。不过，它的缺点是长作业可能会出现饥饿现象，即长时间得不到执行。

CPU上运行的是进程还是线程

在现代操作系统中，CPU运行的是线程。进程是资源分配的基本单位，它包含了代码、数据、文件描述符等资源。而线程是CPU调度的基本单位。一个进程可以包含多个线程，这些线程共享进程的资源。例如，一个多线程的浏览器进程，它的多个线程（如页面渲染线程、网络请求线程等）共享进程的内存空间、文件句柄等资源，而CPU在这些线程之间进行调度，让它们轮流执行。线程比进程更轻量级，创建和切换线程的开销比进程小，所以在多任务处理中，通过线程可以更高效地利用CPU资源。

进程和线程的区别

资源分配方面
调度和执行方面
并发性和独立性方面

以下是对这些面试题的详细回答：

1. 自我介绍

自我介绍是面试的开场环节，应该简洁明了地介绍自己的基本情况、教育背景、工作经历（如果有）、专业技能以及个人优势等。例如：“您好，我叫[姓名]，毕业于[学校名称]的[专业名称]。在校期间，我系统学习了电子信息工程相关课程，包括电路原理、数字电路、模拟电路等。我对硬件开发有着浓厚的兴趣，曾参与过[具体项目名称]，在项目中主要负责硬件电路的设计与调试。通过这个项目，我熟练掌握了Altium Designer等电路设计软件的使用，并且能够独立完成从原理图设计到PCB布局布线的整个流程。我的个人优势在于我有较强的问题解决能力和学习能力，能够快速适应新的技术和工作环境。”

2. 英语四六级分数

如实回答自己的英语四六级分数即可。如果分数较高，可以适当提及自己的英语听说读写能力对工作可能带来的帮助，比如能够阅读英文技术文档、与国外供应商或团队进行沟通等。

3. 介绍项目

详细介绍项目可以从以下几个方面入手：

4. 遇到的困难（详细版）

技术难题方面：
团队协作方面：

5. 做完项目收获

技术能力提升：
项目管理能力：
团队协作和沟通能力：

6. 为什么不做深度学习

可以从自己的兴趣和职业规划方面来回答。例如：“我的兴趣主要集中在硬件开发领域，特别是LED硬件方面。我对电路设计、硬件调试等过程非常着迷，享受通过自己的双手将硬件产品从概念变为实物的过程。在职业规划上，我希望能够在硬件工程师这个领域深入发展，积累更多的硬件设计经验，成为一名资深的硬件专家。虽然深度学习是一个非常有前景的领域，但我觉得自己在硬件方面能够发挥更大的价值，并且我目前的知识体系和技能积累也更适合在硬件方向发展。”

7. 说一下实习

同样可以从以下几个方面介绍实习经历：

8. 对Java语言的理解（三大特性）

封装：
继承：
多态：

9. 常用的集合类以及他们的子类

List接口：
Set接口：
Map接口：

10. 多线程的创建方式

继承Thread类：

class LEDThread extends Thread {
    public void run() {
        // 控制LED闪烁的代码
        while (true) {
            // 点亮LED
            System.out.println("LED is on");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 熄灭LED
            System.out.println("LED is off");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Main {
    public static void main(String[] args) {
        LEDThread ledThread = new LEDThread();
        ledThread.start();
    }
}

这种方式的优点是简单直接，适合简单的线程任务。但是，由于Java是单继承的，如果一个类已经继承了其他类，就不能再继承Thread类来创建线程。”

实现Runnable接口：

class LEDRunnable implements Runnable {
    public void run() {
        // 控制LED闪烁的代码，与上面类似
        while (true) {
            System.out.println("LED is on");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("LED is off");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Main {
    public static void main(String[] args) {
        LEDRunnable ledRunnable = new LEDRunnable();
        Thread thread = new Thread(ledRunnable);
        thread.start();
    }
}

这种方式的优点是可以避免单继承的限制，一个类可以实现多个接口，更灵活地实现多线程任务。并且多个线程可以共享同一个Runnable对象，适合多个线程执行相同任务的情况。”

使用Callable和Future接口：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class LEDCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        // 假设这是一个复杂的LED相关计算任务，返回一个整数结果
        int result = 0;
        for (int i = 0; i < 10; i++) {
            // 模拟一些计算，比如计算LED的亮度总和等
            result += i;
        }
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        LEDCallable ledCallable = new LEDCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(ledCallable);
        Thread thread = new Thread(futureTask);
        thread.start();
        try {
            // 获取Callable任务的返回结果
            Integer result = futureTask.get();
            System.out.println("计算结果: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

这种方式适合需要获取线程执行结果的场景，通过Future接口的get方法可以等待线程执行完成并获取其返回值。不过要注意的是，get方法会阻塞当前线程，直到Callable任务执行完成。

11. Java内存区域，分别是存放什么的（包括直接内存）

程序计数器（PC寄存器）：
Java虚拟机栈（JVM Stack）：
本地方法栈（Native Method Stack）：
堆（Heap）：
方法区（Method Area）：
直接内存（Direct Memory）：

12. OOM会出现在哪里

堆内存溢出（Heap OOM）：
栈内存溢出（Stack OOM）：
方法区内存溢出（Metaspace OOM）：
直接内存溢出（Direct Memory OOM）：

13. 并发编程的三大特性：原子性、可见性、有序性

原子性：
可见性：
有序性：

14. string、stringbuilder和stringbuffer的区别

String：
StringBuilder：
StringBuffer：

15. 不同操作系统的调度算法是不一样的吗

不同操作系统的调度算法是不一样的。

批处理操作系统

批处理操作系统的主要目标是提高系统资源的利用率和作业的吞吐量。

分时操作系统

分时操作系统的主要目标是为多个用户提供及时的交互响应。

实时操作系统

实时操作系统主要用于对时间要求非常严格的应用场景，如工业控制、航空航天等领域，当然也包括一些对实时性要求高的LED设备控制场景，如舞台灯光控制等。

https://www.nowcoder.com/feed/main/detail/f56c9f5c692d44fe8dd450a3ac2b29e4

9.20一面（25mins）1：个人信息询问2：自我介绍3：项目介绍（10mins）4：项目中遇到的难点5：对华勤的了解6：有无还未问到的技术7：平时的爱好反问

面经--华勤技术

@snow＇

已于 2022-03-26 10:24:19 修改

阅读量6.5k

点赞数4

分类专栏：面经系列文章标签： java 面试开发语言

版权

面经系列

专栏收录该内容

12 篇文章1 订阅

订阅专栏

一共三面，下面分别介绍每一面的内容和重点。

一面 30min以上

1、介绍项目

2、java多态

3、java字符串的相关方法

4、java线程创建方式，有过哪些应用

5、java集合有哪些，区别和特点

6、文件输出输出IO

7、经常出现的异常

8、数据库存储视频的方式

9、数据库特性：原子性，一致性，隔离性，持久性

隔离级别

10、数据结构--常用的排序方法

具体挑了两个语言描述过程

二面 20min左右

1、项目

2、是否关注行业新方向，新知识

3、如何学习这些新技术

怎样判定自己的学习情况和学习效果

4、在校期间觉得有哪些具有挑战的、收获最大的、最有成就感，体现合作的事情

5、如何选择一个公司，比较看重的是哪些方面

6、地点在上海，考虑无锡吗

三面hr

1、自我介绍

2、工作地点要求

3、是否有offer

4、hr介绍华勤技术的公司规模以及优势

5、介绍薪资待遇以及福利

结果：发了offer，两天内回复，薪资不是特别理想，也是因为有了其他薪资待遇好一点的offer，就拒了

总结：面试体验非常好，流程很快，一面当天面试官打电话联系我晚上总监面，次周三面谈薪资，目前第二快的，整个流程一周之内，是求职者喜欢的公司类型，但拒的也最快（对不起）。三个面试官都比较好，推荐去无锡研发中心，作为应届生的我，在上海会遭受社会的毒打的，在我还是决定去上海后，hr姐姐还给我介绍上海租房价格等等，非常感谢。

————————————————

原文链接：https://blog.csdn.net/qq_44641527/article/details/121216907

华勤技术校招Java岗二面、三面(已OC)

华勤 3.17 14:00 二面

学习成绩
项目是个人还是公司完成的
介绍一下项目经历
项目中的Redis是做什么的，知道Redis的部署模式吗，知道哨兵模式吗
IOC控制反转的原理是什么
六级分数
大学四年最有成就感的一件事
平时喜欢看什么书
了解设计模式吗？知道代理模式吗
最近在学什么东西
元宇宙了解吗
有没有压力特别大的时候？怎么解决的
在大学有没有参加过社团或者当过班干部
简历里写到了解hadoop，对hadoop的理解
如何了解华勤，为什么要应聘华勤
大学里对你帮助最大的人
大学里帮助别人的事
项目中如何处理有分歧的情况
你觉得你的缺点是什么
你觉得你的优点是什么
大学里受委屈的事
找工作看重哪些方面
有没有做过什么领导工作
在大学有没有与人起过冲突，意见分歧很严重的时候

华勤 3.18 9:50 三面

主要是聊天了。

总的来说公司的企业文化很吓人，有兴趣的可以百度看看，但还是先签了一个保底。

作者：武神酱丶链接：https://www.nowcoder.com/discuss/353159368654921728来源：牛客网

学习成绩：如实介绍自己大学期间的综合成绩情况，比如专业排名、绩点等，如果成绩较为突出，可以列举获得的奖学金、荣誉称号等加以佐证；若成绩一般，可强调自己在与Java相关课程（如Java程序设计、数据结构与算法等）上的良好表现，以及通过自学弥补成绩不足、提升专业能力的经历。
项目是个人还是公司完成的：明确说明项目是个人独立完成，还是在公司实习、参与公司项目时完成的。如果是个人项目，阐述项目发起的原因、遇到的挑战及如何解决；如果是公司项目，介绍自己在团队中的角色、承担的任务和做出的贡献。
介绍一下项目经历：按照项目背景、目标、技术选型、实现过程、个人负责模块、项目成果与收获的逻辑进行介绍。例如：“在[项目名称]中，为了解决[业务问题]，我们团队决定开发[项目功能描述]的系统。我负责[具体功能模块，如用户认证与授权模块]，采用了Spring Boot框架搭建后端服务，MySQL存储数据，前端使用Vue.js。在开发过程中，遇到了[如分布式事务一致性问题]，通过[具体解决方法，如引入Seata框架]解决。项目上线后，实现了[具体成果，如用户注册量提升、系统响应时间缩短等]，我也在其中提升了技术能力和团队协作能力。”
项目中的Redis是做什么的，知道Redis的部署模式吗，知道哨兵模式吗
IOC控制反转的原理是什么：IOC（Inversion of Control）控制反转是一种设计思想，将对象的创建和管理从应用程序代码转移到外部容器（如Spring容器）。以Spring框架为例，通过配置文件（XML或注解）定义对象及其依赖关系，容器负责创建对象实例，并按照配置注入依赖。当应用程序需要使用某个对象时，直接从容器中获取，而不是在代码中自行创建，实现了对象控制权的反转，降低了代码耦合度，提高了可维护性和可扩展性。
六级分数：如实告知自己的六级考试分数，如果分数较高（如500分以上），可以强调自己的英语读写和听说能力，对阅读英文技术文档、参与国际技术交流的帮助；若分数较低，可说明自己通过其他方式（如参加英语技术社区、阅读英文技术博客等）提升英语技术水平的情况。
大学四年最有成就感的一件事：选择一件具有代表性的事情，如带领团队获得竞赛奖项、成功完成一个复杂的项目、克服困难通过专业考试等。详细描述事情的背景、遇到的困难、自己采取的行动和最终取得的成果，突出自己在其中展现的能力（如领导能力、解决问题能力、坚持不懈的精神等）和收获。
平时喜欢看什么书：如果有阅读技术书籍的习惯，列举与Java开发、设计模式、数据库等相关的书籍，如《Effective Java》《设计模式之美》《高性能MySQL》等，并分享从书中获得的知识和启发；若喜欢阅读其他类型书籍，如励志、历史、文学类，可强调阅读对自己思维方式、沟通能力、文化素养的提升，与工作能力培养的间接联系。
了解设计模式吗？知道代理模式吗：表明自己对设计模式的了解程度，设计模式是在软件开发过程中针对反复出现问题总结出的通用解决方案，能提高软件的可维护性、可扩展性和可复用性。代理模式是一种结构型设计模式，分为静态代理和动态代理。静态代理是代理类和目标类实现相同接口，代理类在内部调用目标类方法，并可在前后添加额外逻辑；动态代理则是在运行时动态生成代理类，通过反射机制调用目标类方法，常见的有JDK动态代理和CGLIB代理。在项目中，代理模式可用于实现权限控制、日志记录、缓存等功能。
最近在学什么东西：介绍最近学习的与Java开发相关的新知识、新技术，如学习新的框架（如Spring Cloud Alibaba）、研究新的算法（如深度学习相关算法在Java中的应用）、探索新的开发工具（如IntelliJ IDEA的高级插件使用）等，说明学习的原因和预期收获，展现自己的学习积极性和对技术的追求。
元宇宙了解吗：简单介绍元宇宙的概念，它是整合多种新技术（如虚拟现实VR、增强现实AR、区块链、人工智能AI等）产生的新型虚实相融的互联网应用和社会形态，提供沉浸式体验。结合自身理解阐述元宇宙与Java开发的潜在联系，如Java可用于开发元宇宙相关的后端服务、分布式系统，或参与构建元宇宙中的虚拟场景交互逻辑等，展示自己对新兴技术的关注和思考。
有没有压力特别大的时候？怎么解决的：分享一个压力大的具体场景，如临近项目交付期限但功能还未完成、面临多门考试同时复习等。重点讲述解决压力的方法，如通过运动（跑步、健身等）释放压力，调整心态和身体状态；合理规划时间，制定详细任务清单，按优先级完成任务，减少焦虑；向同学、老师或朋友倾诉，获取建议和情感支持等。
在大学有没有参加过社团或者当过班干部：如果参加过社团，介绍社团名称、担任的角色（如社团干部负责组织活动，普通成员参与社团项目）和参与的重要活动，强调在社团中锻炼的沟通能力、组织能力、团队协作能力等；若当过班干部，讲述担任的职务（如班长、学习委员等）和履行的职责，以及对班级做出的贡献，如组织班级活动、帮助同学解决学习问题等。
简历里写到了解hadoop，对hadoop的理解：Hadoop是一个开源的分布式计算平台，主要由HDFS（分布式文件系统）、MapReduce（分布式计算框架）和YARN（资源管理系统）组成。HDFS用于存储海量数据，将数据分块存储在多个节点上，提供高可靠性和高扩展性；MapReduce负责处理分布式计算任务，将复杂任务分解为Map和Reduce两个阶段，实现并行计算；YARN管理集群资源，为不同应用程序分配计算资源。在大数据场景下，Hadoop可处理大规模数据的存储、分析和处理，如电商的用户行为分析、日志处理等。
如何了解华勤，为什么要应聘华勤：可以说通过校园宣讲会、网络搜索、学长学姐介绍等途径了解到华勤，华勤在行业内的知名度、技术实力和发展前景吸引自己。应聘华勤是因为公司提供的Java开发岗位与自己的专业技能和职业规划相匹配，希望能在华勤的项目中提升技术能力，接触前沿技术，并且华勤的企业文化（即使提到“吓人”，也可从积极角度解读，如强调拼搏、创新等）能激励自己成长，获得更好的职业发展。
大学里对你帮助最大的人：描述这个人是谁（老师、同学、朋友等），讲述他在学习、生活或项目中给予的具体帮助，如老师在专业课程上的耐心指导、同学在项目中帮助解决技术难题等，强调从这个人身上学到的知识、技能或品质，以及对自己成长的重要影响。
大学里帮助别人的事：分享一件帮助他人的经历，如帮助同学解决学习上的难题（如辅导Java编程作业）、协助社团成员完成活动策划等。说明事情的起因、自己采取的帮助方式和最终达到的效果，体现自己乐于助人、团队协作的品质。
项目中如何处理有分歧的情况：表明在项目中遇到分歧很正常，首先会保持冷静，认真倾听对方的观点和理由，确保自己充分理解对方想法。然后客观分析双方观点，从项目目标、技术可行性、时间成本等方面进行讨论。如果无法当场达成一致，会收集更多资料或咨询团队中经验丰富的成员，寻求更合理的解决方案。最终以项目整体利益为重，选择最优方案，并在实施过程中持续关注效果，及时调整。
你觉得你的缺点是什么：选择一个真实但并非致命的缺点，如在面对紧急任务时有时会过于急躁，导致细节处理不够完善；在技术选型时可能会过于追求新技术，忽略了项目的稳定性和团队的技术储备等。重点阐述针对这个缺点采取的改进措施，如通过制定任务清单、深呼吸等方式控制情绪，提高任务处理质量；在技术选型前进行充分的调研和评估，结合项目实际情况选择合适的技术。
你觉得你的优点是什么：结合Java开发岗位需求，突出自己的优点，如学习能力强，能够快速掌握新的Java技术框架并应用到项目中；代码规范意识好，编写的代码结构清晰、易于维护；具备良好的问题解决能力，在项目中遇到技术难题时能通过查阅资料、调试代码等方式快速解决；有较强的团队协作精神，能与团队成员有效沟通，共同推进项目进展。
大学里受委屈的事：讲述一件受委屈的经历，如在团队项目中付出很多却被误解或功劳被忽视。重点强调自己处理这件事的态度和方式，如没有选择当场争辩，而是在事后找合适的时机与相关人员沟通，澄清事实；通过这件事学会了如何更好地表达自己的想法和成果，以及如何在团队中处理复杂的人际关系。
找工作看重哪些方面：可以从以下几个方面回答，如职业发展空间，希望公司有完善的培训体系和晋升机制，能让自己不断提升技术能力和职业素养；工作内容与兴趣匹配度，对Java开发相关的项目和技术有浓厚兴趣，希望能在工作中深入研究和实践；公司平台实力，一个有技术实力、行业影响力的公司能提供更好的资源和机会；薪资福利，合理的薪资和完善的福利（如五险一金、带薪年假、节日福利等）是生活的保障；团队氛围，积极向上、团结协作的团队氛围能提高工作效率和工作体验。
有没有做过什么领导工作：如果有担任领导角色的经历，如项目组长、社团负责人等，介绍负责的项目或活动情况，阐述在领导过程中制定的目标、采取的管理方法（如任务分配、进度跟踪、激励团队成员等），以及取得的成果，突出领导能力、组织协调能力和决策能力；若没有，可说明自己虽然没有正式领导职务，但在团队合作中经常发挥积极推动作用，如主动承担重要任务、协调团队成员关系等。
在大学有没有与人起过冲突，意见分歧很严重的时候：分享一次与他人意见分歧严重的经历，如在小组作业中对项目方案存在不同看法。详细描述冲突的起因、双方观点的差异，以及自己如何处理。可以说先冷静下来，避免情绪化争吵，尝试从对方角度理解问题，通过摆事实、讲道理的方式进行沟通，最终达成共识或找到折中的解决方案，强调从这次经历中学会了如何更好地处理人际关系和团队协作中的矛盾。