这是一份面向Android开发者的复习指南｜掘金技术征文，2024年最新我的头条面试经历分享文案-CSDN博客

本文链接：https://blog.csdn.net/2401_84103549/article/details/137779413

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注Android）

正文

RandomAccessFile：支持随机访问，可以从指定位置进行数据的读写。

有了这个基础以后，思路就清晰了：

通过HttpUrlConnection获取文件长度。
自己分配好线程进行制定区间的文件数据的下载。
获取到数据流以后，使用RandomAccessFile进行指定位置的读写。

6. 性能优化

# 平时做了哪些性能优化？

建议阅读：

《Android 性能优化最佳实践》

7. 第三方库

一定要在熟练使用后再去查看原理。

# Glide

Glide考察的频率挺高的，常见的问题有：

Glide和其他图片加载框架的比较？
如何设计一个图片加载框架？
Glide缓存实现机制？
Glide如何处理生命周期？
…

建议阅读：

《Glide最全解析》

《面试官：简历上最好不要写Glide，不是问源码那么简单》

# OkHttp

OkHttp常见知识点：

责任链模式
interceptors和networkInterceptors的区别？

建议看一遍源码，过程并不复杂。

# Retrofit

Retrofit常见问题：

设计模式和封层解耦的理念
动态代理

建议看一遍源码，过程并不复杂。

# RxJava

RxJava难在各种操作符，我们了解一下大致的设计思想即可。

建议寻找一些RxJava的文章。

# Android Jetpack(非必须)

我主要阅读了Android Jetpack中以下库的源码：

Lifecycle：观察者模式，组件生命周期中发送事件。
DataBinding：核心就是利用LiveData或者Observablexxx实现的观察者模式，对16进制的状态位更新，之后根据这个状态位去更新对应的内容。
LiveData：观察者模式，事件的生产消费模型。
ViewModel：借用Activty异常销毁时存储隐藏Fragment的机制存储ViewModel，保证数据的生命周期尽可能的延长。
Paging：设计思想。

以后有时间再给大家做源码分析。

建议阅读：

《Android Jetpack源码分析系列》

8. 插件化和组件化

这个我基本没用过，等用过了，再和大家分享。

三、Java基础

Java基础

Java基础中考察频率比较高的是Object、String、面向对象、集合、泛型和反射。

1. Object

# equals和==的区别？equals和hashcode的关系？

==：基本类型比较值，引用类型比较地址。
equals：默认情况下，equals作为对象中的方法，比较的是地址，不过可以根据业务，修改equals方法。

equals和hashcode之间的关系：

默认情况下，equals相等，hashcode必相等，hashcode相等，equals不是必相等。hashcode基于内存地址计算得出，可能会相等，虽然几率微乎其微。

2. String

# String、StringBuffer和StringBuilder的区别？

String：String属于不可变对象，每次修改都会生成新的对象。
StringBuilder：可变对象，非多线程安全。
StringBuffer：可变对象，多线程安全。

大部分情况下，效率是：StringBuilder>StringBuffer>String。

3. 面向对象的特性

# Java中抽象类和接口的特点？

共同点：

抽象类和接口都不能生成具体的实例。
都是作为上层使用。

不同点：

抽象类可以有属性和成员方法，接口不可以。
一个类只能继承一个类，但是可以实现多个接口。
抽象类中的变量是普通变量，接口中的变量是静态变量。
抽象类表达的是is-a的关系，接口表达的是like-a的关系。

# 关于多态的理解？

多态是面向对象的三大特性：继承、封装和多态之一。

多态的定义：允许不同类对同一消息做出响应。

多态存在的条件：

要有继承。
要有复写。
父类引用指向子类对象。

Java中多态的实现方式：接口实现，继承父类进行方法重写，同一个类中的方法重载。

4. 集合

# HashMap的特点是什么？HashMap的原理？

HashMap的特点：

基于Map接口，存放键值对。
允许key/value为空。
非多线程安全。
不保证有序，也不保证使用的过程中顺序不会改变。

简单来讲，核心是数组+链表/红黑树，HashMap的原理就是存键值对的时候：

