字节跳动｜字节客户端｜一二三面+hr面（已Offer，持续更新）

一面｜45min

1.输入url到页面展示过程

输入url地址
应用层进行DNS解析
应用层生成HTTP请求报文
传输层建立TCP连接
网络层使用IP协议来选择路线
数据链路层实现网络相邻节点间可靠的数据通信
物理层传输数据
服务器处理反向传输
服务器返回一个 HTTP 响应
浏览器渲染

https://blog.csdn.net/qinian8/article/details/99081105

2.http和https的区别

HTTP（HyperText Transfer Protocol：超文本传输协议）是一种用于分布式、协作式和超媒体信息系统的应用层协议。 简单来说就是一种发布和接收 HTML 页面的方法，被用于在 Web 浏览器和网站服务器之间传递信息。
HTTP 默认工作在 TCP 协议 80 端口，用户访问网站 http:// 打头的都是标准 HTTP 服务。

HTTP 协议以明文方式发送内容，不提供任何方式的数据加密，如果攻击者截取了Web浏览器和网站服务器之间的传输报文，就可以直接读懂其中的信息，因此，HTTP协议不适合传输一些敏感信息，比如：信用卡号、密码等支付信息。

HTTPS（Hypertext Transfer Protocol Secure：超文本传输安全协议）是一种透过计算机网络进行安全通信的传输协议。HTTPS 经由 HTTP 进行通信，但利用 SSL/TLS 来加密数据包。HTTPS 开发的主要目的，是提供对网站服务器的身份认证，保护交换数据的隐私与完整性。

HTTP 明文传输，数据都是未加密的，安全性较差，HTTPS（SSL+HTTP） 数据传输过程是加密的，安全性较好。
使用 HTTPS 协议需要到 CA（Certificate Authority，数字证书认证机构） 申请证书，一般免费证书较少，因而需要一定费用。证书颁发机构如：Symantec、Comodo、GoDaddy 和 GlobalSign 等。
HTTP 页面响应速度比 HTTPS 快，主要是因为 HTTP 使用 TCP 三次握手建立连接，客户端和服务器需要交换 3 个包，而 HTTPS除了 TCP 的三个包，还要加上 ssl 握手需要的 9 个包，所以一共是 12 个包。
http 和 https 使用的是完全不同的连接方式，用的端口也不一样，前者是 80，后者是 443。
HTTPS 其实就是建构在 SSL/TLS 之上的 HTTP 协议，所以，要比较 HTTPS 比 HTTP 要更耗费服务器资源

https://blog.csdn.net/guolin_blog/article/details/104546558

3.数字证书的内容

1）概念：
数字证书是数字证书在一个身份和该身份的持有者所拥有的公/私钥对之间建立了一种联系，由认证中心（CA）或者认证中心的下级认证中心颁发的。根证书是认证中心与用户建立信任关系的基础。在用户使用数字证书之前必须首先下载和安装。

认证中心是一家能向用户签发数字证书以确认用户身份的管理机构。为了防止数字凭证的伪造，认证中心的公共密钥必须是可靠的，认证中心必须公布其公共密钥或由更高级别的认证中心提供一个电子凭证来证明其公共密钥的有效性，后一种方法导致了多级别认证中心的出现。

2）数字证书颁发过程：

数字证书颁发过程如下：用户产生了自己的密钥对，并将公共密钥及部分个人身份信息传送给一家认证中心。认证中心在核实身份后，将执行一些必要的步骤，以确信请求确实由用户发送而来，然后，认证中心将发给用户一个数字证书，该证书内附了用户和他的密钥等信息，同时还附有对认证中心公共密钥加以确认的数字证书。当用户想证明其公开密钥的合法性时，就可以提供这一数字证书。

3）内容：

数字证书的格式普遍采用的是X.509V3国际标准，一个标准的X.509数字证书包含以下一些内容：

1、证书的版本信息；

2、证书的序列号，每个证书都有一个唯一的证书序列号；

3、证书所使用的签名算法；

4、证书的发行机构名称，命名规则一般采用X.500格式；

5、证书的有效期，通用的证书一般采用UTC时间格式；

6、证书所有人的名称，命名规则一般采用X.500格式；

7、证书所有人的公开密钥；

8、证书发行者对证书的签名。

4.对称加密和非对称加密

对称加密：加密和解密用的是同一个密码或者同一套逻辑的加密方式。对称加密的致命性缺点就是无法保证秘钥的安全性。
非对称加密:加密和解密用的秘钥不是同一个

5.https用的是对称加密还是非对称加密

HTTPS 在内容传输的加密上使用的是对称加密，非对称加密只作用在证书验证阶段

