金三银四，来一波Android面试(附答案)

Posted 2021-04-27 Java和Android架构

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了金三银四，来一波Android面试(附答案)相关的知识，希望对你有一定的参考价值。

热文导读| 点击标题阅读

来源：BlackFlag

https://www.jianshu.com/p/564b3920697a

JAVA面试题

1.GC机制

垃圾回收需要完成两件事：找到垃圾，回收垃圾。
找到垃圾一般的话有两种方法：

引用计数法
当一个对象被引用时，它的引用计数器会加一，垃圾回收时会清理掉引用计数为0的对象。但这种方法有一个问题，比方说有两个对象A和B，A引用了B，B又引用了A，除此之外没有别的对象引用A和B，那么A和B在我们看来已经是垃圾对象，需要被回收，但它们的引用计数不为0，没有达到回收的条件。正因为这个循环引用的问题，Java并没有采用引用计数法。
可达性分析法
我们把Java中对象引用的关系看做一张图，从根级对象不可达的对象会被垃圾收集器清除。根级对象一般包括Java虚拟机栈中的对象、本地方法栈中的对象、方法区中的静态对象和常量池中的常量。
回收垃圾的话有这么四种方法：
标记清除算法
顾名思义分为两步，标记和清除。首先标记到需要回收的垃圾对象，然后回收掉这些垃圾对象。标记清除算法的缺点是清除垃圾对象后会造成内存的碎片化。
复制算法
复制算法是将存活的对象复制到另一块内存区域中，并做相应的内存整理工作。复制算法的优点是可以避免内存碎片化，缺点也显而易见，它需要两倍的内存。
标记整理算法
标记整理算法也是分两步，先标记后整理。它会标记需要回收的垃圾对象，清除掉垃圾对象后会将存活的对象压缩，避免了内存的碎片化。
分代算法
分代算法将对象分为新生代和老年代对象。那么为什么做这样的区分呢？主要是在Java运行中会产生大量对象，这些对象的生命周期会有很大的不同，有的生命周期很长，有的甚至使用一次之后就不再使用。所以针对不同生命周期的对象采用不同的回收策略，这样可以提高GC的效率。
新生代对象分为三个区域：Eden区和两个Survivor区。新创建的对象都放在Eden区，当Eden区的内存达到阈值之后会触发Minor GC，这时会将存活的对象复制到一个Survivor区中，这些存活对象的生命存活计数会加一。这时Eden区会闲置，当再一次达到阈值触发Minor GC时，会将Eden区和之前一个Survivor区中存活的对象复制到另一个Survivor区中，采用的是我之前提到的复制算法，同时它们的生命存活计数也会加一。这个过程会持续很多遍，直到对象的存活计数达到一定的阈值后会触发一个叫做晋升的现象：新生代的这个对象会被放置到老年代中。
老年代中的对象都是经过多次GC依然存活的生命周期很长的Java对象。当老年代的内存达到阈值后会触发Major GC，采用的是标记整理算法。

2.JVM内存区域的划分，哪些区域会发生OOM

JVM的内存区域可以分为两类：线程私有和区域和线程共有的区域。
线程私有的区域：程序计数器、JVM虚拟机栈、本地方法栈
线程共有的区域：堆、方法区、运行时常量池

JVM虚拟机栈。创建线程的时候会创建线程内的虚拟机栈，栈中存放着一个个的栈帧，对应着一个个方法的调用。JVM虚拟机栈有两种操作，分别是压栈和出站。栈帧中存放着局部变量表、方法返回值和方法的正常或异常退出的定义等等。
本地方法栈。跟JVM虚拟机栈比较类似，只不过它支持的是Native方法。
堆。堆是内存管理的核心区域，用来存放对象实例。几乎所有创建的对象实例都会直接分配到堆上。所以堆也是垃圾回收的主要区域，垃圾收集器会对堆有着更细的划分，最常见的就是把堆划分为新生代和老年代。
方法区。方法区主要存放类的结构信息，比如静态属性和方法等等。
运行时常量池。运行时常量池位于方法区中，主要存放各种常量信息。

其实除了程序计数器，其他的部分都会发生OOM。