通过键的Hash值确定数组的位置。
找到以后，如果该位置无节点，直接存放。
该位置有节点即位置发生冲突，遍历该节点以及后续的节点，比较key值，相等则覆盖。
没有就新增节点，默认使用链表，相连节点数超过8的时候，在jdk 1.8中会变成红黑树。
如果Hashmap中的数组使用情况超过一定比例，就会扩容，默认扩容两倍。

当然这是存入的过程，其他过程可以自行查阅。这里需要注意的是：

key的hash值计算过程是高16位不变，低16位和高16位取抑或，让更多位参与进来，可以有效的减少碰撞的发生。
初始数组容量为16，默认不超过的比例为0.75。

5. 泛型

# 说一下对泛型的理解？

泛型的本质是参数化类型，在不创建新的类型的情况下，通过泛型指定不同的类型来控制形参具体限制的类型。也就是说在泛型的使用中，操作的数据类型被指定为一个参数，这种参数可以被用在类、接口和方法中，分别被称为泛型类、泛型接口和泛型方法。

泛型是Java中的一种语法糖，能够在代码编写的时候起到类型检测的作用，但是虚拟机是不支持这些语法的。

泛型的优点：

类型安全，避免类型的强转。
提高了代码的可读性，不必要等到运行的时候才去强制转换。

# 什么是类型擦除？

不管泛型的类型传入哪一种类型实参，对于Java来说，都会被当成同一类处理，在内存中也只占用一块空间。通俗一点来说，就是泛型只作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的信息擦除，也就是说，成功编译过后的class文件是不包含任何泛型信息的。

6. 反射

# 动态代理和静态代理

静态代理很简单，运用的就是代理模式：

声明一个接口，再分别实现一个真实的主题类和代理主题类，通过让代理类持有真实主题类，从而控制用户对真实主题的访问。

动态代理指的是在运行时动态生成代理类，即代理类的字节码在运行时生成并载入当前的ClassLoader。

动态代理的原理是使用反射，思路和上面的一致。

使用动态代理的好处：

不需要为RealSubject写一个形式完全一样的代理类。
使用一些动态代理的方法可以在运行时制定代理类的逻辑，从而提升系统的灵活性。

四、Java并发

Java并发中考察频率较高的有线程、线程池、锁、线程间的等待和唤醒、线程特性和阻塞队列等。

1. 线程

# 线程的状态有哪些（待修改）？

线程的状态有：

new：新创建的线程
Ready：准备就绪的线程，由于CPU分配的时间片的关系，此时的任务不在执行过程中。
Running：正在执行的任务
Block：被阻塞的任务
Time Waiting：计时等待的任务
Terminated：终止的任务

附上一张状态转换的图：线程状态转换

# 线程中wait和sleep的区别？

wait方法既释放cpu，又释放锁。 sleep方法只释放cpu，但是不释放锁。

# 线程和进程的区别？

线程是CPU调度的最小单位，一个进程中可以包含多个线程，在Android中，一个进程通常是一个App，App中会有一个主线程，主线程可以用来操作界面元素，如果有耗时的操作，必须开启子线程执行，不然会出现ANR，除此以外，进程间的数据是独立的，线程间的数据可以共享。

2. 线程池

线程池的地位十分重要，基本上涉及到跨线程的框架都使用到了线程池，比如说OkHttp、RxJava、LiveData以及协程等。

# 与新建一个线程相比，线程池的特点？

节省开销：线程池中的线程可以重复利用。
速度快：任务来了就能开始，省去创建线程的时间。
线程可控：线程数量可空和任务可控。
功能强大：可以定时和重复执行任务。

# 线程池中的几个参数是什么意思，线程池的种类有哪些？

线程池的构造函数如下：

public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}

参数解释如下：

corePoolSize：核心线程数量，不会释放。
maximumPoolSize ：允许使用的最大线程池数量，非核心线程数量，闲置时会释放。
keepAliveTime ：闲置线程允许的最大闲置时间。
unit ：闲置时间的单位。
workQueue ：阻塞队列，不同的阻塞队列有不同的特性。

线程池分为四个类型：

