Android面试真题《思考及解答》10月刊

最新推荐文章于 2024-07-09 18:22:48 发布

陈小刀砍一刀

最新推荐文章于 2024-07-09 18:22:48 发布

阅读量367

点赞数

分类专栏：面试 Android 移动开发文章标签： android kotlin 小程序程序人生面试

本文链接：https://blog.csdn.net/m0_59484713/article/details/118387986

版权

前言嗨，大家好，好久不见。今天就总结下之前一个多月看到的一些面试题，难度不大，大佬可以直接路过，当然发发善心点个赞也是可以的❤️。进入正题，下面为10月刊内容，每三个问题为一个小节，也就是一个专题文章，我就不具体区分了，由于字数问题，也只节选了一些问题，大家见谅。另外答的不好的地方大家也可以留言敲敲我，感谢。要声明的是，大家不要背题哈，面试题只是为了帮助大家复习，扩展自己的知识面，取长补短，答案也是仅供参考。不懂的地方还是要自己好好看看相关知识点，只是看题也是没用的，最后希望大家都能找到满意的工作～

摘要由CSDN通过智能技术生成

前言

嗨，大家好，好久不见。

今天就总结下之前一个多月看到的一些面试题，难度不大，大佬可以直接路过，当然发发善心点个赞也是可以的❤️。

进入正题，下面为10月刊内容，每三个问题为一个小节，也就是一个专题文章，我就不具体区分了，由于字数问题，也只节选了一些问题，大家见谅。另外答的不好的地方大家也可以留言敲敲我，感谢。

要声明的是，大家不要背题哈，面试题只是为了帮助大家复习，扩展自己的知识面，取长补短，答案也是仅供参考。不懂的地方还是要自己好好看看相关知识点，只是看题也是没用的，最后希望大家都能找到满意的工作～

10月刊内容

网页中输入url，到渲染整个界面的整个过程，以及中间用了什么协议？

1）过程分析：主要分为三步

DNS解析。用户输入url后，需要通过DNS解析找到域名对应的ip地址，有了ip地址才能找到服务器端。首先会查找浏览器缓存，是否有对应的dns记录。再继续按照操作系统缓存—路由缓存—isp的dns服务器—根服务器的顺序进行DNS解析，直到找到对应的ip地址。
客户端（浏览器）和服务器交互。浏览器根据解析到的ip地址和端口号发起HTTP请求，请求到达传输层，这里也就是TCP层，开始三次握手建立连接。服务器收到请求后，发送相应报文给客户端（浏览器），客户端收到相应报文并进行解析，得到html页面数据，包括html，js，css等。
客户端（浏览器）解析html数据，构建DOM树，再构造呈现树（render树），最终绘制到浏览器页面上。

2）其中涉及到TCP/IP协议簇，包括DNS，TCP，IP，HTTP协议等等。

具体介绍下TCP/IP

TCP/IP一般指的是TCP/IP协议簇，主要包括了多个不同网络间实现信息传输涉及到的各种协议主要包括以下几层：

应用层：主要提供数据和服务。比如HTTP，FTP，DNS等
传输层：负责数据的组装，分块。比如TCP，UDP等
网络层：负责告诉通信的目的地，比如IP等
数据链路层：负责连接网络的硬件部分，比如以太网，WIFI等

TCP的三次握手和四次挥手，为什么不是两次握手？为什么挥手多一次呢？

客户端简称A，服务器端简称B 1）TCP建立连接需要三次握手

A向B表示想跟B进行连接（A发送syn包，A进入SYN_SENT状态）
B收到消息，表示我也准备好和你连接了（B收到syn包，需要确认syn包，并且自己也发送一个syn包，即发送了syn+ack包，B进入SYN_RECV状态）
A收到消息，并告诉B表示我收到你也准备连接的信号了（A收到syn+ack包，向服务器发送确认包ack，AB进入established状态）开始连接。

2）TCP断开连接需要四次挥手