6.http头部有哪些内容

包括通用头，请求头，响应头和实体头
1.通用头域包含请求和响应消息都支持的头域，通用头域包含Cache-Control、 Connection、Date、Pragma、Transfer-Encoding、Upgrade、Via。对通用头域的扩展要求通讯双方都支持此扩展，如果存在不支持的通用头域，一般将会作为实体头域处理
2.请求头域可能包含下列字段Accept、Accept-Charset、Accept- Encoding、Accept-Language、Authorization、From、Host、If-Modified-Since、If- Match、If-None-Match、If-Range、If-Range、If-Unmodified-Since、Max-Forwards、 Proxy-Authorization、Range、Referer、User-Agent。对请求头域的扩展要求通讯双方都支持，如果存在不支持的请求头域,一般将会作为实体头域处理。
3.响应消息的第一行为下面的格式： 
HTTP-Version Status-Code Reason-Phrase

HTTP -Version表示支持的HTTP版本，例如为HTTP/1.1。
Status- Code是一个三个数字的结果代码。
Reason-Phrase给Status-Code提供一个简单的文本描述。
4.请求消息和响应消息都可以包含实体信息，实体信息一般由实体头域和实体组成。

实体头域包含关于实体的原信息，实体头包括Allow、Content- Base、Content-Encoding、Content-Language、Content-Length、Content-Location、Content-MD5、Content-Range、Content-Type、 Etag、Expires、Last-Modified、extension-header。extension-header允许客户端定义新的实体头，但是这些域可能无法为接受方识别。

7.线程和进程的区别

一个进程可以有多个线程,至少有一个线程
根本区别：进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位

8.进程通信的方式

1 匿名管道通信
2 高级管道通信
3 有名管道通信
4 消息队列通信
5 信号量通信
6 信号
7 共享内存通信
8 套接字通信

9.线程的状态怎样转移

线程主要分为6种状态：初始，可运行，等待，超时等待，阻塞，终止

10.封装继承和多态

封装的意义：
　　封装的意义在于保护或者防止代码（数据）被我们无意中破坏。在面向对象程序设计中数据被看作是一个中心的元素并且和使用它的函数结合的很密切，从而保护它不被其它的函数意外的修改。
继承主要实现重用代码，节省开发时间。
多态：

1、“一个接口，多种方法”

同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。

  多态的三个条件:
 
 a.    继承的存在(继承是多态的基础,没有继承就没有多态).
 b.    子类重写父类的方法(多态下调用子类重写的方法).
 c.    父类引用变量指向子类对象(子类到父类的类型转换).

重载（overload）和重写（override）是实现多态的两种主要方式。

 　２、实现多态：

接口多态性。
继承多态性。
通过抽象类实现的多态性。

11.重载和重写的区别

重写： 在方法名，参数列表，返回类型(除过子类中方法的返回值是父类中方法返回值的子类时)都相同的情况下， 对方法体进行修改或重写，这就是重写。但要注意子类函数的访问修饰权限不能少于父类的。
重载：在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同甚至是参数顺序不同）则视为重载。同时，重载对返回类型没有要求，可以相同也可以不同，但不能通过返回类型是否相同来判断重载。

12.垃圾回收算法了解吗？怎么判断对象需要被回收？GC ROOTS有哪些

垃圾：已经不再被内存使用到的空间

1.标记清除
2.标记压缩
3.可达性分析算法
4.GC roots
GC roots
--
1.虚拟机栈中的引用对象
2.方法区中的类静态属性引用对象
3.方法区中常量引用的对象
4.本地方法栈Native方法引用的对象

算法题一，回型打印二维数组

public class ArrayBackPrint {
 
    public static void arrayBackPrint(int[][] nums) {
        if (nums == null) {
            throw new RuntimeException("invalid param");
        }
        if (nums.length == 0) {
            return;
        }
        int top = 0;
        int bottom =  nums.length - 1;
        int left =0;
        int right = nums[0].length - 1;
        while (top <= bottom && left <= right) {
            for (int i = left; i <= right; i++) {
                System.out.print(nums[top][i] + " ");
            }
            top++;
            if (top > bottom || left > right) {
                break;
            }
            for (int i = top; i <= bottom; i++) {
                System.out.print(nums[i][right] + " ");
            }
            right--;
            if (top > bottom || left > right) {
                break;
            }
            for (int i = right; i >= left; i--) {
                System.out.print(nums[bottom][i] + " ");
            }
            bottom--;
            if (top > bottom || left > right) {
                break;
            }
            for (int i = bottom; i >= top; i--) {
                System.out.print(nums[i][left] + " ");
            }
            left++;
            System.out.println();
        }
    }
 