CachedThreadPool：闲置线程超时会释放，没有闲置线程的情况下，每次都会创建新的线程。
FixedThreadPool：线程池只能存放指定数量的线程池，线程不会释放，可重复利用。
SingleThreadExecutor：单线程的线程池。
ScheduledThreadPool：可定时和重复执行的线程池。

# 线程池的工作流程？

线程池工作流程 图片来自《线程池是怎样工作的》

简而言之：

任务来了，优先考虑核心线程。
核心线程满了，进入阻塞队列。
阻塞队列满了，考虑非核心线程（图上好像少了这个过程）。
非核心线程满了，再触发拒绝任务。

3. 锁

# 死锁触发的四大条件？

互斥锁
请求与保持
不可剥夺
循环的请求与等待

# synchronized关键字的使用？synchronized的参数放入对象和Class有什么区别？

synchronized关键字的用法：

修饰方法
修饰代码块：需要自己提供锁对象，锁对象包括对象本身、对象的Class和其他对象。

放入对象和Class的区别是：

锁住的对象不同：成员方法锁住的实例对象，静态方法锁住的是Class。
访问控制不同：如果锁住的是实例，只会针对同一个对象方法进行同步访问，多线程访问同一个对象的synchronized代码块是串行的，访问不同对象是并行的。如果锁住的是类，多线程访问的不管是同一对象还是不同对象的synchronized代码块是都是串行的。

# synchronized的原理？

任何一个对象都有一个monitor与之相关联，JVM基于进入和退出mointor对象来实现代码块同步和方法同步，两者实现细节不同：

代码块同步：在编译字节码的时候，代码块起始的地方插入monitorenter

指令，异常和代码块结束处插入monitorexit指令，线程在执行monitorenter指令的时候尝试获取monitor对象的所有权，获取不到的情况下就是阻塞

方法同步：synchronized方法在method_info结构有AAC_synchronized标记，线程在执行的时候获取对应的锁，从而实现同步方法

# synchronized和Lock的区别？

主要区别：

synchronized是Java中的关键字，是Java的内置实现；Lock是Java中的接口。
synchronized遇到异常会释放锁；Lock需要在发生异常的时候调用成员方法Lock#unlock()方法。
synchronized是不可以中断的，Lock可中断。
synchronized不能去尝试获得锁，没有获得锁就会被阻塞； Lock可以去尝试获得锁，如果未获得可以尝试处理其他逻辑。
synchronized多线程效率不如Lock，不过Java在1.6以后已经对synchronized进行大量的优化，所以性能上来讲，其实差不了多少。

# 悲观锁和乐观锁的举例？以及它们的相关实现？

悲观锁和乐观锁的概念：

悲观锁：悲观锁会认为，修改共享数据的时候其他线程也会修改数据，因此只在不会受到其他线程干扰的情况下执行。这样会导致其他有需要锁的线程挂起，等到持有锁的线程释放锁
乐观锁：每次不加锁，每次直接修改共享数据假设其他线程不会修改，如果发生冲突就直接重试，直到成功为止

举例：

悲观锁：典型的悲观锁是独占锁，有synchronized、ReentrantLock。
乐观锁：典型的乐观锁是CAS，实现CAS的atomic为代表的一系列类

# CAS是什么？底层原理？

CAS全称Compare And Set，核心的三个元素是：内存位置、预期原值和新值，执行CAS的时候，会将内存位置的值与预期原值进行比较，如果一致，就将原值更新为新值，否则就不更新。底层原理：是借助CPU底层指令cmpxchg实现原子操作。

4. 线程间通信

# notify和notifyAll方法的区别？

notify随机唤醒一个线程，notifyAll唤醒所有等待的线程，让他们竞争锁。

# wait/notify和Condition类实现的等待通知有什么区别？

synchronized与wait/notify结合的等待通知只有一个条件，而Condition类可以实现多个条件等待。

5. 多线程间的特性

# 多线程间的有序性、可见性和原子性是什么意思？

