上海华为OD--JAVA面试总结

我是2021年6月21日收到华为OD的机试邀请，华为OD机试第一次做很难，我在2019年的时候第一次接触这个机试，三道题一题不会，要想通过，前期不去LeetCode上刷题那是不可能的，好在这次面试有个华为的人事全程对接，可能是od那边真的很缺人，他们急迫想招人进去，然后给了一份常考机试题的答案给我了，一百多道，我大概花了5天时间，全部敲了一遍，机考链接给下来，有7天有效期，如果准备准备不充分的千万不要尝试去做，没过有6个月的封禁期，实在是得不偿失。想去OD的同学下面这个链接的机试题务必请务必掌握都是高频考题：

华为OD机试高频考题

下面重点讲一下本次7轮面试的面试题以及注意点：

第一轮 机试  2021年6月27日

说明机试第一和第二题一般对应LeetCode上的中等题，第三题为困难模式，总分400分，通过180分，也即是2道中等题搞出来基本就过了

第一题：

查找众数及中位数
1.众数是指一组数据中出现次数量多的那个数，众数可以是多个
2.中位数是指把一组数据从小到大排列，最中间的那个数，如果这组数据的个数是奇数，那最中间那个就是中位数，如果这组数据的个数为偶数，那就把中间的两个数之和除以2，所得的结果就是中位数
3.查找整型数组中元素的众数并组成一个新的数组，求新数组的中位数

输入描述:
输入一个一维整型数组，数组大小取值范围 0<N<1000，数组中每个元素取值范围 0<E<1000
输出描述:
输出众数组成的新数组的中位数

示例1：
输入
10 11 21 19 21 17 21 16 21 18 15
输出
21
示例2：
输入
2 1 5 4 3 3 9 2 7 4 6 2 15 4 2 4
输出
3
示例3：
输入
5 1 5 3 5 2 5 5 7 6 7 3 7 11 7 55 7 9 98 9 17 9 15 9 9 1 39
输出
7

答案(测试用例通过100%)，【注：最终得分=用例通过率*本题总分数】

import java.util.*;
public class Main {
    public static void main(String[] args) {
        // 输入
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        String[] s = input.split(" ");
        int[] nums = new int[s.length];
        for (int i = 0; i < nums.length; i++) {
            nums[i] = Integer.parseInt(s[i]);
        }
        scanner.close();
        // 获取众数数组和中位数
        Integer[] manyNums = getManyArr(nums);
        int medium = 0;
        int len = manyNums.length;
        if (len % 2 == 0) {
            medium = (manyNums[len / 2 - 1] + manyNums[len / 2]) / 2;
        } else {
            medium = manyNums[len / 2];
        }
        System.out.println(medium);
    }

    private static Integer[] getManyArr(int[] arr) {
        if (arr == null) {
            return new Integer[0];
        }
        // 将数组元素和出现的次数转换为key-value
        Map<Integer, Integer> countMap = new HashMap<>();
        for (int i = 0; i < arr.length; i++) {
            int current = arr[i];
            if (countMap.containsKey(current)) {
                Integer count = countMap.get(current);
                countMap.put(current, ++count);
            } else {
                countMap.put(current, 1);
            }
        }
        // 获取出现最多的次数
        int countMax = 0;
        for (int value : countMap.values()) {
            if (value > countMax) {
                countMax = value;
            }
        }
        // 获取众数，并排序
        List<Integer> list = new ArrayList<>();
        for (int key : countMap.keySet()) {
            if (countMap.get(key) == countMax) {
                list.add(key);
            }
        }
        list.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        Integer[] newArr = new Integer[list.size()];
        return list.toArray(newArr);
    }
}

 第二题：LeetCode第152题

152. 乘积最大子数组
给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。

 

示例 1:

输入: [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。
示例 2:

输入: [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。

用例通过100%答案：

public class Solution {
    public int maxProduct(int[] nums) {
        int length = nums.length;
        int[] maxF = new int[length];
        int[] minF = new int[length];
        System.arraycopy(nums, 0, maxF, 0, length);
        System.arraycopy(nums, 0, minF, 0, length);
        for (int i = 1; i < length; ++i) {
            maxF[i] = Math.max(maxF[i - 1] * nums[i], Math.max(nums[i], minF[i - 1] * nums[i]));
            minF[i] = Math.min(minF[i - 1] * nums[i], Math.min(nums[i], maxF[i - 1] * nums[i]));
        }
        int ans = maxF[0];
        for (int i = 1; i < length; ++i) {
            ans = Math.max(ans, maxF[i]);
        }
        return ans;
    }
}

第三题LeetCode第65题：

有效数字（按顺序）可以分成以下几个部分：

一个 小数 或者 整数
（可选）一个 'e' 或 'E' ，后面跟着一个 整数
小数（按顺序）可以分成以下几个部分：

（可选）一个符号字符（'+' 或 '-'）
下述格式之一：
至少一位数字，后面跟着一个点 '.'
至少一位数字，后面跟着一个点 '.' ，后面再跟着至少一位数字
一个点 '.' ，后面跟着至少一位数字
整数（按顺序）可以分成以下几个部分：

（可选）一个符号字符（'+' 或 '-'）
至少一位数字
部分有效数字列举如下：

["2", "0089", "-0.1", "+3.14", "4.", "-.9", "2e10", "-90E3", "3e+7", "+6e-1", "53.5e93", "-123.456e789"]
部分无效数字列举如下：

["abc", "1a", "1e", "e3", "99e2.5", "--6", "-+3", "95a54e53"]
给你一个字符串 s ，如果 s 是一个 有效数字 ，请返回 true 。

 

示例 1：

输入：s = "0"
输出：true
示例 2：

输入：s = "e"
输出：false
示例 3：

输入：s = "."
输出：false
示例 4：

输入：s = ".1"
输出：true

答案(这道题参考标准答案太难了)：

public class Solution {
    public boolean isNumber(String s) {
        Map<State, Map<CharType, State>> transfer = new HashMap<State, Map<CharType, State>>();
        Map<CharType, State> initialMap = new HashMap<CharType, State>() {{
            put(CharType.CHAR_NUMBER, State.STATE_INTEGER);
            put(CharType.CHAR_POINT, State.STATE_POINT_WITHOUT_INT);
            put(CharType.CHAR_SIGN, State.STATE_INT_SIGN);
        }};
        transfer.put(State.STATE_INITIAL, initialMap);
        Map<CharType, State> intSignMap = new HashMap<CharType, State>() {{
            put(CharType.CHAR_NUMBER, State.STATE_INTEGER);
            put(CharType.CHAR_POINT, State.STATE_POINT_WITHOUT_INT);
        }};
        transfer.put(State.STATE_INT_SIGN, intSignMap);
        Map<CharType, State> integerMap = new HashMap<CharType, State>() {{
            put(CharType.CHAR_NUMBER, State.STATE_INTEGER);
            put(CharType.CHAR_EXP, State.STATE_EXP);
            put(CharType.CHAR_POINT, State.STATE_POINT);
        }};
        transfer.put(State.STATE_INTEGER, integerMap);
        Map<CharType, State> pointMap = new HashMap<CharType, State>() {{
            put(CharType.CHAR_NUMBER, State.STATE_FRACTION);
            put(CharType.CHAR_EXP, State.STATE_EXP);
        }};
        transfer.put(State.STATE_POINT, pointMap);
        Map<CharType, State> pointWithoutIntMap = new HashMap<CharType, State>() {{
            put(CharType.CHAR_NUMBER, State.STATE_FRACTION);
        }};
        transfer.put(State.STATE_POINT_WITHOUT_INT, pointWithoutIntMap);
        Map<CharType, State> fractionMap = new HashMap<CharType, State>() {{
            put(CharType.CHAR_NUMBER, State.STATE_FRACTION);
            put(CharType.CHAR_EXP, State.STATE_EXP);
        }};
        transfer.put(State.STATE_FRACTION, fractionMap);
        Map<CharType, State> expMap = new HashMap<CharType, State>() {{
            put(CharType.CHAR_NUMBER, State.STATE_EXP_NUMBER);
            put(CharType.CHAR_SIGN, State.STATE_EXP_SIGN);
        }};
        transfer.put(State.STATE_EXP, expMap);
        Map<CharType, State> expSignMap = new HashMap<CharType, State>() {{
            put(CharType.CHAR_NUMBER, State.STATE_EXP_NUMBER);
        }};
        transfer.put(State.STATE_EXP_SIGN, expSignMap);
        Map<CharType, State> expNumberMap = new HashMap<CharType, State>() {{
            put(CharType.CHAR_NUMBER, State.STATE_EXP_NUMBER);
        }};
        transfer.put(State.STATE_EXP_NUMBER, expNumberMap);

        int length = s.length();
        State state = State.STATE_INITIAL;

        for (int i = 0; i < length; i++) {
            CharType type = toCharType(s.charAt(i));
            if (!transfer.get(state).containsKey(type)) {
                return false;
            } else {
                state = transfer.get(state).get(type);
            }
        }
        return state == State.STATE_INTEGER || state == State.STATE_POINT || state == State.STATE_FRACTION || state == State.STATE_EXP_NUMBER || state == State.STATE_END;
    }

    public CharType toCharType(char ch) {
        if (ch >= '0' && ch <= '9') {
            return CharType.CHAR_NUMBER;
        } else if (ch == 'e' || ch == 'E') {
            return CharType.CHAR_EXP;
        } else if (ch == '.') {
            return CharType.CHAR_POINT;
        } else if (ch == '+' || ch == '-') {
            return CharType.CHAR_SIGN;
        } else {
            return CharType.CHAR_ILLEGAL;
        }
    }

    enum State {
        STATE_INITIAL,
        STATE_INT_SIGN,
        STATE_INTEGER,
        STATE_POINT,
        STATE_POINT_WITHOUT_INT,
        STATE_FRACTION,
        STATE_EXP,
        STATE_EXP_SIGN,
        STATE_EXP_NUMBER,
        STATE_END
    }

    enum CharType {
        CHAR_NUMBER,
        CHAR_EXP,
        CHAR_POINT,
        CHAR_SIGN,
        CHAR_ILLEGAL
    }
}

第一轮三道机试，我最终应该拿到280，测试的时候 第一道100%通过，第二道测试100%通过，第三道40%，那么总分就是280分，这样机试第一轮就过了。

第二轮 性格测试 时间2021年7月2日

性格测试也是机试，可不要小看性格测试，我有个同事机试过了挂在性格测试上面，为什么这么说呢，性格测试，是在测试你是否和华为的价值观相符，测试之前请好好了解一下华为的企业价值观，无非就是华为是数字型企业，你将从事数字化工作，华为奉承奋斗者文化、狼性文化、奉献文化，你将吃苦耐劳，能在重压之下成长，明确自己在公司的定位，做技术就专心做技术，不要朝三暮四的，等等吧，一共102道选择题，每组2道，一共51组，每组选出一个最符合你的描述，选出一个最不符合你的描述，时间是30分钟内做完，非常难选，你稍微选错了，就无缘了，反正你选的是要尽量要仔细，把自己的价值观往华为公司的价值观上靠拢，这样被淘汰。我选完手心冒汗，因为太难做出选择，不过最后还是通过的。

第三轮 技术面试第一轮 时间2021年7月7日

性格测试通过以后才是真正的技术面试了，面试事宜视频面试举行的，面试时候保持环境安静，不要太吵了，影响面试体感，穿着上正式一点，上身穿件带领的寸衫吧，面试前提前15分钟进入房间测试语音和摄像头，电脑视频面试的，所以保证你的电脑是带摄像头的，因为面试官要共享你的电脑屏幕，让你手撕一道算法题，我第一轮那个面试官人很话不多，上来就是，你先写一道算法题吧。题目如下：

注：此题是LeetCode第三题
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度
 * 输入: s = "abcabcbb"
 * 输出: 3
 * 解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
 * 输入: s = "bbbbb"
 * 输出: 1
 * 解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
 * 输入: s = "pwwkew"
 * 输出: 3
 * 解释: 因为无重复字符的最长子串是"wke"，所以其长度为 3。
 * 请注意，你的答案必须是 子串 的长度，"pwke"是一个子序列，不是子串。
 * 输入: s = ""
 * 输出: 0

我当时的答案：

package leetcode;

/**
 * @author:
 * @description 无重复字符的最长子串
 * @create 2021-07-07 13:56
 * @Copyright (C), 2006-2021, 
 */

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Set;

/**
 * 给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度
 * 输入: s = "abcabcbb"
 * 输出: 3
 * 解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
 * 输入: s = "bbbbb"
 * 输出: 1
 * 解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
 * 输入: s = "pwwkew"
 * 输出: 3
 * 解释: 因为无重复字符的最长子串是"wke"，所以其长度为 3。
 * 请注意，你的答案必须是 子串 的长度，"pwke"是一个子序列，不是子串。
 * 输入: s = ""
 * 输出: 0
 */
public class Test_3 {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        String str = bufferedReader.readLine();
        System.out.println(solve(str));
        //System.out.println(solve(new Scanner(System.in).nextLine()));
    }

    static int solve(String str) {
        int ans = 0, n = str.length(), rk = -1;
        Set<Character> occ = new HashSet<>();
        for (int i = 0; i < n; i++) {
            if (i != 0) {
                occ.remove(str.charAt(i - 1));
            }
            while (rk + 1 < n && !occ.contains(str.charAt(rk + 1))) {
                occ.add(str.charAt(rk + 1));
                ++rk;
            }
            ans = Math.max(ans, rk - i + 1);
        }
        return ans;
    }
}

手撕算法有时间限制的，一般在15分钟就要写完，超时直接挂

写完以后，就开始正式进入提问环节了，首先进行自我介绍

自我介绍无非自己受教育经历、工作经历，其中你说的时候要注意你的项目描述，一般建议这样描述，项目背景是什么、项目主要解决了什么问题、项目的主要介绍架构、项目前、后端、运维分布使用了什么技术栈、项目的人员规模、你在项目里担任的角色(一般就说核心开发人员，核心二字请务必加上)、最后描述下你在项目里遇到重难点技术问题你是怎么解决的，我一般会说前后端跨域怎么解决的、分布式系统全局session怎么解决的、第三方登录、单点登录、分布式事务怎么控制的、事务一致性怎么保证的、缓存穿透、击穿、雪崩分别怎样保证的、mysql的分库分表怎样设计的等等，最好有这块的经验，不然很难，推荐去尚硅谷和黑马找对应的视频看看。

我介绍完大概10分钟吧，你说完，请补充一句，我的个人学习和工作情况就是这样的，请问您还有什么需要了解的吗？这样就平滑过渡到面试官的发文环节了

第一轮技术问题如下：

1.说下java集合，以及他们之间的区别(很多，详细说)

2.说下get和post的请求之间的区别

3.熟下MVC模式设计原则和好处

4.说下servlet是不是线程安全的

5.说下SpringMVC的主要组件以及请求流程(6个组件，11个流程，务必牢记)

6.讲一下mysql的优化原则，已经索引失效的场景，以及为什么会失效

7.讲一下spirng 的IOC和AOP的原理

8.讲一下redis的数据结构，以及你在项目中的使用场景有哪些

9.讲一下Sringboot自动注解的原理，已经他的启动原理

10.讲下数据库的隔离级别，脏库、幻读、不可重复读，分别是什么概念

11.讲下hashMap和hashTable的底层实现以及底层的扩容机制

12.讲下你项目中遇到的困难，以及你怎样解决的

然后面试官向你发问，你有什么问题想问他，精心准备几个吧

你可准备的问题如下：

1.如果顺利入职，公司这边对我的安排是怎样的？
2.公司这边做的项目主要是什么，技术栈是什么？
3.公司这边有没有一些知识分享的平台？
4.面的好就问，你觉得我在这次面试中表现的怎么样，我们还有机会再见吗？

第一轮面试持续时间70分钟

第四轮  技术面试第二轮 时间 2021年7月12日

本轮技术面试是一位中年面试官，很严肃，这一轮不是先手撕代码，还是先自我介绍，说辞如上，这里不再赘述。直接到发问环节

1.说下双亲委派原则以及类加载机制，双亲委派有何好处

2.你说你做过架构设计，那你的输入是什么，输出是什么，UML设计原则讲一下(卧槽，这种题我哪儿会，我都听蒙了，输入输出，UML，完全没搞过呀，不知道就说自己不知道，输入就说需求文档，输出就说prd文档，UML设计干脆说自己没搞过，就说自己架构图是简单的png图片)

3.讲一下你项目怎样进行单元测试的，输入输出又是什么？(这边我又听蒙了，可能这就是小厂和大厂的区别吧，规范都没有，我傻乎乎的说，我们用postman进行整个模块测试，单元测试很少，业务场景用不上)

4.说下hashMap的底层实现，以及扩容机制

5.你们项目里怎样对代码进行质量把控，又是输入输出，我说我们用sonar代码检测质量工具进行分析的，然后针对需要的优化的代码会尽心提示，然后他又问，你这个检测工具界面是什么样的，你看什么指标，我的天，追到这里就看你有无实际的项目经验，然后他又说你这里的异常代码，有哪些，你项目中的异常都有哪些，说5个，并说出出现场景、我说了5个 数组越界异常、空指针异常、算术异常、类转换异常、类找不到异常等等

6.你刚才说sonar检测代码，那为什么在编辑CICD的时候不单独拉取一个流水线进行检测呢，我的理由就是一条jenkinsfile文件集成多个步骤，主要为了节省共工作量，然后后面，他针对我的K8S集群和CICD流水线部署做了一些建议，你虚心接收就行了

7.好了，咱们来写一道算法题，题目如下，15分钟内完成

 * * 示例 1:
 * * 输入: "(()"
 * * 输出: 2
 * * 解释: 最长有效括号子串为 "()"
 * * 示例 2:
 * * 输入: ")()())"
 * * 输出: 4
 * * 解释: 最长有效括号子串为 "()()"
 * * 示例 3:
 * * 输入: "(())(()"
 * * 输出: 6
 * * 解释: 最长有效括号子串为 "(())()"

标准答案：

package test;

/**
 * @author:
 * @description
 * @create 2021-07-12 20:01
 * @Copyright (C), 2006-2021, 
 */

import java.util.Scanner;
import java.util.Stack;

/**
 * * 示例 1:
 * * 输入: "(()"
 * * 输出: 2
 * * 解释: 最长有效括号子串为 "()"
 * * 示例 2:
 * * 输入: ")()())"
 * * 输出: 4
 * * 解释: 最长有效括号子串为 "()()"
 * * 示例 3:
 * * 输入: "(())(()"
 * * 输出: 6
 * * 解释: 最长有效括号子串为 "(())()"
 * *
 * * class Solution {
 * *     public int longestValidParentheses(String s) {
 * *     }
 * * }
 */
public class OdTest_02 {
    public static void main(String[] args) {
        System.out.println(solve(new Scanner(System.in).nextLine()));
    }

    static int solve(String str) {
        int max = 0;
        if (str == null) {
            return 0;
        }
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) == '(') {
                stack.push('(');
                continue;
            } else {
                if (stack.isEmpty()) {
                    continue;
                } else {
                    stack.pop();
                    max += 2;
                }
            }
        }
        return max;
    }
}