A向B表示想跟B断开连接（A发送fin，进入FIN_WAIT_1状态）
B收到消息，但是B消息没发送完，只能告诉A我收到你的断开连接消息（B收到fin，发送ack，进入CLOSE_WAIT状态，A进入FIN-WAIT-2状态）
过一会，B数据发送完毕，告诉A，我可以跟你断开了（B发送fin，进入LAST_ACK状态，A进入TIME-WAIT状态）
A收到消息，告诉B，可以他断开（A收到fin，发送ack，B进入closed状态）

3）为什么挥手多一次其实正常的断开和连接都是需要四次：

A发消息给B
B反馈给A表示正确收到消息
B发送消息给A
A反馈给B表示正确收到消息。

但是连接中，第二步和第三步是可以合并的，因为连接之前A和B是无联系的，所以没有其他情况需要处理。而断开的话，因为之前两端是正常连接状态，所以第二步的时候不能保证B之前的消息已经发送完毕，所以不能马上告诉A要断开的消息。这就是连接为什么可以少一步的原因。

4）为什么连接需要三次，而不是两次。正常来说，我给你发消息，你告诉我能收到，不就代表我们之前通信是正常的吗？

简单回答就是，TCP是双向通信协议，如果两次握手，不能保证B发给A的消息正确到达。

TCP 协议为了实现可靠传输，通信双方需要判断自己已经发送的数据包是否都被接收方收到，如果没收到，就需要重发。

TCP是怎么保证可靠传输的？

序列号和确认号。比如连接的一方发送一段80byte数据，会带上一个序列号，比如101。接收方收到数据，回复确认号181（180+1），这样下一次发送消息就会从181开始发送了。

所以握手过程中，比如A发送syn信号给B，初始序列号为120，那么B收到消息，回复ack消息，序列号为120+1。同时B发送syn信号给A，初始序列号为256，如果收不到A的回复消息，就会重发，否则丢失这个序列号，就无法正常完成后面的通信了。

这就是三次握手的原因。

TCP和UDP的区别？

TCP提供的是面向连接，可靠的字节流服务。即客户和服务器交换数据前，必须现在双方之间建立一个TCP连接（三次握手），之后才能传输数据。并且提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端传到另一端。

UDP 是一个简单的面向数据报的运输层协议。它不提供可靠性，只是把应用程序传给IP层的数据报发送出去，但是不能保证它们能到达目的地。由于UDP在传输数据报前不用再客户和服务器之间建立一个连接，且没有超时重发等机制，所以传输速度很快。

所以总结下来就是：

TCP 是面向连接的，UDP 是面向无连接的
TCP数据报头包括序列号，确认号，等等。相比之下UDP程序结构较简单。
TCP 是面向字节流的，UDP 是基于数据报的
TCP 保证数据正确性，UDP 可能丢包
TCP 保证数据顺序，UDP 不保证

可以看到TCP适用于稳定的应用场景，他会保证数据的正确性和顺序，所以一般的浏览网页，接口访问都使用的是TCP传输，所以才会有三次握手保证连接的稳定性。而UDP是一种结构简单的协议，不会考虑丢包啊，建立连接等。优点在于数据传输很快，所以适用于直播，游戏等场景。

HTTP的几种请求方法具体介绍

常见的有四种：

GET 获取资源，没有body，幂等性
POST 增加或者修改资源，有body
PUT 修改资源，有body，幂等性
DELETE 删除资源，幂等性

HTTP请求和响应报文的格式，以及常用状态码

1）请求报文：

 //请求行（包括method、path、HTTP版本）
   GET /s HTTP/1.1
   //Headers
   Host: www.baidu.com
   Content-Type: text/plain
   //Body
   搜索****

2）响应报文

 //状态行 （包括HTTP版本、状态码，状态信息）
   HTTP/1.1 200 OK
   //Headers
   Content-Type: application/json; charset=utf-8
   //Body
   [{"info":"xixi"}]

3）常用状态码