原子性：执行一个或者多个操作的时候，要么全部执行，要么都不执行，并且中间过程中不会被打断。Java中的原子性可以通过独占锁和CAS去保证
可见性：指多线程访问同一个变量的时候，一个线程修改了变量的值，其他线程能够立刻看得到修改的值。锁和volatile能够保证可见性
有序性：程序执行的顺序按照代码先后的顺序执行。锁和volatile能够保证有序性

# happens-before原则有哪些？

Java内存模型具有一些先天的有序性，它通常叫做happens-before原则。

如果两个操作的先后顺序不能通过happens-before原则推倒出来，那就不能保证它们的先后执行顺序，虚拟机就可以随意打乱执行指令。happens-before原则有：

程序次序规则：单线程程序的执行结果得和看上去代码执行的结果要一致。
锁定规则：一个锁的lock操作一定发生在上一个unlock操作之后。
volatile规则：对volatile变量的写操作一定先行于后面对这个变量的对操作。
传递规则：A发生在B前面，B发生在C前面，那么A一定发生在C前面。
线程启动规则：线程的start方法先行发生于线程中的每个动作。
线程中断规则：对线程的interrupt操作先行发生于中断线程的检测代码。
线程终结原则：线程中所有的操作都先行发生于线程的终止检测。
对象终止原则：一个对象的初始化先行发生于他的finalize()方法的执行。

前四条规则比较重要。

# volatile的原理？

可见性 如果对声明了volatile的变量进行写操作的时候，JVM会向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据写入到系统内存。

多处理器的环境下，其他处理器的缓存还是旧的，为了保证各个处理器一致，会通过嗅探在总线上传播的数据来检测自己的数据是否过期，如果过期，会强制重新将系统内存的数据读取到处理器缓存。

有序性 Lock前缀的指令相当于一个内存栅栏，它确保指令排序的时候，不会把后面的指令拍到内存栅栏的前面，也不会把前面的指令排到内存栅栏的后面。

6. 阻塞队列

# 通常的阻塞队列有哪几种，特点是什么？

ArrayBlockQueue：基于数组实现的有界的FIFO(先进先出)阻塞队列。
LinkedBlockQueue：基于链表实现的无界的FIFO(先进先出)阻塞队列。
SynchronousQueue：内部没有任何缓存的阻塞队列。
PriorityBlockingQueue：具有优先级的无限阻塞队列。

# ConcurrentHashMap的原理

数据结构的实现跟HashMap一样，不做介绍。

JDK 1.8之前采用的是分段锁，核心类是一个Segment，Segment继承了ReentrantLock，每个Segment对象管理若干个桶，多个线程访问同一个元素的时候只能去竞争获取锁。

JDK 1.8采用了CAS + synchronized，插入键值对的时候如果当前桶中没有Node节点，使用CAS方式进行更新，如果有Node节点，则使用synchronized的方式进行更新。

五、Jvm

JVM Jvm中考察频率较高的内容有：Jvm内存区域的划分、GC机制和类加载机制。

建议阅读：

《深入理解Java虚拟机》

1. Java内存模型

# Jvm内存区域是如何划分的？

内存区域划分：

程序计数器：当前线程的字节码执行位置的指示器，线程私有。
Java虚拟机栈：描述的Java方法执行的内存模型，每个方法在执行的同时会创建一个栈帧，存储着局部变量、操作数栈、动态链接和方法出口等，线程私有。
本地方法栈：本地方法执行的内存模型，线程私有。
Java堆：所有对象实例分配的区域。
方法区：所有已经被虚拟机加载的类的信息、常量、静态变量和即时编辑器编译后的代码数据。

# Jvm内存模型是怎么样的？

Java规定所有变量的内存都需要存储在主内存。
每个线程都有自己的工作内存，线程中使用的所有变量以及对变量的操作都基于工作内存，工作内存中的所有变量都从主内存读取过来的。
不同线程间的工作内存无法进行直接交流，必须通过主内存完成。

主内存和工作内存之间的交互协议，即变量如何从主内存传递到工作内存、工作内存如何将变量传递到主内存，Java内存模型定义了8种操作来完成，并且每一种操作都是原子的，不可再分的。