写完后，让我问他几个问题，我还是问了技术一轮面试问的问题

总结，这一轮面试明显吃力很多，面试时间持续60分钟，这一轮面试侧重点在于对你简历上的项目进行深度发掘，深追你项目问题，算法题，我自己写的时候测试用例三，不满足，面试官提示了很多，最后才写出上面的答案，主要是自己算法太菜了，也太难了，不过后来他还是当面说，这一轮放你过，此时我终于松了一口气。

第五轮 华为HRBP 人力资源官面试 时间2021年7月13日

经历技术一轮和二轮面试 也是华为那边的对接人事为了缓解氛围，来一轮HR面试，面试形式也就是视频面试，这一轮面试，首先是自我介绍，因为人事面试，所以呢，会重点关心你为什么离职的原因，就照实说吧，第一次因为疫情公司倒闭，第二次因为想去华为公司，无奈学历不够，经验来凑，只能社招进华为OD，然后就疯狂舔华为公司，想过，你懂得，就说他是技术创新高低，中国高科技公司的一面旗帜，从新闻得知华为公司多牛逼，以一个公司的力量对抗超级大国美国的制裁，依然业绩坚挺，等等反正就是往好的方向说，我说完，面试官心里乐滋滋的，然后说我这种人特别适合来华为OD干，最后呢他简单聊了一下OD和自营的区别，整体上无非就是，自营有股票，OD没有股票，工牌和华为一样，在一起办公，技术氛围好，成长快，压力大，工资不低，然后就问我期望多少薪资了，整体而言，整个过程都在一种轻松的环境里度过的，面试持续时间30分钟