主要分为五种类型：

1开头，代表临时性消息，比如100（继续发送）
2开头，代表请求成功，比如200（OK）
3开头，代表重定向，比如304（内容无改变）
4开头，代表客户端的一些错误，比如403（禁止访问）
5开头，代表服务器的一些错误，比如500

介绍对称加密和非对称加密

1）对称加密，即加密和解密算法不同，但是密钥相同。比如DES，AES算法。

数据A --> 算法D（密钥S）--> 加密数据B
加密数据B --> 算法E（密钥S）--> 数据A

优点：缺点：密钥有可能被破解，容易被伪造。传输过程中一旦密钥被其他人获知则可以进行数据解密。

2）非对称加密，即加密和解密算法相同，但是密钥不同。私钥自己保存，公钥提供给对方。比如RSA，DSA算法。

数据A --> 算法D（公钥）--> 加密数据B
加密数据B --> 算法D（私钥）--> 数据A

优点：安全，公钥即使被其他人获知，也无法解密数据。缺点：需要通信双方都有一套公钥和私钥

数字签名的原理

1）首先，为什么需要数字签名？

防止被攻击，被伪造。由于公钥是公开的，别人截获到公钥就能伪造数据进行传输，所以我们需要验证数据的来源。

2）怎么签名？

由于公钥能解密私钥加密的数据，所以私钥也能解密公钥加密的数据。（上图非对称加密A和B代号互换即可）所以我们用公钥进行加密后，生成加密数据。再用私钥对数据的摘要（hash值）进行一次加密，那么私钥的这次加密就叫签名，也就是只有我自己可以进行加密的操作。所以传输数据流程就变成了加密数据和签名数据，如果解出来都是同样的数据及其摘要信息，那么则数据安全可靠。

数据A --> 算法D（公钥）--> 加密数据B
数据A摘要--> 算法D（私钥）--> 签名数据C

加密数据B --> 算法D（私钥）--> 数据A -->数据A摘要
签名数据C --> 算法D（公钥）--> 数据A摘要

这样加了签名数据，就能保证原数据也就是数据A确实是从正确的发送方发出的，且是没有被修改过的完整原数据。

Base64算法是什么，是加密算法吗？

Base64是一种将二进制数据转换成64种字符组成的字符串的编码算法，主要用于非文本数据的传输，比如图片。可以将图片这种二进制数据转换成具体的字符串，进行保存和传输。
严格来说，不算。虽然它确实把一段二进制数据转换成另外一段数据，但是他的加密和解密是公开的，也就无秘密可言了。所以我更倾向于认为它是一种编码，每个人都可以用base64对二进制数据进行编码和解码。
面试加分项：为了减少混淆，方便复制，减少数据长度，就衍生出一种base58编码。去掉了base64中一些容易混淆的数字和字母（数字0，字母O，字母I，数字1，符号+，符号/）

大名鼎鼎的比特币就是用的改进后的base58编码，即Base58Check编码方式，有了校验机制，加入了hash值。

为什么多线程同时访问（读写）同个变量，会有并发问题？

Java 内存模型规定了所有的变量都存储在主内存中，每条线程有自己的工作内存。
线程的工作内存中保存了该线程中用到的变量的主内存副本拷贝，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存。
线程访问一个变量，首先将变量从主内存拷贝到工作内存，对变量的写操作，不会马上同步到主内存。
不同的线程之间也无法直接访问对方工作内存中的变量，线程间变量的传递均需要自己的工作内存和主存之间进行数据同步。

说说原子性，可见性，有序性分别是什么意思？

原子性：在一个操作中，CPU 不可以在中途暂停然后再调度，即不被中断操作，要么执行完成，要么就不执行。
可见性：多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
有序性：程序执行的顺序按照代码的先后顺序执行。

实际项目过程中，有用到多线程并发问题的例子吗？