堆。通常发生的OOM都会发生在堆中，最常见的可能导致OOM的原因就是内存泄漏。
JVM虚拟机栈和本地方法栈。当我们写一个递归方法，这个递归方法没有循环终止条件，最终会导致StackOverflow的错误。当然，如果栈空间扩展失败，也是会发生OOM的。
方法区。方法区现在基本上不太会发生OOM，但在早期内存中加载的类信息过多的情况下也是会发生OOM的。

3.类加载过程，双亲委派模型

Java中类加载分为3个步骤：加载、链接、初始化。

加载。加载是将字节码数据从不同的数据源读取到JVM内存，并映射为JVM认可的数据结构，也就是Class对象的过程。数据源可以是Jar文件、Class文件等等。如果数据的格式并不是ClassFile的结构，则会报ClassFormatError。

链接。链接是类加载的核心部分，这一步分为3个步骤：验证、准备、解析。

验证。验证是保证JVM安全的重要步骤。JVM需要校验字节信息是否符合规范，避免恶意信息和不规范数据危害JVM运行安全。如果验证出错，则会报VerifyError。
准备。这一步会创建静态变量，并为静态变量开辟内存空间。
解析。这一步会将符号引用替换为直接引用。
初始化。初始化会为静态变量赋值，并执行静态代码块中的逻辑。

双亲委派模型。

类加载器大致分为3类：启动类加载器、扩展类加载器、应用程序类加载器。
启动类加载器主要加载 jre/lib下的jar文件。
扩展类加载器主要加载 jre/lib/ext 下的jar文件。
应用程序类加载器主要加载 classpath下的文件。

所谓的双亲委派模型就是当加载一个类时，会优先使用父类加载器加载，当父类加载器无法加载时才会使用子类加载器去加载。这么做的目的是为了避免类的重复加载。

4.HashMap的原理

HashMap的内部可以看做数组+链表的复合结构。数组被分为一个个的桶(bucket)。哈希值决定了键值对在数组中的寻址。具有相同哈希值的键值对会组成链表。需要注意的是当链表长度超过阈值(默认是8)的时候会触发树化，链表会变成树形结构。

把握HashMap的原理需要关注4个方法：hash、put、get、resize。

hash方法。将key的hashCode值的高位数据移位到低位进行异或运算。这么做的原因是有些key的hashCode值的差异集中在高位，而哈希寻址是忽略容量以上高位的，这种做法可以有效避免哈希冲突。

put方法。put方法主要有以下几个步骤：

通过hash方法获取hash值，根据hash值寻址。
如果未发生碰撞，直接放到桶中。
如果发生碰撞，则以链表形式放在桶后。
当链表长度大于阈值后会触发树化，将链表转换为红黑树。
如果数组长度达到阈值，会调用resize方法扩展容量。

get方法。get方法主要有以下几个步骤：

通过hash方法获取hash值，根据hash值寻址。
如果与寻址到桶的key相等，直接返回对应的value。
如果发生冲突，分两种情况。如果是树，则调用getTreeNode获取value；如果是链表则通过循环遍历查找对应的value。

resize方法。resize做了两件事：

将原数组扩展为原来的2倍
重新计算index索引值，将原节点重新放到新的数组中。这一步可以将原先冲突的节点分散到新的桶中。

5.什么情况下Java会产生死锁，如何定位、修复，手写死锁
答案略

6.sleep和wait的区别

sleep方法是Thread类中的静态方法，wait是Object类中的方法
sleep并不会释放同步锁，而wait会释放同步锁
sleep可以在任何地方使用，而wait只能在同步方法或者同步代码块中使用
sleep中必须传入时间，而wait可以传，也可以不传，不传时间的话只有notify或者notifyAll才能唤醒，传时间的话在时间之后会自动唤醒

7.join的用法

join方法通常是保证线程间顺序调度的一个方法，它是Thread类中的方法。比方说在线程A中执行线程B.join()，这时线程A会进入等待状态，直到线程B执行完毕之后才会唤醒，继续执行A线程中的后续方法。