第六轮  部门技术主管面试  时间2021年7月14日

这一轮面试时间很仓促，因为要协调面试官的面试时间，形式也是视频面试，这一轮部门主管面试，延续技术二轮面试一样，氛围紧张，上来也是手撕一道算法题，LeetCode第64题，如下，

package leetcode;

/**
 * @author:
 * @description 动态规划-最小路径之和
 * @create 2021-07-14 10:09
 * @Copyright (C), 2006-2021, 
 */

/**
 * 给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
 * 说明：每次只能向下或者向右移动一步。
 */
public class Test_64 {
    public static void main(String[] args) {
        int[][] arr = new int[][]{
                {1, 0, 0, 0},
                {1, 2, 2, 0},
                {1, 3, 7, 0},
                {0, 3, 0, 0}
        };
        System.out.println(solve(arr));
    }

    static int solve(int[][] arr) {
        if (arr == null || arr.length == 0 || arr[0].length == 0) {
            return 0;
        }
        int rows = arr.length, columns = arr[0].length;
        int[][] dp = new int[rows][columns];
        dp[0][0] = arr[0][0];
        for (int i = 1; i < rows; i++) {
            dp[i][0] = dp[i - 1][0] + arr[i][0];
        }
        for (int j = 1; j < columns; j++) {
            dp[0][j] = dp[0][j - 1] + arr[0][j];
        }
        for (int i = 1; i < rows; i++) {
            for (int j = 1; j < columns; j++) {
                dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + arr[i][j];
            }
        }
        return dp[rows - 1][columns - 1];
    }
}