有，比如单例模式。
由于单例模式的特殊性，可能被程序中不同地方多个线程同时调用，所以为了避免多线程并发问题，一般要采用volatile+Synchronized的方式进行变量，方法保护。

 private volatile static Singleton singleton;

    public static Singleton getSingleton4() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }

        }
        return singleton;
    }

介绍几种启动模式。

standard,默认模式，每次启动都会新建一个Activity实例，并进入当前任务栈
singleTop，如果要启动的Activity在栈顶存在实例，则不会重新创建Activity，而是直接使用栈顶的Activity实例，并回调onNewIntent方法。
singleTask，如果要启动的Activity在栈中存在实例，则不会重新创建Activity，而是直接使用栈里的Activity实例，并回调onNewIntent方法。并且会把这个实例放到栈顶，之前在这个Activity之上的都会被出栈销毁。
singleInstance，有点单例的感觉，就是所启动的Activity会单独放在一个任务栈里，并且后续所有启动该Activity都会直接用这个实例，同样被重复调用的时候会调用并回调onNewIntent方法。

Activity依次A→B→C→B，其中B启动模式为singleTask，AC都为standard，生命周期分别怎么调用？如果B启动模式为singleInstance又会怎么调用？B启动模式为singleInstance不变，A→B→C的时候点击两次返回，生命周期如何调用。

1)A→B→C→B,B启动模式为singleTask

启动A的过程，生命周期调用是 (A)onCreate→(A)onStart→(A)onResume
再启动B的过程，生命周期调用是 (A)onPause→(B)onCreate→(B)onStart→(B)onResume→(A)onStop
B→C的过程同上
C→B的过程，由于B启动模式为singleTask，所以B会调用onNewIntent，并且将B之上的实例移除，也就是C会被移出栈。所以生命周期调用是 ©onPause→(B)onNewIntent→(B)onRestart→(B)onStart→(B)onResume→©onStop→©onDestory

2)A→B→C→B,B启动模式为singleInstance

如果B为singleInstance，那么C→B的过程，C就不会被移除，因为B和C不在一个任务栈里面。所以生命周期调用是 ©onPause→(B)onNewIntent→(B)onRestart→(B)onStart→(B)onResume→©onStop

3)A→B→C,B启动模式为singleInstance,点击两次返回键

如果B为singleInstance，A→B→C的过程，生命周期还是同前面一样正常调用。但是点击返回的时候，由于AC同任务栈，所以C点击返回，会回到A，再点击返回才回到B。所以生命周期是：©onPause→(A)onRestart→(A)onStart→(A)onResume→©onStop→©onDestory。
再次点击返回，就会回到B，所以生命周期是：(A)onPause→(B)onRestart→(B)onStart→(B)onResume→(A)onStop→(A)onDestory。

屏幕旋转时Activity的生命周期，如何防止Activity重建。

切换屏幕的生命周期是：onConfigurationChanged->onPause->onSaveInstanceState->onStop->onDestroy->onCreate->onStart->onRestoreInstanceState->onResume
如果需要防止旋转时候，Activity重新创建的话需要做如下配置：

在targetSdkVersion的值小于或等于12时，配置 android:configChanges=“orientation|keyboardHidden”，在targetSdkVersion的值大于12时，配置 android:configChanges=“orientation|keyboardHidden|screenSize”

线程的三种启动实现写法

1）继承thread类

 class MyThread :Thread(){
        override fun run() {
            super.run()
        }
    }

    fun test(){
        var t1=MyThread()
        t1.start()
    }

2)实现runnable接口

 class MyRunnable : Runnable {
        override fun run() {

        }
    }

    fun test() {
        var t1 = Thread(MyRunnable(),"test")
        t1.start()
    }

3)实现 Callable 接口

 class MyCallThread : Callable<String> {
        override fun call(): String {
            return "i got it"
        }

    }

    fun test() {
        var task = FutureTask(MyCallThread())
        var t1 = Thread(task, "test")
        t1.start()
        try {
            //获取结果
            var result = task.get()
        } catch (e: Exception) {
        }
    }