    public static void arrayPrint(int[][] nums) {
        if (nums == null) {
            throw new RuntimeException("invalid param");
        }
        if (nums.length == 0) {
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums[0].length; j++) {
                System.out.print(nums[i][j] + " ");
            }
            System.out.println();
        }
    }
 
    public static void arrayInnit(int[][] nums) {
        if (nums == null) {
            throw new RuntimeException("invalid param");
        }
        if (nums.length == 0) {
            return;
        }
        int num = 11;
        for (int i = 0; i < nums.length; i++) {
            for (int j = 0; j < nums[0].length; j++) {
                nums[i][j] = num++;
            }
        }
    }
 
    public static void main(String[] args) {
//        int[][] nums = new int[10][7];
        int[][] nums = new int[10][10];
        arrayInnit(nums);
        arrayPrint(nums);
        arrayBackPrint(nums);
    }
 
}

二面｜20min

1.重载和重写的区别（重复

2.静态方法能不能重写

重写的目的在于父类引用可以根据子类对象的运行时实际类型不同而调用不同实现代码，从而表现出多态。并且，静态方法无需创建对象即可使用，而重写的方法发挥作用，需要父类引用，和（不同的）子类对象

3.只有返回值不同算不算重载

不算,编译都通过不了

4.类的加载过程

加载--验证--准备--解析--初始化--使用--卸载

算法一，判断A是不是B的子树

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    //分为两个函数，一个用于遍历节点当做子树的根节点，另一个用于判断是否是子树（必须要root2先空）
    public boolean HasSubtree(TreeNode root1,TreeNode root2) {
        if(root1==null||root2==null)
            return false;
        //此处用到一个技巧，直接判断isSubtree(root1,root2)，并且采取||的方式确定结果。
        return isSubtree(root1,root2)||HasSubtree(root1.left,root2)||HasSubtree(root1.right,root2);
        
    }
    
    public boolean isSubtree(TreeNode root1,TreeNode root2){
        if(root2==null)
            return true;
        if(root1==null)
            return false;
        if(root1.val==root2.val)
            return isSubtree(root1.left,root2.left)&&
            isSubtree(root1.right,root2.right);
        else{
            return false;
        }
    }
}

三面｜50min

1.问了前两面的表现具体说说

算法题一，给一个数n，和一个数组，用数组中的数组成最大的小于n的数，数组中的数可以重复使用（贪心）

算法题二，一个数组求max(ai-aj)其中i小于j

数学题一：求log2的第10000位（答：会用二分求近似，不会做这个…换了抛硬币，应该是牛顿迭代没学过。。。

数学题二：AB轮流抛硬币，A先抛，抛到正面胜利，抛到反面对方接着抛，问A的胜率，等比数列求和，还好还记得等比数列求和公式。。。

2.数据库ACID

3.缺页中断

缺页中断就是要访问的页不在主存，需要操作系统将其调入主存后再进行访问。在这个时候，被内存映射的文件实际上成了一个分页交换文件。

4.页面置换算法

未来永远不会再使用的页面 or 未来最长时间不再被访问的页面

5.http的无状态

6.为什么设计成无状态

7.你觉得什么样的代码算好的代码（瞎说挖了好多坑。。。

SOLLID

8.什么叫可拓展性好，举个例子

对扩展开放，对修改关闭

9.为啥要降低耦合度

10.你提到了设计模式，设计模式的七大原则是什么（7挖的坑…不会，设计模式只会单例模式

单一职责原则（Single Responsibility Principle）；----通俗地说，即一个类只负责一项职责

开闭原则（Open Closed Principle）；----开放-关闭原则表示软件实体 (类、模块、函数等等) 应该是可以被扩展的，但是不可被修改

里氏替换原则（Liskov Substitution Principle）；----子类可以扩展父类的功能，但不能改变父类原有的功能

迪米特法则（Law of Demeter），又叫“最少知道法则”；----最少知道原则，它表示一个对象应该对其它对象保持最少的了解。通俗来说就是，只与直接的朋友通信

接口隔离原则（Interface Segregation Principle）；----客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。

依赖倒置原则（Dependence Inversion Principle）。—面向接口编程，理解了面向接口编程，也就理解了依赖倒转

组合/聚合复用原则 (Composite/Aggregate Reuse Principle)----在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分; 新的对象通过向这些对象的委派达到复用已有功能的目的。

11.你的优势和缺陷

三面当天下午收到hr面邀请

hr面｜20min

聊了一些职业规划得问题略

作者：匿名用户

链接：https://leetcode.cn/circle/discuss/eBN2jJ/

来源：力扣（LeetCode）

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。