做完后面展开发问：

1.介绍项目，不再赘述

2.讲一下常用的springcloud组件

3.讲一下，soringboot的自动配置原理

4.Mybaties的一二级缓存有什么区别、原理、怎么开启，画一下你项目里的mybaties的一二级原理图

5.JVM内存模型说下，分别存放什么

6.GC的整个流程讲一下

7.monitor gc 、Major GC 、Full GC的区别，以及常用参数

8.Spring Bean 的生命周期

9.HashMap 和 hashTable 区别？

10.线上服务 CPU 很高该怎么做？有哪些措施可以找到问题

11.JDK 中有哪几个线程池？顺带把线程池讲了个遍

12.线程池的异步编排使用场景，以及线程池的参数

13.Concurrenthashmap 是怎么做到线程安全的？

总结：部门主管面试持续时间75分钟，重点也是聊了项目，至于后续的常见问题和二轮面试并无区别

第七轮 综合面试 时间2021年7月24日

这一轮面试持续时间大约为35分钟，一共提问了8个问题

1.项目架构设计你的输入输出是什么，UML设计原则是什么？

2.技术选型你是怎么考虑的，有哪些因素，我的回答，技术成本、技术开源社区活跃度，讲一下这些场景你的实际应用

3.你认为你最大的优势是什么