类型	说明
`lock`	作用于主内存的变量，把一个变量标识一个线程独占的状态
`unlock`	作用于主内存的变量，把一个处于锁定状态的变量释放出来
`read`	把一个变量从主内存传输到工作内存，以便随后的`load`使用
`load`	把`read`操作读取的变量存储到工作内存的变量副本中
`use`	把工作内存中的变量的值传递给执行引擎，每当虚拟机执行到一个需要使用变量的字节码指令的时候都会执行这个操作
`assign`	把一个从执行引擎中接收到的变量赋值给工作内存中的变量，每当虚拟机遇到赋值的字节码指令都会执行这个操作
`store`	把工作内存中的一个变量的值传递给主内存，以便以后的`write`使用
`write`	把`store`传递过来的工作内存中的变量写入到主内存中的变量

# String s1 = "abc"和String s2 = new String(“abc”)的区别，生成对象的情况

指向方法区："abc"是常量，所以它会在方法区中分配内存，如果方法区已经给"abc"分配过内存，则s1会直接指向这块内存区域。
指向Java堆：new String("abc")是重新生成了一个Java实例，它会在Java堆中分配一块内存。

所以s1和s2的内存地址肯定不一样，但是内容一样。

2. GC机制

# 如何判断对象可回收？

判断一个对象可以回收通常采用的算法是引用几算法和可达性算法。由于互相引用导致的计数不好判断，Java采用的可达性算法。

可达性算法的思路是：通过一些列被成为GC Roots的对象作为起始点，自上往下从这些起点往下搜索，搜索所有走过的路径称为引用链，如果一个对象没有跟任何引用链相关联的时候，则证明该对象不可用，所以这些对象就会被判定为可以回收。

可以被当作GC Roots的对象包括：

Java虚拟机栈中的引用的对象
方法区中静态属性引用的对象
方法区中常量引用的对象
本地方法中JNI引用的对象

# GC的常用算法？

标记 - 清除：首先标记出需要回收的对象，标记完成后统一回收所有被标记的对象。容易产生碎片空间。
复制算法：它将可用的内存分为两块，每次只用其中的一块，当需要内存回收的时候，将存活的对象复制到另一块内存，然后将当前已经使用的内存一次性回收掉。需要浪费一半的内存。
标记 - 整理：让存活的对象向一端移动，之后清除边界外的内存。
分代搜集：根据对象存活的周期，Java堆会被分为新生代和老年代，根据不同年代的特性，选择合适的GC收集算法。

# Minar GC和Full GC的区别？

Minar GC：频率高、针对新生代。
Full GC：频率低、发生在老年代、通常会伴随一次Minar GC和速度慢。

# 说一下四种引用以及他们的区别？

强引用：强引用还在，垃圾搜集器就不会回收被引用的对象。
软引用：对于软引用关联的对象，在系统发生内存溢出异常之前，将会把这些对象列进回收范围进行第二次回收，如果这次回收还没有足够的内存，才会抛出内存溢出异常。
弱引用：被若引用关联的对象只能存活到下一次GC之前。
虚引用：为对象设置虚引用的目的仅仅是为了GC之前收到一个系统通知。

3. 类加载

# 类加载的过程？

类加载的过程可以分为：

加载：将类的全限定名转化为二进制流，再将二进制流转化为方法区中的类型信息，从而生成一个Class对象。
验证：对类的验证，包括格式、字节码、属性等。
准备：为类变量分配内存并设置初始值。
解析：将常量池的符号引用转化为直接引用。
初始化：执行类中定义的Java程序代码，包括类变量的赋值动作和构造函数的赋值。
使用
卸载

只有加载、验证、准备、初始化和卸载的这个五个阶段的顺序是确定的。

# 类加载的机制，以及为什么要这样设计？

类加载的机制是双亲委派模型。大部分Java程序需要使用的类加载器包括：

启动类加载器：由C++语言实现，负责加载Java中的核心类。
扩展类加载器：负责加载Java扩展的核心类之外的类。
应用程序类加载器：负责加载用户类路径上指定的类库。

双亲委派模型如下：双亲委派模型要求出了顶层的启动类加载器之外，其他的类加载器都有自己的父加载器，通过组合实现。