join方法可以传时间参数，也可以不传参数，不传参数实际上调用的是join(0)。它的原理其实是使用了wait方法，join的原理如下：

public final synchronized void join(long millis)
   throws InterruptedException {
       long base = System.currentTimeMillis();
       long now = 0;

       if (millis < 0) {
           throw new IllegalArgumentException("timeout value is negative");
       }

       if (millis == 0) {
           while (isAlive()) {
               wait(0);
           }
       } else {
           while (isAlive()) {
               long delay = millis - now;
               if (delay <= 0) {
                   break;
               }
               wait(delay);
               now = System.currentTimeMillis() - base;
           }
       }
   }

8.volatile和synchronize的区别

9.Java中的线程池

10.线程通信

11.Java中的并发集合

12.Java中生产者与消费者模式

生产者消费者模式要保证的是当缓冲区满的时候生产者不再生产对象，当缓冲区空时，消费者不再消费对象。实现机制就是当缓冲区满时让生产者处于等待状态，当缓冲区为空时让消费者处于等待状态。当生产者生产了一个对象后会唤醒消费者，当消费者消费一个对象后会唤醒生产者。

三种种实现方式：wait和notify、await和signal、BlockingQueue。

wait和notify

//wait和notify
import java.util.LinkedList;

public class StorageWithWaitAndNotify {
   private final int                MAX_SIZE = 10;
   private       LinkedList<Object> list     = new LinkedList<Object>();

