Android 面试主题整理合集（三），Android 屏幕适配很难嘛其实也就那么回事

第一层判断主要是为了避免不必要的同步

第二层的判断则是为了在 null 的情况下创建实例。mInstance = new TestInstance(); 这个步骤，其实在 jvm 里面的执行分为三步：

1.在堆内存开辟内存空间;

2.初始化对象;

3.把对象指向堆内存空间;

由于在 JDK 1.5 以前 Java 编译器允许处理器乱序执行。不过在 JDK 1.5 之后，官方也发现了这个问题，故而具体化了 volatile ，即在 JDK 1.6 以后，只要定义为 private volatile static DaoManager3 sinstance ; 就可解决 DCL 失效问题

5.OkHttp 中的责任链

=============

public interface Interceptor {

//每一层的拦截器接口，需要进行实现 Chain：串连拦截器的链

Response intercept(Chain chain) throws IOException;

//链主要有两个方法:拿到 Request；通过 Request 拿到 Response

interface Chain {

Request request();

Response proceed(Request request):Response throws IOException;//负责往下执行

}

}

链

public class RealInterceptorChain implements Interceptor.Chain {

final List<Interceptor> interceptors;//节点的列表

final int index;//当前节点的 index,通过 index 和 interceptors 就可以拿到所有节点

final Request request;//请求

public RealInterceptorChain(List<Interceptor> interceptors, int index, Request request){

this.interceptors = interceptors;

this.index = index;

this.request = request;

}

@Override

public Request request() {

return request;

}

@Override

public Response proceed(Request request) throws IOException {

RealInterceptorChain next = new RealInterceptorChain(interceptors, index + 1, request);

//next 传到当前节点，当前节点处理好 request 后就可以通过 next 执行 proceed 方法，将 request 传递到下一节点

Interceptor interceptor = interceptors.get(index);

Response response = interceptor.intercept(next);

return response;

}

}

拦截器

public class BridgeInterceptor implements Interceptor{

@Override

public Response intercept(Chain chain) throws IOException {

Log.e("TAG","BridgeInterceptor");

Request request = chain.request();

// 添加一些请求头

request.header("Connection","keep-alive");

// 做一些其他处理

if(request.requestBody()!=null){

RequestBody requestBody = request.requestBody();

request.header("Content-Type",requestBody.getContentType());

request.header("Content-Length",Long.toString(requestBody.getContentLength()));

}

Response response = chain.proceed(request);//这里的 chain 就是

《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》
浏览器打开：qq.cn.hn/FTe 免费领取

传进来的 next，next 的 index 已经加 1

return response;

}

}

RealCall 中 excute()方法

protected void execute() {

final Request request = orignalRequest;

try {

List<Interceptor> interceptors = new ArrayList<>();

interceptors.add(new BridgeInterceptor());

interceptors.add(new CacheInterceptor());

interceptors.add(new CallServerInterceptor());

Interceptor.Chain chain = new RealInterceptorChain(interceptors,0,orignalRequest);

Response response = chain.proceed(request);

callback.onResponse(RealCall.this,response);

} catch (IOException e) {

callback.onFailure(RealCall.this,e);

}

}

算法

1.反转单链表

=======

class Node{

private int data;

private Node next;

public Node(int data,Node next){

this.data=data;

this.next=next;

}

}

Node node4 = new Node(4, null);

Node node3 = new Node(3, node4);

Node node2 = new Node(2, node3);

Node node1 = new Node(1, node2);

Node pHead = node1;//头结点

这组链表从 1 到 4 排序,要求反转后 4 到 1

public static Node reverseList(Node pHead) {

Node pReversedHead = null; //反转过后的单链表存储头结点

Node pNode = pHead; //当前节点

Node pPrev = null; //前一结点

while (pNode != null) {

//1.记录 next,下一步:更新当前节点的上一节点和本身。最后移动一位

Node pNext = pNode.next;

if (pNext == null) {

//到了尾节点

pReversedHead = pNode;

}

pNode.next = pPrev;

pPrev = pNode;

pNode = pNext;

}

return pReversedHead;

}

//递归方式反转(node1->node2->node3->node4->node5)

public static ListNode reverseR(Node head){

//空链表和一个结点的链表无需反转

if(head == null || head.next == null){

return head;

}

//递归到 node4(head)时回溯时,reverseR(node4.next)直接返回 node5

Node res = reverseR(head.next);

//递归回溯时,此时 head 指向 node4,将 node4 的 next(node5)的 next 指向 node4(head)

head.next.next = head;

//将 node4.next 指向 null

head.next = null;

return res;

}

输出

pHead = reverseList(pHead);//反转之后头结点

while (pHead != null) {

System.out.println(pHead.key);

pHead = pHead.next;

}

2.LRU 算法(最近最少使用算法)

=================