双亲委派模型的工作流程：当一个类加载的任务来临的时候，先交给父类加载器完成，父类加载器交给父父类加载器完成，知道传递给启动类加载器，如果完成不了的情况下，再依次往下传递类加载的任务。

这样设计的原因：双亲委派模型能够保证Java程序的稳定运行，不同层次的类加载器具有不同优先级，所有的对象的父类Object，无论哪一个类加载器加载，最后都会交给启动类加载器，保证安全。

六、kotlin

Kotlin

建议阅读：

《Kotlin》实战

1. 基础

# ==、===和equal的区别？

==和equal的作用相同，===比较内存地址

# var和val的区别？

var：可变引用，具有可读和可写权限，值可变，类型不可变
val：不可变引用，具有可读权限，值不可变，但是对象的属性可变

2. 函数

# Kotlin中默认参数的作用以及原理？

作用：配合@JavaOverloads可以解决Java调用Kotlin函数重载的问题。原理：Kotlin编译的默认参数是被编译到调用的函数中的，所以默认参数改变的时候，是需要重新编译这个函数的。

# Kotlin中顶层函数的原理

顶层函数实质就是Java中的静态函数，可以通过Kotlin中的@Jvm:fileName自动生成对应的Java调用类名。

# 中缀函数是什么？注意点？

中缀函数需要是用infix关键字修饰，如downTo：

public infix fun Int.downTo(to: Int): IntProgression {
return IntProgression.fromClosedRange(this, to, -1)
}

注意点是函数的参数只能有一个，函数的参与者只能有两个。

# 解构函数的本质？

解构声明将对象中的所有属性，解构成一组属性变量，而且这些变量可以单独使用，可以单数使用的原因是通过获取对应的component()方法对应着类中每个属性的值，这些属性的值被存储在局部变量中，所以解构声明的实质是局部变量。

# 扩展函数的本质？

扩展函数的本质就是对应Java中的静态函数，这个静态函数参数为接受者类型的对象，然后利用这个对象去访问对象中的属性和成员方法，最后返回这个对象的本身。

# 扩展函数和成员函数的区别？

实质不同：扩展函数实质是静态函数，是外部函数，成员函数是内部函数。
权限不同：扩展函数访问不了私有的属性和成员方法，成员函数可以。
继承：扩展函数不可复写，成员函数可以复写。

它们的使用方式类似。

3. 类、对象和接口

# Kotlin中常用的类的修饰符有哪些？

open：运行创建子类或者复写子类的方法。
final：不允许创建子类和复写子类的方法。
abstract：抽象类，必须复写子类的方法。

在Kotlin中，默认的类和方法的修饰符都是final的，如果想让类和方法能够被继承或者复写，需要显示的添加open修饰符。

# Kotlin中可见性修饰符有哪些？

public：所有地方可见
protected：子类中可见
private：类中可见
internal：模块中可见，一个模块就是一组一起编译的Kotlin文件

Java默认的访问权限是包访问权限，Kotlin中默认的访问权限是public。

# Kotlin中的内部类和Java中的内部类有什么不同？

Kotlin：默认相当于Java中的静态内部类，如果想访问类中的成员方法和属性，需要添加inner关键字修饰。
Java：默认持有外部类引用，可以访问成员方法和属性，如果想声明为静态内部类，需要添加static关键字修饰。

# Kotlin属性代理背后原理？

可以简单理解为属性的settter、getter访问器内部实现交给了代理对象来实现，相当于使用一个代理对象代替了原来简单属性的读写过程，而暴露外部属性操作还是不变的，照样是属性赋值和读取，只是setter、getter内部具体实现变了。

# object和companion object的一些特点？

共同点：定义单例的一种方式，提供静态成员和方法。

不同点：

object：用来生成匿名内部类。
companion object：提供工厂方法，访问私有的构造方法。

4. lambda

# lambda表达式有几种？

普通表达式：()->R。
带接收者对象的表达式：T.()->R，可以访问接收者对象的属性和成员方法。如apply。

# kotlin和Java内部类或者lambda表达式访问局部变量有什么不同？