   public void produce() {
       synchronized (list) {
           while (list.size() == MAX_SIZE) {
               System.out.println("仓库已满：生产暂停");
               try {
                   list.wait();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }

           list.add(new Object());
           System.out.println("生产了一个新产品，现库存为：" + list.size());
           list.notifyAll();
       }
   }

   public void consume() {
       synchronized (list) {
           while (list.size() == 0) {
               System.out.println("库存为0：消费暂停");
               try {
                   list.wait();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }

           list.remove();
           System.out.println("消费了一个产品，现库存为：" + list.size());
           list.notifyAll();
       }
   }


}

await和signal

import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

class StorageWithAwaitAndSignal {
   private final int                MAX_SIZE = 10;
   private       ReentrantLock      mLock    = new ReentrantLock();
   private       Condition          mEmpty   = mLock.newCondition();
   private       Condition          mFull    = mLock.newCondition();
   private       LinkedList<Object> mList    = new LinkedList<Object>();

   public void produce() {
       mLock.lock();
       while (mList.size() == MAX_SIZE) {
           System.out.println("缓冲区满，暂停生产");
           try {
               mFull.await();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }

       mList.add(new Object());
       System.out.println("生产了一个新产品，现容量为：" + mList.size());
       mEmpty.signalAll();

       mLock.unlock();
   }

   public void consume() {
       mLock.lock();
       while (mList.size() == 0) {
           System.out.println("缓冲区为空，暂停消费");
           try {
               mEmpty.await();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }

       mList.remove();
       System.out.println("消费了一个产品，现容量为：" + mList.size());
       mFull.signalAll();

       mLock.unlock();
   }
}

BlockingQueue

import java.util.concurrent.LinkedBlockingQueue;

public class StorageWithBlockingQueue {
   private final int                         MAX_SIZE = 10;
   private       LinkedBlockingQueue<Object> list     = new LinkedBlockingQueue<Object>(MAX_SIZE);

   public void produce() {
       if (list.size() == MAX_SIZE) {
           System.out.println("缓冲区已满，暂停生产");
       }

       try {
           list.put(new Object());
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println("生产了一个产品，现容量为：" + list.size());
   }

   public void consume() {
       if (list.size() == 0) {
           System.out.println("缓冲区为空，暂停消费");
       }

       try {
           list.take();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println("消费了一个产品，现容量为：" + list.size());
   }

}

13.final、finally、finalize区别

final可以修饰类、变量和方法。修饰类代表这个类不可被继承。修饰变量代表此变量不可被改变。修饰方法表示此方法不可被重写(override)。

finally是保证重点代码一定会执行的一种机制。通常是使用try-finally或者try-catch-finally来进行文件流的关闭等操作。

finalize是Object类中的一个方法，它的设计目的是保证对象在垃圾收集前完成特定资源的回收。finalize机制现在已经不推荐使用，并且在JDK 9已经被标记为deprecated。

14.Java中单例模式

Java中常见的单例模式实现有这么几种：饿汉式、双重判断的懒汉式、静态内部类实现的单例、枚举实现的单例。

这里着重讲一下双重判断的懒汉式和静态内部类实现的单例。

双重判断的懒汉式：

public class SingleTon {
   //需要注意的是volatile
   private static volatile SingleTon mInstance;

   private SingleTon() {

   }

   public static SingleTon getInstance() {
       if (mInstance == null) { 
           synchronized (SingleTon.class) {
               if (mInstance == null) {
                   mInstance=new SingleTon();
               }
           }
       }

       return mInstance;
   }
}

双重判断的懒汉式单例既满足了延迟初始化，又满足了线程安全。通过synchronized包裹代码来实现线程安全，通过双重判断来提高程序执行的效率。这里需要注意的是单例对象实例需要有volatile修饰，如果没有volatile修饰，在多线程情况下可能会出现问题。原因是这样的，mInstance=new SingleTon() 这一句代码并不是一个原子操作，它包含三个操作：

给mInstance分配内存
调用SingleTon的构造方法初始化成员变量
将mInstance指向分配的内存空间（在这一步mInstance已经不为null了）

我们知道JVM会发生指令重排，正常的执行顺序是1-2-3，但发生指令重排后可能会导致1-3-2。我们考虑这样一种情况，当线程A执行到1-3-2的3步骤暂停了，这时候线程B调用了getInstance，走到了最外层的if判断上，由于最外层的if判断并没有synchronized包裹，所以可以执行到这一句，这时候由于线程A已经执行了步骤3，此时mInstance已经不为null了，所以线程B直接返回了mInstance。但其实我们知道，完整的初始化必须走完这三个步骤，由于线程A只走了两个步骤，所以一定会报错的。

解决的办法就是使用volatile修饰mInstance，我们知道volatile有两个作用：保证可见性和禁止指令重排，在这里关键在于禁止指令重排，禁止指令重排后保证了不会发生上述问题。

静态内部类实现的单例：

class SingletonWithInnerClass {

   private SingletonWithInnerClass() {

   }

   private static class SingletonHolder{
       private static SingletonWithInnerClass INSTANCE=new SingletonWithInnerClass();
   }

   public SingletonWithInnerClass getInstance() {
       return SingletonHolder.INSTANCE;
   }

}

由于外部类的加载并不会导致内部类立即加载，只有当调用getInstance的时候才会加载内部类，所以实现了延迟初始化。由于类只会被加载一次，并且类加载也是线程安全的，所以满足我们所有的需求。静态内部类实现的单例也是最为推荐的一种方式。

15.Java中引用类型的区别，具体的使用场景

Java中引用类型分为四类：强引用、软引用、弱引用、虚引用。

强引用：强引用指的是通过new对象创建的引用，垃圾回收器即使是内存不足也不会回收强引用指向的对象。

软引用：软引用是通过SoftRefrence实现的，它的生命周期比强引用短，在内存不足，抛出OOM之前，垃圾回收器会回收软引用引用的对象。软引用常见的使用场景是存储一些内存敏感的缓存，当内存不足时会被回收。

弱引用：弱引用是通过WeakRefrence实现的，它的生命周期比软引用还短，GC只要扫描到弱引用的对象就会回收。弱引用常见的使用场景也是存储一些内存敏感的缓存。

虚引用：虚引用是通过FanttomRefrence实现的，它的生命周期最短，随时可能被回收。如果一个对象只被虚引用引用，我们无法通过虚引用来访问这个对象的任何属性和方法。它的作用仅仅是保证对象在finalize后，做某些事情。虚引用常见的使用场景是跟踪对象被垃圾回收的活动，当一个虚引用关联的对象被垃圾回收器回收之前会收到一条系统通知。

16.Exception和Error的区别

Exception和Error都继承于Throwable，在Java中，只有Throwable类型的对象才能被throw或者catch，它是异常处理机制的基本组成类型。

Exception和Error体现了Java对不同异常情况的分类。Exception是程序正常运行中，可以预料的意外情况，可能并且应该被捕获，进行相应的处理。

Error是指在正常情况下，不大可能出现的情况，绝大部分Error都会使程序处于非正常、不可恢复的状态。既然是非正常，所以不便于也不需要捕获，常见的OutOfMemoryError就是Error的子类。

Exception又分为checked Exception和unchecked Exception。checked Exception在代码里必须显式的进行捕获，这是编译器检查的一部分。unchecked Exception也就是运行时异常，类似空指针异常、数组越界等，通常是可以避免的逻辑错误，具体根据需求来判断是否需要捕获，并不会在编译器强制要求。

17.volatile

一般提到volatile，就不得不提到内存模型相关的概念。我们都知道，在程序运行中，每条指令都是由CPU执行的，而指令的执行过程中，势必涉及到数据的读取和写入。程序运行中的数据都存放在主存中，这样会有一个问题，由于CPU的执行速度是要远高于主存的读写速度，所以直接从主存中读写数据会降低CPU的效率。为了解决这个问题，就有了高速缓存的概念，在每个CPU中都有高速缓存，它会事先从主存中读取数据，在CPU运算之后在合适的时候刷新到主存中。

这样的运行模式在单线程中是没有任何问题的，但在多线程中，会导致缓存一致性的问题。举个简单的例子：i=i+1 ,在两个线程中执行这句代码，假设i的初始值为0。我们期望两个线程运行后得到2，那么有这样的一种情况，两个线程都从主存中读取i到各自的高速缓存中，这时候两个线程中的i都为0。在线程1执行完毕得到i=1，将之刷新到主存后，线程2开始执行，由于线程2中的i是高速缓存中的0，所以在执行完线程2之后刷新到主存的i仍旧是1。

所以这就导致了对共享变量的缓存一致性的问题，那么为了解决这个问题，提出了缓存一致性协议：当CPU在写数据时，如果发现操作的是共享变量，它会通知其他CPU将它们内部的这个共享变量置为无效状态，当其他CPU读取缓存中的共享变量时，发现这个变量是无效的，它会从新从主存中读取最新的值。

在Java的多线程开发中，有三个重要概念：原子性、可见性、有序性。
原子性：一个或多个操作要么都不执行，要么都执行。
可见性：一个线程中对共享变量(类中的成员变量或静态变量)的修改，在其他线程立即可见。
有序性：程序执行的顺序按照代码的顺序执行。
把一个变量声明为volatile，其实就是保证了可见性和有序性。
可见性我上面已经说过了，在多线程开发中是很有必要的。这个有序性还是得说一下，为了执行的效率，有时候会发生指令重排，这在单线程中指令重排之后的输出与我们的代码逻辑输出还是一致的。但在多线程中就可能发生问题，volatile在一定程度上可以避免指令重排。

volatile的原理是在生成的汇编代码中多了一个lock前缀指令，这个前缀指令相当于一个内存屏障，这个内存屏障有3个作用：

确保指令重排的时候不会把屏障后的指令排在屏障前，确保不会把屏障前的指令排在屏障后。
修改缓存中的共享变量后立即刷新到主存中。
当执行写操作时会导致其他CPU中的缓存无效。

网络相关面试题

1.http 状态码

2.http 与 https 的区别？https 是如何工作的？

http是超文本传输协议，而https可以简单理解为安全的http协议。https通过在http协议下添加了一层ssl协议对数据进行加密从而保证了安全。https的作用主要有两点：建立安全的信息传输通道，保证数据传输安全；确认网站的真实性。

http与https的区别主要如下：

https需要到CA申请证书，很少免费，因而需要一定的费用
http是明文传输，安全性低；而https在http的基础上通过ssl加密，安全性高
二者的默认端口不一样，http使用的默认端口是80；https使用的默认端口是443

https的工作流程

提到https的话首先要说到加密算法，加密算法分为两类：对称加密和非对称加密。

对称加密：加密和解密用的都是相同的秘钥，优点是速度快，缺点是安全性低。常见的对称加密算法有DES、AES等等。

非对称加密：非对称加密有一个秘钥对，分为公钥和私钥。一般来说，私钥自己持有，公钥可以公开给对方，优点是安全性比对称加密高，缺点是数据传输效率比对称加密低。采用公钥加密的信息只有对应的私钥可以解密。常见的非对称加密包括RSA等。

在正式的使用场景中一般都是对称加密和非对称加密结合使用，使用非对称加密完成秘钥的传递，然后使用对称秘钥进行数据加密和解密。二者结合既保证了安全性，又提高了数据传输效率。

https的具体流程如下：

客户端（通常是浏览器）先向服务器发出加密通信的请求

支持的协议版本，比如TLS 1.0版
一个客户端生成的随机数 random1，稍后用于生成"对话密钥"
支持的加密方法，比如RSA公钥加密
支持的压缩方法

服务器收到请求,然后响应

确认使用的加密通信协议版本，比如TLS 1.0版本。如果浏览器与服务器支持的版本不一致，服务器关闭加密通信
一个服务器生成的随机数random2，稍后用于生成"对话密钥"
确认使用的加密方法，比如RSA公钥加密
服务器证书

客户端收到证书之后会首先会进行验证

首先验证证书的安全性
验证通过之后，客户端会生成一个随机数pre-master secret，然后使用证书中的公钥进行加密，然后传递给服务器端

服务器收到使用公钥加密的内容，在服务器端使用私钥解密之后获得随机数pre-master secret，然后根据radom1、radom2、pre-master secret通过一定的算法得出一个对称加密的秘钥，作为后面交互过程中使用对称秘钥。同时客户端也会使用radom1、radom2、pre-master secret，和同样的算法生成对称秘钥。
然后再后续的交互中就使用上一步生成的对称秘钥对传输的内容进行加密和解密。

3.TCP三次握手流程

Android面试题

1.android中的动画有哪几类，它们的特点和区别是什么

Android中动画大致分为3类：帧动画、补间动画（View Animation）、属性动画（Object Animation）。

帧动画：通过xml配置一组图片，动态播放。很少会使用。
补间动画（View Animation）：大致分为旋转、透明、缩放、位移四类操作。很少会使用。
属性动画（Object Animation）：属性动画是现在使用的最多的一种动画，它比补间动画更加强大。属性动画大致分为两种使用类型，分别是ViewPropertyAnimator和ObjectAnimator。前者适合一些通用的动画，比如旋转、位移、缩放和透明，使用方式也很简单通过View.animate()即可得到ViewPropertyAnimator，之后进行相应的动画操作即可。后者适合用于为我们的自定义控件添加动画，当然首先我们应该在自定义View中添加相应的getXXX()和setXXX()相应属性的getter和setter方法，这里需要注意的是在setter方法内改变了自定义View中的属性后要调用invalidate()来刷新View的绘制。之后调用ObjectAnimator.of属性类型()返回一个ObjectAnimator，调用start()方法启动动画即可。

补间动画与属性动画的区别：

补间动画是父容器不断的绘制view，看起来像移动了效果,其实view没有变化，还在原地。
是通过不断改变view内部的属性值，真正的改变view。

2.Android性能优化工具使用（这个问题建议配合Android中的性能优化）

Android中常用的性能优化工具包括这些：Android Studio自带的Android Profiler、LeakCanary、BlockCanary

Android自带的Android Profiler其实就很好用，Android Profiler可以检测三个方面的性能问题：CPU、MEMORY、NETWORK。

LeakCanary是一个第三方的检测内存泄漏的库，我们的项目集成之后LeakCanary会自动检测应用运行期间的内存泄漏，并将之输出给我们。

BlockCanary也是一个第三方检测UI卡顿的库，项目集成后Block也会自动检测应用运行期间的UI卡顿，并将之输出给我们。

3.Android性能优化

Android中的性能优化在我看来分为以下几个方面：内存优化、布局优化、网络优化、安装包优化。

内存优化：下一个问题就是。

布局优化：布局优化的本质就是减少View的层级。常见的布局优化方案如下

在LinearLayout和RelativeLayout都可以完成布局的情况下优先选择RelativeLayout，可以减少View的层级
将常用的布局组件抽取出来使用 < include > 标签
通过 < ViewStub > 标签来加载不常用的布局
使用 < Merge > 标签来减少布局的嵌套层次

网络优化：常见的网络优化方案如下

尽量减少网络请求，能够合并的就尽量合并
避免DNS解析，根据域名查询可能会耗费上百毫秒的时间，也可能存在DNS劫持的风险。可以根据业务需求采用增加动态更新IP的方式，或者在IP方式访问失败时切换到域名访问方式。
大量数据的加载采用分页的方式
网络数据传输采用GZIP压缩
加入网络数据的缓存，避免频繁请求网络
上传图片时，在必要的时候压缩图片

安装包优化：安装包优化的核心就是减少apk的体积，常见的方案如下

使用混淆，可以在一定程度上减少apk体积，但实际效果微乎其微
减少应用中不必要的资源文件，比如图片，在不影响APP效果的情况下尽量压缩图片，有一定的效果
在使用了SO库的时候优先保留v7版本的SO库，删掉其他版本的SO库。原因是在2018年，v7版本的SO库可以满足市面上绝大多数的要求，可能八九年前的手机满足不了，但我们也没必要去适配老掉牙的手机。实际开发中减少apk体积的效果是十分显著的，如果你使用了很多SO库，比方说一个版本的SO库一共10M，那么只保留v7版本，删掉armeabi和v8版本的SO库，一共可以减少20M的体积。

4.Android内存优化

Android的内存优化在我看来分为两点：避免内存泄漏、扩大内存，其实就是开源节流。

其实内存泄漏的本质就是较长生命周期的对象引用了较短生命周期的对象。

常见的内存泄漏：

单例模式导致的内存泄漏。最常见的例子就是创建这个单例对象需要传入一个Context，这时候传入了一个Activity类型的Context，由于单例对象的静态属性，导致它的生命周期是从单例类加载到应用程序结束为止，所以即使已经finish掉了传入的Activity，由于我们的单例对象依然持有Activity的引用，所以导致了内存泄漏。解决办法也很简单，不要使用Activity类型的Context，使用Application类型的Context可以避免内存泄漏。
静态变量导致的内存泄漏。静态变量是放在方法区中的，它的生命周期是从类加载到程序结束，可以看到静态变量生命周期是非常久的。最常见的因静态变量导致内存泄漏的例子是我们在Activity中创建了一个静态变量，而这个静态变量的创建需要传入Activity的引用this。在这种情况下即使Activity调用了finish也会导致内存泄漏。原因就是因为这个静态变量的生命周期几乎和整个应用程序的生命周期一致，它一直持有Activity的引用，从而导致了内存泄漏。
非静态内部类导致的内存泄漏。非静态内部类导致内存泄漏的原因是非静态内部类持有外部类的引用，最常见的例子就是在Activity中使用Handler和Thread了。使用非静态内部类创建的Handler和Thread在执行延时操作的时候会一直持有当前Activity的引用，如果在执行延时操作的时候就结束Activity，这样就会导致内存泄漏。解决办法有两种：第一种是使用静态内部类，在静态内部类中使用弱引用调用Activity。第二种方法是在Activity的onDestroy中调用handler.removeCallbacksAndMessages来取消延时事件。
使用资源未及时关闭导致的内存泄漏。常见的例子有：操作各种数据流未及时关闭，操作Bitmap未及时recycle等等。
使用第三方库未能及时解绑。有的三方库提供了注册和解绑的功能，最常见的就是EventBus了，我们都知道使用EventBus要在onCreate中注册，在onDestroy中解绑。如果没有解绑的话，EventBus其实是一个单例模式，他会一直持有Activity的引用，导致内存泄漏。同样常见的还有RxJava，在使用Timer操作符做了一些延时操作后也要注意在onDestroy方法中调用disposable.dispose()来取消操作。
属性动画导致的内存泄漏。常见的例子就是在属性动画执行的过程中退出了Activity，这时View对象依然持有Activity的引用从而导致了内存泄漏。解决办法就是在onDestroy中调用动画的cancel方法取消属性动画。
WebView导致的内存泄漏。WebView比较特殊，即使是调用了它的destroy方法，依然会导致内存泄漏。其实避免WebView导致内存泄漏的最好方法就是让WebView所在的Activity处于另一个进程中，当这个Activity结束时杀死当前WebView所处的进程即可，我记得阿里钉钉的WebView就是另外开启的一个进程，应该也是采用这种方法避免内存泄漏。

扩大内存，为什么要扩大我们的内存呢？有时候我们实际开发中不可避免的要使用很多第三方商业的SDK，这些SDK其实有好有坏，大厂的SDK可能内存泄漏会少一些，但一些小厂的SDK质量也就不太靠谱一些。那应对这种我们无法改变的情况，最好的办法就是扩大内存。

扩大内存通常有两种方法：一个是在清单文件中的Application下添加largeHeap="true"这个属性，另一个就是同一个应用开启多个进程来扩大一个应用的总内存空间。第二种方法其实就很常见了，比方说我使用过个推的SDK，个推的Service其实就是处在另外一个单独的进程中。

Android中的内存优化总的来说就是开源和节流，开源就是扩大内存，节流就是避免内存泄漏。

5.Binder机制

在Linux中，为了避免一个进程对其他进程的干扰，进程之间是相互独立的。在一个进程中其实还分为用户空间和内核空间。这里的隔离分为两个部分，进程间的隔离和进程内的隔离。

既然进程间存在隔离，那其实也是存在着交互。进程间通信就是IPC，用户空间和内核空间的通信就是系统调用。

Linux为了保证独立性和安全性，进程之间不能直接相互访问，Android是基于Linux的，所以也是需要解决进程间通信的问题。

其实Linux进程间通信有很多方式，比如管道、socket等等。为什么Android进程间通信采用了Binder而不是Linux已有的方式，主要是有这么两点考虑：性能和安全

性能。在移动设备上对性能要求是比较严苛的。Linux传统的进程间通信比如管道、socket等等进程间通信是需要复制两次数据，而Binder则只需要一次。所以Binder在性能上是优于传统进程通信的。

安全。传统的Linux进程通信是不包含通信双方的身份验证的，这样会导致一些安全性问题。而Binder机制自带身份验证，从而有效的提高了安全性。

Binder是基于CS架构的，有四个主要组成部分。

Client。客户端进程。
Server。服务端进程。
ServiceManager。提供注册、查询和返回代理服务对象的功能。
Binder驱动。主要负责建立进程间的Binder连接，进程间的数据交互等等底层操作。

Binder机制主要的流程是这样的：

服务端通过Binder驱动在ServiceManager中注册我们的服务。
客户端通过Binder驱动查询在ServiceManager中注册的服务。
ServiceManager通过Binder驱动返回服务端的代理对象。
客户端拿到服务端的代理对象后即可进行进程间通信。

6.图片加载如何避免OOM

我们知道内存中的Bitmap大小的计算公式是：长所占像素 * 宽所占像素 * 每个像素所占内存。想避免OOM有两种方法：等比例缩小长宽、减少每个像素所占的内存。

等比缩小长宽。我们知道Bitmap的创建是通过BitmapFactory的工厂方法，decodeFile()、decodeStream()、decodeByteArray()、decodeResource()。这些方法中都有一个Options类型的参数，这个Options是BitmapFactory的内部类，存储着BItmap的一些信息。Options中有一个属性：inSampleSize。我们通过修改inSampleSize可以缩小图片的长宽，从而减少BItmap所占内存。需要注意的是这个inSampleSize大小需要是2的幂次方，如果小于1，代码会强制让inSampleSize为1。
减少像素所占内存。Options中有一个属性inPreferredConfig，默认是ARGB_8888，代表每个像素所占尺寸。我们可以通过将之修改为RGB_565或者ARGB_4444来减少一半内存。

7.数据结构与算法

手写快排

手写归并排序

手写堆以及堆排序

说一下排序算法的区别(时间复杂度和空间复杂度)

工作中解决了什么难题，做了什么有成就感的项目（这个问题一定会问到，所以肯定要做准备）