4.你对华为公司有哪些了解

5.你未来的工作方向

6.你在杭州为什么选择来上海

7.你认为你自己有没有被不公平对待过，说一下你的真实想法

8.你有家人或者朋友在华为上班吗？

总结

        整个面试走完大概花了5周时间，昨天通知我提交审核材料，如果审核通过，offer就会下来，如果offer能下来，我在补充od的福利待遇吧。

        面试是综合性的，面试官问你的问题，没有标准答案，面试的过程看中的是你的表述能力以及是否自信，总体上有个积极乐观、开放自信、衣冠得体、基础扎实、心态健康的人能容易面试成功，自信非常重要，我在面试第一轮的时候，让我手撕代码，我差点放弃，有时候面试坚持住了，可能就成功，总之，IT行业不是养老行业，技术迭代太快，唯一能顺应时代发展的唯有努力学习，不断提升。最后说下,简单聊下工作岗位的问题，现在的趋势是，在工作岗位整体不变的情况下，每年仍有1000多万应届毕业生加入进来，争抢好的工作岗位，如果自身学历、专业并不占优的情况下，请看清形式，深度了解自己在这个竞争潮流中的所处的地位，如果你没有合适的大厂offer，华为OD是你比较好的选择之一，工作无非就是为了挣钱养家，所以有时候别放不开你的面子，能挣钱的工作就是好工作，先让自己活下来，再去讨论自己要过得更好的话题，好了，我的面试经验就写到这里吧。