Java中的内部类：局部变量必须是final声明的，无法去修改局部变量的值。
Kotlin中lambda表达式：不要求final声明，对于非final修饰的lambda表达式，可以修改局部变量的值。

如果想在Java中的内部类修改外层局部变量的值，有两种方法：用数组包装或者提供包装类，Kotlin中lambda能够访问并修改局部变量的本质就是提供了一层包装类：

class Ref(var value:T)

修改局部变量的值就是修改value中的值。

# 使用lambda表达式访问的局部变量有什么不同？

默认情况下，局部变量的生命周期会被限制在声明这个变量的函数中，但是如果它被lambda捕捉了，使用这个变量的代码可以被存储并稍后执行。

class Apple {
lateinit var num:(() -> Int)

fun initCount(){
val count = 2
num = fun():Int{
return count * count
}
}

fun res():Int{
return num()
}
}

fun main(args: Array) {
val a = Apple()
a.initCount()
val res = a.res()
println(res)
}

如上面代码所示，局部变量count就被存储在lambda表达式中，最后通过Apple#res方法引用表达式。

原理：当你捕捉final变量的时候，它的值会和lambda代码一起存储。对于非final变量，它的值会被封装在一层包装器中，包装器的引用会和lambda代码一起被存储。

带来的问题：默认情况下，lambda表达式会生成匿名内部类，在非显示声明对象的情况下可以多次重用，但是如果捕获了局部变量，每次调用的时候都需要生成新的实例。

# 序列是什么？集合类和序列的操作符比较？

Sequence(序列)是一种惰性集合，可以更高效地对元素进行链式操作，不需要创建额外的集合保存过程中产生的中间结果，简单来讲，就是序列中所有的操作都是按顺序应用在每一个元素中。比如：

fun main(args: Array) {
val list = mutableListOf(“1”,“2”,“3”,“4”,“5”,“6”,“7”,“8”,“9”)
val l = list.asSequence()
.filter { it.toCharArray()[0] < ‘4’ }
.map { it.toInt() * it.toInt() }
.toList()
}

对于上述序列中的"1"，它会先执行filter，再执行map，之后再对"2"重复操作。除此以外，序列中所有的中间操作都是惰性的。

集合和序列操作符的比较：

集合类：map和filter方法是内联，不会生成匿名类的实例，但每次进行map和filter都会生成新的集合，当数据量大的时候，消耗的内存也比较大。
序列：map和fitler非内联，会生成匿名类实例，但不需要创建额外的集合保存中间操作的结果。

# 为什么要使用内联函数？内联函数的作用？

使用lambda表达式可能带来的开销：

lambda表达式正常会被编译成匿名类。
正常情况下，使用lambda表达式至少会生成一个对象，如果很不幸的使用了局部变量，那么每次使用该lambda表达式都会生成一个新的对象，导致使用lambda的效率比不使用还要低。

使用内联函数可以减少运行时的开销。内联函数主要作用：

使用内联函数可以减少中间类和对象的创建，进而提升性能。主要原因是内联函数可以做到函数被使用的时候编译器不会生成函数调用的代码，而是使用函数实现的真实代码区替换每一次的调用。
结合reified实化类型参数，解决泛型类型运行时擦除的问题。

5. 类型系统

# Kotlin中的基本数据类型的理解？

在Kotlin中，使用的时候是不区分基本类型的，统一如下： Int、Byte、Short、Long、Float、Double、Char和Boolean。

使用统一的类型并不意味着Kotlin中所有的基本类型都是引用类型，大多数情况下，对于变量、参数、返回类型和属性都会被编译成基本类型，泛型类会被编译成Java中的包装类，即引用类型。

# 只读集合和可变集合的区别？

在Kotlin中，集合会被分为两大类型，只读集合和可变集合。

只读集合：对集合只有读取权限。
可变集合：能够删除、新增、修改和读取元素。

但是有一点需要注意，只读集合不一定是不可变的，如果你使用的变量是只读集合，它可能是众多集合引用中的一个，任何一个集合引用都有可能是可变集合。

# Array和IntArray的区别？