也有人表示其实是两个方法，因为第三个方法FutureTask也是实现了Runnable的方法，只不过表现方法不一样，然后带返回值。这个大家面试的时候可以都说上，然后说说自己的见解，毕竟要让面试官多多看到你的知识面。

线程run和start的区别

start方法,用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体中的代码执行完毕而直接继续执行后续的代码。通过调用Thread类的 start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法，这里的run()方法称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。
run方法，run方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。

简单的说就是：调用start方法方可启动线程，而run方法只是thread类中的一个普通方法调用，不用启动新线程，还是在主线程里执行。

线程的几种状态，相互之间是如何转化的

1） 初始状态（New）。新创建了一个线程对象就进入了初始状态，也就是通过上述新建线程的几个方法就能进入该状态。

2） 可运行状态，就绪状态(RUNNABLE)。线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权。以下几种方式会进入可运行状态：

调用start方法。
拿到对象锁
调用yield方法

3）运行状态(RUNNING)。可运行状态(runnable)的线程获得了cpu 时间片，执行程序代码。线程调度程序从可运行池中选择一个线程作为当前线程，就会进入运行状态。

4）阻塞状态(BLOCKED)。线程正在运行的时候，被暂停，通常是为了等待某个时间的发生（比如说某项资源就绪）之后再继续运行。wait，sleep,suspend等方法都可以导致线程阻塞。

5）死亡状态(DEAD)。线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

String是java中的基本数据类型吗？是可变的吗？是线程安全的吗？

String不是基本数据类型，java中把大数据类型是：byte, short, int, long, char, float, double, boolean
String是不可变的
String是不可变类，一旦创建了String对象，我们就无法改变它的值。因此，它是线程安全的，可以安全地用于多线程环境中

为什么要设计成不可变的呢？如果String是不可变的，那我们平时赋值是改的什么呢？

1）为什么设计不可变

安全。由于String广泛用于java类中的参数，所以安全是非常重要的考虑点。包括线程安全，打开文件，存储数据密码等等。
String的不变性保证哈希码始终一，所以在用于HashMap等类的时候就不需要重新计算哈希码，提高效率。
因为java字符串是不可变的，可以在java运行时节省大量java堆空间。因为不同的字符串变量可以引用池中的相同的字符串。如果字符串是可变得话，任何一个变量的值改变，就会反射到其他变量，那字符串池也就没有任何意义了。

2）平时使用双引号方式赋值的时候其实是返回的字符串引用,并不是改变了这个字符串对象

浅谈一下String, StringBuffer，StringBuilder的区别？String的两种创建方式，在JVM的存储方式相同吗？

String是不可变类，每当我们对String进行操作的时候，总是会创建新的字符串。操作String很耗资源,所以Java提供了两个工具类来操作String - StringBuffer和StringBuilder。

StringBuffer和StringBuilder是可变类，StringBuffer是线程安全的，StringBuilder则不是线程安全的。所以在多线程对同一个字符串操作的时候，我们应该选择用StringBuffer。由于不需要处理多线程的情况，StringBuilder的效率比StringBuffer高。

1） String常见的创建方式有两种

String s1 = “Java”

最低0.47元/天解锁文章

陈小刀砍一刀

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android面试真题《思考及解答》10月刊

前言嗨，大家好，好久不见。今天就总结下之前一个多月看到的一些面试题，难度不大，大佬可以直接路过，当然发发善心点个赞也是可以的❤️。进入正题，下面为10月刊内容，每三个问题为一个小节，也就是一个专题文章，我就不具体区分了，由于字数问题，也只节选了一些问题，大家见谅。另外答的不好的地方大家也可以留言敲敲我，感谢。要声明的是，大家不要背题哈，面试题只是为了帮助大家复习，扩展自己的知识面，取长补短，答案也是仅供参考。不懂的地方还是要自己好好看看相关知识点，只是看题也是没用的，最后希望大家都能找到满意的工作～
复制链接

扫一扫