Array<Int>相当于Java中的Integer[]，IntArray对应Java中的int[]。

# 使用实化类型参数解决泛型擦除的原理是什么？

内联函数的原理是编译器把实现的字节码动态插入到每一次调用的地方。实化类型参数也正是基于这个原理，每次调用实化类型参数的函数的时候，编译器都知道此次作为泛型类型实参的具体类型，所以编译器每次调用的时候生成不同类型实参调用的字节码插入到调用点。

6. 协程

# 协程是什么？协程的有什么特点？

Kotlin官方文档上说：

协程的本质是轻量级的线程。

为什么说它是轻量级的线程，因为从官方角度来讲，创建十万个协程没什么问题打印任务不会存在问题，创建十万个线程会造成内存问题，可能会造成内存溢出。但是这个对比有问题，因为协程本质上是基于Java的线程池的，你去用线程池创建十万个打印任务是不会造成内存溢出的。

从上面我们可以得出结果，协程就是基于线程实现的更上层的Api，只不过它可以用阻塞式的写法写出非阻塞式的代码，避免了大量的回调，核心就是协程可以帮我自动的切换线程。

# 协程的原理？

很多人都会讲，协程中处理耗时任务，协程会先挂起，执行完，再切回来。我在这就浅显的分析这两步。

挂起：协程挂起的时候会从挂起处将后面的代码封装成续体，协程挂起的时候，将挂起的任务根据调度器放到线程池中执行，会有一个线程监视任务的完成情况。
线程切回：监视线程看到任务结束以后，根据需要再切到指定的线程中（主线程or子线程），执行续体中剩余的代码。

详解请查看：

《Kotlin/JVM 协程实现原理》

七、网络

掌握网络知识其实是需要一个系统的过程，在时间充裕的情况下，建议还是系统化的学习。

高频网络知识有TCP、HTTP和HTTPS。

建议阅读：

《趣谈网络协议》

《图解Http》

1. HTTP和HTTPS

# HTTP是哪一层的协议，常见的HTTP状态码有哪些，分别代表什么意思？

HTTP协议是应用层的协议。

常见的HTTP状态码有：

类别	解释
`1xx`	请求已经接收，继续处理
`2xx`	服务器已经正确处理请求，比如`200`
`3xx`	重定向，需要做进一步的处理才能完成请求
`4xx`	服务器无法理解的请求，比如`404`，访问的资源不存在
`5xx`	服务器收到请求以后，处理错误
#### # HTTP 1.1 和HTTP 2有什么区别？
HTTP 2.0基于HTTP 1.1，与HTTP 2.0增加了：

二进制格式：HTTP 1.1使用纯文本进行通信，HTTP 2.0使用二进制进行传输。
Head压缩：对已经发送的Header使用键值建立索引表，相同的Header使用索引表示。
服务器推送：服务器可以进行主动推送
多路复用：一个TCP连接可以划分成多个流，每个流都会分配Id，客户端可以借助流和服务端建立全双工进行通信，并且流具有优先级。

HTTP2连接

# HTTP和HTTPS有什么区别？

简单来说，HTTP和HTTPS的关系是这样的

HTTPS = HTTP + SSL/TLS

总结

Android架构学习进阶是一条漫长而艰苦的道路，不能靠一时激情，更不是熬几天几夜就能学好的，必须养成平时努力学习的习惯。所以：贵在坚持！

上面分享的字节跳动公司2021年的面试真题解析大全，笔者还把一线互联网企业主流面试技术要点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节。

【Android高级架构视频学习资源】

Android部分精讲视频领取学习后更加是如虎添翼！进军BATJ大厂等（备战）！现在都说互联网寒冬，其实无非就是你上错了车，且穿的少（技能），要是你上对车，自身技术能力够强，公司换掉的代价大，怎么可能会被裁掉，都是淘汰末端的业务Curd而已！现如今市场上初级程序员泛滥，这套教程针对Android开发工程师1-6年的人员、正处于瓶颈期，想要年后突破自己涨薪的，进阶Android中高级、架构师对你更是如鱼得水，赶快领取吧！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注Android）