标签： Android面试题

JAVA 相关

 

1.静态内部类、内部类、匿名内部类，为什么内部类会持有外部类的引用?持有的引用是this?还是其它?

 

静态内部类：使用static修饰的内部类

 

内部类：就是在某个类的内部又定义了一个类，内部类所嵌入的类称为外部类

 

匿名内部类：使用new生成的内部类

 

因为内部类的产生依赖于外部类，持有的引用是类名.this

 

2.Java中try catch finally的执行顺序

 

先执行try中代码，如果发生异常执行catch中代码，*后一定会执行finally中代码

 

3.equals与==的区别：

 

==是判断两个变量或实例是不是指向同一个内存空间 equals是判断两个变量或实例所指向的内存空间的值是不是相

 

4.Object有哪些公用方法?

 

方法equals测试的是两个对象是否相等

 

方法clone进行对象拷贝

 

方法getClass返回和当前对象相关的Class对象

 

方法notify,notifyall,wait都是用来对给定对象进行线程同步的

 

5.String、StringBuffer与StringBuilder的区别

 

String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象 StringBuffer和StringBuilder底层是 char[]数组实现的 StringBuffer是线程安全的，而StringBuilder是线程不安全的

 

6.Java的四种引用的区别

 

强引用：如果一个对象具有强引用，它就不会被垃圾回收器回收。即使当前内存空间不足，JVM 也不会回收它，而是抛出 OutOfMemoryError 错误，使程序异常终止。如果想中断强引用和某个对象之间的关联，可以显式地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象

 

软引用：在使用软引用时，如果内存的空间足够，软引用就能继续被使用，而不会被垃圾回收器回收，只有在内存不足时，软引用才会被垃圾回收器回收。

 

弱引用：具有弱引用的对象拥有的生命周期更短暂。因为当 JVM 进行垃圾回收，一旦发现弱引用对象，无论当前内存空间是否充足，都会将弱引用回收。不过由于垃圾回收器是一个优先级较低的线程，所以并不一定能迅速发现弱引用对象

 

虚引用：顾名思义，就是形同虚设，如果一个对象仅持有虚引用，那么它相当于没有引用，在任何时候都可能被垃圾回收器回收。

 

7.介绍垃圾回收机制

 

标记回收法：遍历对象图并且记录可到达的对象，以便删除不可到达的对象，一般使用单线程工作并且可能产生内存碎片

 

标记-压缩回收法：前期与*种方法相同，只是多了一步，将所有的存活对象压缩到内存的一端，这样内存碎片就可以合成一大块可再利用的内存区域，提高了内存利用率

 

复制回收法：把现有内存空间分成两部分，gc运行时，它把可到达对象复制到另一半空间，再清空正在使用的空间的全部对象。这种方法适用于短生存期的对象，持续复制长生存期的对象则导致效率降低。

 

分代回收发：把内存空间分为两个或者多个域，如年轻代和老年代，年轻代的特点是对象会很快被回收，因此在年轻代使用效率比较高的算法。当一个对象经过几次回收后依然存活，对象就会被放入称为老年的内存空间，老年代则采取标记-压缩算法

集合、数据结构相关

1.你用过哪些集合类

数据结构中用于存储数据的有哪些

数组

数组存储区间是连续的，占用内存严重，故空间复杂的很大。但数组的二分查找时间复杂度小，为O(1);数组的特点是：寻址容易，插入和删除困难;

链表

链表存储区间离散，占用内存比较宽松，故空间复杂度很小，但时间复杂度很大，达O(N)。链表的特点是：寻址困难，插入和删除容易。

2.说说hashMap是怎样实现的

哈希表:由数组+链表组成的

当我们往HashMap中put元素的时候，先根据key的hashCode重新计算hash值，根据hash值得到这个元素在数组中的位置(即下标)，如果数组该位置上已经存放有其他元素了，那么在这个位置上的元素将以链表的形式存放，新加入的放在链头，*先加入的放在链尾。如果数组该位置上没有元素，就直接将该元素放到此数组中的该位置上。

3.ArrayList,LinkedList的区别

ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。

对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

4.ArrayList和Vector的主要区别是什么?

ArrayList 和Vector底层是采用数组方式存储数据

Vector:

线程同步

当Vector中的元素超过它的初始大小时，Vector会将它的容量翻倍，

ArrayList:

线程不同步，但性能很好

当ArrayList中的元素超过它的初始大小时，ArrayList只增加50%的大小

5.HashMap和 HashTable 的区别：

HashTable比较老，是基于Dictionary 类实现的，HashTable 则是基于 Map接口实现的

HashTable 是线程安全的， HashMap 则是线程不安全的

HashMap可以让你将空值作为一个表的条目的key或value

 

算法相关

1.排序算法和稳定性，快排什么时候情况*坏?

2.给*外层的rootview，把这个根视图下的全部button背景设置成红色，手写代码，不许用递归

算法原理：

Android的view视图是按树形结构分布，所以按树形结构遍历

循环判断每一层的ViewGroup元素，将其入栈;否则判断当前view是否是Button类实例，是则改写背景色

当前ViewGroup检查childView完成后，判断栈是否非空，取出栈顶元素ViewGroup重复步骤2直至栈为空。

 

Thread、AsynTask相关

1.wait()和sleep()的区别

sleep来自Thread类，和wait来自Object类

调用sleep()方法的过程中，线程不会释放对象锁。而 调用 wait 方法线程会释放对象锁

sleep睡眠后不出让系统资源，wait让出系统资源其他线程可以占用CPU

sleep(milliseconds)需要指定一个睡眠时间，时间一到会自动唤醒

2.若Activity已经销毁，此时AsynTask执行完并且返回结果，会报异常吗?

当一个App旋转时，整个Activity会被销毁和重建。当Activity重启时，AsyncTask中对该Activity的引用是无效的，因此onPostExecute()就不会起作用，若AsynTask正在执行，折会报 view not attached to window manager 异常

同样也是生命周期的问题，在 Activity 的onDestory()方法中调用Asyntask.cancal方法，让二者的生命周期同步

3.Activity销毁但Task如果没有销毁掉，当Activity重启时这个AsyncTask该如何解决?

还是屏幕旋转这个例子，在重建Activity的时候，会回掉Activity.onRetainNonConfigurationInstance()重新传递一个新的对象给AsyncTask，完成引用的更新

4.Android 线程间通信有哪几种方式(重要)

共享内存(变量);

文件，数据库;

Handler;

Java 里的 wait()，notify()，notifyAll()

5.请介绍下 AsyncTask的内部实现，适用的场景是

AsyncTask 内部也是 Handler 机制来完成的，只不过 Android 提供了执行框架来提供线程池来

执行相应地任务，因为线程池的大小问题，所以 AsyncTask 只应该用来执行耗时时间较短的任务，

比如 HTTP 请求，大规模的下载和数据库的更改不适用于 AsyncTask，因为会导致线程池堵塞，没有

线程来执行其他的任务，导致的情形是会发生 AsyncTask 根本执行不了的问题。

网络相关

1.TCP三次握手

2.为什么TCP是可靠的，UDP早不可靠的?为什么UDP比TCP快?

TCP/IP协议高，因为其拥有三次握手双向机制，这一机制保证校验了数据，保证了他的可靠性。

UDP就没有了，udp信息发出后,不验证是否到达对方,所以不可靠。

但是就速度来说，还是UDP协议更高，毕竟其无需重复返回验证，只是一次性的

3.http协议了解多少，说说里面的协议头部有哪些字段?

http(超文本传输协议)是一个基于请求与响应模式的、无状态的、应用层的协议;http请求由三部分组成，分别是：请求行、消息报头、请求正文。

HTTP消息报头包括普通报头、请求报头、响应报头、实体报头

4.https了解多少

HTTPS(全称：Hyper Text Transfer Protocol over Secure Socket Layer)，是以安全为目标的HTTP通道，简单讲是HTTP的安全版。即HTTP下加入SSL层，HTTPS的安全基础是SSL，因此加密的详细内容就需要SSL。

5.谈谈 HTTP 中Get 和 Post 方法的区别

GET – 从指定的服务器中获取数据，明文发送内容

POST – 提交数据给指定的服务器处理

1. POST请求不能被缓存下来

2. POST请求不会保存在浏览器浏览记录中

3. 以POST请求的URL无法保存为浏览器书签

4. POST请求没有长度限制

6.推送心跳包是TCP包还是UDP包或者HTTP包

心跳包的实现是调用了socket.sendUrgentData(0xFF)这句代码实现的，所以，当然是TCP包。

7.如何实现文件断点上传

在 Android 中上传文件可以采用 HTTP 方式，也可以采用 Socket 方式，但是 HTTP 方式不能上传

大文件，这里介绍一种通过 Socket 方式来进行断点续传的方式，服务端会记录下文件的上传进度，

当某一次上传过程意外终止后，下一次可以继续上传，这里用到的其实还是 J2SE 里的知识。

这个上传程序的原理是：客户端*次上传时向服务端发送

“Content-Length=35;filename=WinRAR_3.90_SC.exe;sourceid=“这种格式的字符串，服务端

收到后会查找该文件是否有上传记录，如果有就返回已经上传的位置，否则返回新生成的 sourceid

以及 position 为 0，类似 sourceid=2324838389;position=0“这样的字符串，客户端收到返回后

的字符串后再从指定的位置开始上传文件。

Fragment相关

1.Fragment 如何实现类似 Activity 栈的压栈和出栈效果的?

Fragment 的事物管理器内部维持了一个双向链表结构，该结构可以记录我们每次 add 的

Fragment 和 replace 的 Fragment，然后当我们点击 back 按钮的时候会自动帮我们实现退栈操作。

2.Fragment 在你们项目中的使用

Fragment 是 android3.0 以后引入的的概念，做局部内容更新更方便，原来为了到达这一点要

把多个布局放到一个 activity 里面，现在可以用多 Fragment 来代替，只有在需要的时候才加载

Fragment，提高性能。

Fragment 的好处：

1. Fragment 可以使你能够将 activity 分离成多个可重用的组件，每个都有它自己的生命周期和

UI。

2. Fragment 可以轻松得创建动态灵活的 UI 设计，可以适应于不同的屏幕尺寸。从手机到平板电

脑。

3. Fragment 是一个独立的模块,紧紧地与 activity 绑定在一起。可以运行中动态地移除、加入、

交换等。

4. Fragment 提供一个新的方式让你在不同的安卓设备上统一你的 UI。

5. Fragment 解决 Activity 间的切换不流畅，轻量切换。

6. Fragment 替代 TabActivity 做导航，性能更好。

7. Fragment 在 4.2.版本中新增嵌套 fragment 使用方法，能够生成更好的界面效果

3.如何切换 fragement,不重新实例化

正确的切换方式是 add()，切换时 hide()，add()另一个 Fragment;再次切换时，只需 hide()当前，

show()另一个

四大组件相关

1.Activity和Fragment生命周期有哪些?

Activity——onCreate->onStart->onResume->onPause->onStop->onDestroy

Fragment——onAttach->onCreate->onCreateView->onActivityCreated->onStart->onResume->onPause->onStop->onDestroyView->onDestroy->onDetach

2.广播的两种注册方式及有什么区别

3.内存不足时，怎么保持Activity的一些状态，在哪个方法里面做具体操作?

Activity的 onSaveInstanceState() 和 onRestoreInstanceState()并不是生命周期方法，它们不同于 onCreate()、onPause()等生命周期方法，它们并不一定会被触发。当应用遇到意外情况(如：内存不足、用户直接按Home键)由系统销毁一个Activity，onSaveInstanceState() 会被调用。但是当用户主动去销毁一个Activity时，例如在应用中按返回键，onSaveInstanceState()就不会被调用。除非该activity是被用户主动销毁的，通常onSaveInstanceState()只适合用于保存一些临时性的状态，而onPause()适合用于数据的持久化保存。

4.启动service的两种方法?有什么区别?

一种是startService(),另一种是bindService()。这两者的区别是*种方式调用者开启了服务，即会与服务失去联系，两者没有关联。即使访问者退出了，服务仍在运行。如需解除服务必须显式的调用stopService方法。主要用于调用者与服务没有交互的情况下，也就是调用者不需要获取服务里的业务方法。比如电话录音。而后者调用者与服务绑定在一起的。当调用者退出的时候，服务也随之退出。用于需要与服务交互。

5.Android中的Context, Activity，Appliction有什么区别?

相同：Activity和Application都是Context的子类。

Context从字面上理解就是上下文的意思，在实际应用中它也确实是起到了管理上下文环境中各个参数和变量的总用，方便我们可以简单的访问到各种资源。

不同：维护的生命周期不同。 Context维护的是当前的Activity的生命周期，Application维护的是整个项目的生命周期。

使用context的时候，小心内存泄露，防止内存泄露，注意一下几个方面：

1. 不要让生命周期长的对象引用activity context，即保证引用activity的对象要与activity本身生命周期是一样的。

2. 对于生命周期长的对象，可以使用application，context。

3. 避免非静态的内部类，尽量使用静态类，避免生命周期问题，注意内部类对外部对象引用导致的生命周期变化。

6.Context是什么?

它描述的是一个应用程序环境的信息，即上下文。

该类是一个抽象(abstract class)类，Android提供了该抽象类的具体实现类(ContextIml)。

通过它我们可以获取应用程序的资源和类，也包括一些应用级别操作，例如：启动一个Activity，发送广播，接受Intent，信息，等。

7.Service 是否在 main thread 中执行, service 里面是否能执行耗时的操

作?

默认情况,如果没有显示的指 servic 所运行的进程, Service 和 activity 是运行在当前 app 所在进

程的 main thread(UI 主线程)里面。

service 里面不能执行耗时的操作(网络请求,拷贝数据库,大文件 )

 

特殊情况 ,可以在清单文件配置 service 执行所在的进程 ,让 service 在另外的进程中执行

 

8.Activity 怎么和 Service 绑定，怎么在 Activity 中启动自己对应的

Service?

Activity 通过 bindService(Intent service, ServiceConnection conn, int flags)跟 Service 进行

绑定，当绑定成功的时候 Service 会将代理对象通过回调的形式传给 conn，这样我们就拿到了

Service 提供的服务代理对象。

在 Activity 中可以通过 startService 和 bindService 方法启动 Service。一般情况下如果想获取

Service 的服务对象那么肯定需要通过 bindService()方法，比如音乐播放器，第三方支付等。如

果仅仅只是为了开启一个后台任务那么可以使用 startService()方法。

9.说说 Activity、Intent、Service 是什么关系

他们都是 Android 开发中使用频率*高的类。其中 Activity 和 Service 都是 Android 四大组件

之一。他俩都是 Context 类的子类 ContextWrapper 的子类，因此他俩可以算是兄弟关系吧。不过

兄弟俩各有各自的本领，Activity 负责用户界面的显示和交互，Service 负责后台任务的处理。Activity

和 Service 之间可以通过 Intent 传递数据，因此可以把 Intent 看作是通信使者。

10.请描述一下 BroadcastReceiver

BroadCastReceiver 是 Android 四大组件之一，主要用于接收系统或者 app 发送的广播事件。

广播分两种：有序广播和无序广播。

内部通信实现机制：通过 Android 系统的 Binder 机制实现通信。

1. 无序广播：完全异步，逻辑上可以被任何广播接收者接收到。优点是效率较高。缺点是一个接收者不

能将处理结果传递给下一个接收者，并无法终止广播 intent 的传播。

2. 有序广播：按照被接收者的优先级顺序，在被接收者中依次传播。比如有三个广播接收者 A，B，C，

优先级是 A > B > C。那这个消息先传给 A，再传给 B，*后传给 C。每个接收者有权终止广播，比

如 B 终止广播，C 就无法接收到。此外 A 接收到广播后可以对结果对象进行操作，当广播传给 B 时，

B 可以从结果对象中取得 A 存入的数据。

在通过 Context.sendOrderedBroadcast(intent, receiverPermission, resultReceiver, scheduler,

initialCode, initialData, initialExtras)时我们可以指定 resultReceiver 广播接收者，这个接收者我们

可以认为是*终接收者，通常情况下如果比他优先级更高的接收者如果没有终止广播，那么他的

onReceive 会被执行两次，*次是正常的按照优先级顺序执行，第二次是作为*终接收者接收。

如果比他优先级高的接收者终止了广播，那么他依然能接收到广播

11.为什么要用 ContentProvider?它和 sql 的实现上有什么差别?

ContentProvider 屏蔽了数据存储的细节,内部实现对用户完全透明,用户只需要关心操作数据的

uri 就可以了，ContentProvider 可以实现不同 app 之间共享。

Sql 也有增删改查的方法，但是 sql 只能查询本应用下的数据库。而 ContentProvider 还可

以去增删改查本地文件. xml 文件的读取等。

12.说说 ContentProvider、ContentResolver、ContentObserver 之间的关系

a. ContentProvider 内容提供者，用于对外提供数据

b. ContentResolver.notifyChange(uri)发出消息

c. ContentResolver 内容解析者，用于获取内容提供者提供的数据

d. ContentObserver 内容监听器，可以监听数据的改变状态

e. ContentResolver.registerContentObserver()监听消息。

View 相关

1.onInterceptTouchEvent()和onTouchEvent()的区别

onInterceptTouchEvent()用于拦截触摸事件

onTouchEvent()用于处理触摸事件

2.RemoteView在哪些功能中使用

APPwidget和Notification中

3. SurfaceView和View的区别是什么?

SurfaceView中采用了双缓存技术，在单独的线程中更新界面

View在UI线程中更新界面

4.View的绘制过程

一个View要显示在界面上，需要经历一个View树的遍历过程，这个过程又可以分为三个过程，也就是自定义View中的三要素：大小，位置，画什么，即onMesure()，onLayout(),onDraw()。

1.onMesure()确定一个View的大小;

2.onLayout()确定View在父节点上的位置;

3.onDraw()绘制View 的内容;

5.如何自定义ViewGroup

1.指定的LayoutParams

2.onMeasure中计算所有childView的宽和高，然后根据childView的宽和高，计算自己的宽和高。(当然，如果不是wrap_content，直接使用父ViewGroup传入的计算值即可)

3.onLayout中对所有的childView进行布局。

6.View中onTouch，onTouchEvent，onClick的执行顺序

dispatchTouchEvent—->onTouch—->onTouchEvent—–>onClick。在所有ACTION_UP事件之后才触发onClick点击事件。

性能优化相关

1.ListView卡顿的原因与性能优化，越多越好

重用converView： 通过复用converview来减少不必要的view的创建，另外Infalte操作会把xml文件实例化成相应的View实例，属于IO操作，是耗时操作。

减少findViewById()操作： 将xml文件中的元素封装成viewholder静态类，通过converview的setTag和getTag方法将view与相应的holder对象绑定在一起，避免不必要的findviewbyid操作

避免在 getView 方法中做耗时的操作: 例如加载本地 Image 需要载入内存以及解析 Bitmap ，都是比较耗时的操作，如果用户快速滑动listview，会因为getview逻辑过于复杂耗时而造成滑动卡顿现象。用户滑动时候不要加载图片，待滑动完成再加载，可以使用这个第三方库glide

Item的布局层次结构尽量简单，避免布局太深或者不必要的重绘

尽量能保证 Adapter 的 hasStableIds() 返回 true 这样在 notifyDataSetChanged() 的时候，如果item内容并没有变化，ListView 将不会重新绘制这个 View，达到优化的目的

在一些场景中，ScollView内会包含多个ListView，可以把listview的高度写死固定下来。 由于ScollView在快速滑动过程中需要大量计算每一个listview的高度，阻塞了UI线程导致卡顿现象出现，如果我们每一个item的高度都是均匀的，可以通过计算把listview的高度确定下来，避免卡顿现象出现

使用 RecycleView 代替listview： 每个item内容的变动，listview都需要去调用notifyDataSetChanged来更新全部的item，太浪费性能了。RecycleView可以实现当个item的局部刷新，并且引入了增加和删除的动态效果，在性能上和定制上都有很大的改善

ListView 中元素避免半透明： 半透明绘制需要大量乘法计算，在滑动时不停重绘会造成大量的计算，在比较差的机子上会比较卡。 在设计上能不半透明就不不半透明。实在要弄就把在滑动的时候把半透明设置成不透明，滑动完再重新设置成半透明。

尽量开启硬件加速： 硬件加速提升巨大，避免使用一些不支持的函数导致含泪关闭某个地方的硬件加速。当然这一条不只是对 ListView。

2.如何避免 OOM 问题的出现

使用更加轻量的数据结构 例如，我们可以考虑使用ArrayMap/SparseArray而不是HashMap等传统数据结构。通常的HashMap的实现方式更加消耗内存，因为它需要一个额外的实例对象来记录Mapping操作。另外，SparseArray更加高效，在于他们避免了对key与value的自动装箱(autoboxing)，并且避免了装箱后的解箱。

避免在Android里面使用Enum Android官方培训课程提到过“Enums often require more than twice as much memory as static constants. You should strictly avoid using enums on Android.”，具体原理请参考《Android性能优化典范(三)》，所以请避免在Android里面使用到枚举。

减小Bitmap对象的内存占用 Bitmap是一个*容易消耗内存的大胖子，减小创建出来的Bitmap的内存占用可谓是重中之重，，通常来说有以下2个措施： ++inSampleSize++：缩放比例，在把图片载入内存之前，我们需要先计算出一个合适的缩放比例，避免不必要的大图载入。 ++decode format++：解码格式，选择ARGB_6666/RBG_545/ARGB_4444/ALPHA_6，存在很大差异

Bitmap对象的复用 缩小Bitmap的同时，也需要提高BitMap对象的复用率，避免频繁创建BitMap对象，复用的方法有以下2个措施 LRUCache : “*近*少使用算法”在Android中有*其普遍的应用。ListView与GridView等显示大量图片的控件里，就是使用LRU的机制来缓存处理好的Bitmap，把近期*少使用的数据从缓存中移除，保留使用*频繁的数据， inBitMap高级特性:利用inBitmap的高级特性提高Android系统在Bitmap分配与释放执行效率。使用inBitmap属性可以告知Bitmap解码器去尝试使用已经存在的内存区域，新解码的Bitmap会尝试去使用之前那张Bitmap在Heap中所占据的pixel data内存区域，而不是去问内存重新申请一块区域来存放Bitmap。利用这种特性，即使是上千张的图片，也只会仅仅只需要占用屏幕所能够显示的图片数量的内存大小

使用更小的图片 在涉及给到资源图片时，我们需要特别留意这张图片是否存在可以压缩的空间，是否可以使用更小的图片。尽量使用更小的图片不仅可以减少内存的使用，还能避免出现大量的InflationException。假设有一张很大的图片被XML文件直接引用，很有可能在初始化视图时会因为内存不足而发生InflationException，这个问题的根本原因其实是发生了OOM。

StringBuilder 在有些时候，代码中会需要使用到大量的字符串拼接的操作，这种时候有必要考虑使用StringBuilder来替代频繁的“+”。

避免在onDraw方法里面执行对象的创建 类似onDraw等频繁调用的方法，一定需要注意避免在这里做创建对象的操作，因为他会迅速增加内存的使用，而且很容易引起频繁的gc，甚至是内存抖动。

避免对象的内存泄露

3.三级缓存的原理

从缓存中加载。

从本地文件中加载(数据库，SD)

从网络加载。

a.加载 bitmap 的时候无需考虑 bitmap 加载过程中出现的 oom(内存溢出)和 android 容器快速

滑动的时候出现的图片错位等现象。(16M)

b. 支持加载网络图片和本地图片。

c. 内存管理使用的 lru 算法(移除里面是有频率*少的对象)，更好的管理 bitmap 的内存

Android其他

1.讲一下android中进程的优先级?

前台进程

可见进程

服务进程

后台进程

空进程

2.介绍Handle的机制

Handler通过调用sendmessage方法把消息放在消息队列MessageQueue中，Looper负责把消息从消息队列中取出来，重新再交给Handler进行处理，三者形成一个循环

通过构建一个消息队列，把所有的Message进行统一的管理，当Message不用了，并不作为垃圾回收，而是放入消息队列中，供下次handler创建消息时候使用，提高了消息对象的复用，减少系统垃圾回收的次数

每一个线程，都会单独对应的一个looper，这个looper通过ThreadLocal来创建，保证每个线程只创建一个looper，looper初始化后就会调用looper.loop创建一个MessageQueue，这个方法在UI线程初始化的时候就会完成，我们不需要手动创建

3.Dalvik虚拟机与JVM有什么区别

Dalvik 基于寄存器，而 JVM 基于栈。基于寄存器的虚拟机对于更大的程序来说，在它们编译的时候，花费的时间更短。

Dalvik执行.dex格式的字节码，而JVM执行.class格式的字节码。

4.每个应用程序对应多少个Dalvik虚拟机

每一个Android应用在底层都会对应一个独立的Dalvik虚拟机实例，其代码在虚拟机的解释下得以执行 ，而所有的Android应用的线程都对应一个Linux线程

5.应用常驻后台，避免被第三方杀掉的方法

Service设置成START_STICKY kill 后会被重启(等待5秒左右)，重传Intent，保持与重启前一样

通过 startForeground将进程设置为前台进程， 做前台服务，优先级和前台应用一个级别，除非在系统内存非常缺，否则此进程不会被 kill

双进程Service： 让2个进程互相保护对方，其中一个Service被清理后，另外没被清理的进程可以立即重启进程

用C编写守护进程(即子进程) : Android系统中当前进程(Process)fork出来的子进程，被系统认为是两个不同的进程。当父进程被杀死的时候，子进程仍然可以存活，并不受影响(Android5.0以上的版本不可行

联系厂商，加入白名单

6.根据自己的理解描述下Android数字签名。

所有的应用程序都必须有数字证书，Android系统不会安装一个没有数字证书的应用程序

Android程序包使用的数字证书可以是自签名的，不需要一个权威的数字证书机构签名认证

如果要正式发布一个Android程序，必须使用一个合适的私钥生成的数字证书来给程序签名，而不能使用adt插件或者ant工具生成的调试证书来发布。

数字证书都是有有效期的，Android只是在应用程序安装的时候才会检查证书的有效期。如果程序已经安装在系统中，即使证书过期也不会影响程序的正常功能。

7.Dalvik基于JVM的改进

几个class变为一个dex，constant pool，省内存

Zygote，copy-on-write shared,省内存，省cpu，省电

基于寄存器的bytecode，省指令，省cpu，省电

Trace-based JIT,省cpu，省电,省内存

8.ARGB_8888占用内存大小

本题的答案，是4byte，即ARGB各占用8个比特来描述。

9.apk安装卸载的原理

安装过程：复制apk安装包到data/app目录下，解压并扫描安装包，把dex文件(dalvik字节码)保存到dalvik-cache目录，并data/data目录下创建对应的应用数据目录。

卸载过程：删除安装过程中在上述三个目录下创建的文件及目录。

10.通过Intent传递一些二进制数据的方法有哪些?

使用Serializable接口实现序列化，这是Java常用的方法。

实现Parcelable接口，这里Android的部分类比如Bitmap类就已经实现了，同时Parcelable在Android AIDL中交换数据也很常见的。

11.横竖屏切换时Activity的生命周期

此时的生命周期跟清单文件里的配置有关系。

不设置Activity的android:configChanges时，切屏会重新调用各个生命周期默认首先销毁当前activity,然后重新加载。

设置Activity android:configChanges=”orientation|keyboardHidden|screenSize”时，切屏不会重新调用各个生命周期，只会执行onConfigurationChanged方法

12.Serializable 和 Parcelable 的区别

在使用内存的时候，Parcelable 类比 Serializable 性能高，所以推荐使用 Parcelable 类。

1. Serializable 在序列化的时候会产生大量的临时变量，从而引起频繁的 GC。

2. Parcelable 不能使用在要将数据存储在磁盘上的情况。尽管 Serializable 效率低点，但在这

种情况下，还是建议你用 Serializable 。

13.Android 中如何捕获未捕获的异常

自 定 义 一 个 Application ， 比 如 叫 MyApplication 继 承 Application 实 现

UncaughtExceptionHandler。

覆写 UncaughtExceptionHandler 的 onCreate 和 uncaughtException 方法。

14.Android 的权限规则

Android 中的 apk 必须签名

基于 UserID 的进程级别的安全机制

默认 apk 生成的数据对外是不可见的

AndroidManifest.xml 中的显式权限声明

15.多线程间通信和多进程之间通信有什么不同，分别怎么实现?

一、进程间的通信方式

1. 管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的

进程间使用。进程的亲缘关系通常是指父子进程关系。

2. 有名管道 (namedpipe) ： 有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的

通信。

3. 信号量(semophore ) ： 信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它

常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进

程间以及同一进程内不同线程之间的同步手段。

4. 消息队列( messagequeue ) ： 消息队列是由消息的链表，存放在内核中并由消息队列标识符

标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。

5. 信号 (sinal ) ： 信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。

6. 共享内存(shared memory ) ：共享内存就是映射一段能被其他进程所访问的内存，这段共享内

存由一个进程创建，但多个进程都可以访问。共享内存是*快的 IPC 方式，它是针对其他进程间

通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间

的同步和通信。

7. 套接字(socket ) ： 套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同

及其间的进程通信。

二、线程间的通信方式

1. 锁机制：包括互斥锁、条件变量、读写锁

*互斥锁提供了以排他方式防止数据结构被并发修改的方法。

*读写锁允许多个线程同时读共享数据，而对写操作是互斥的。

*条件变量可以以原子的方式阻塞进程，直到某个特定条件为真为止。对条件的测试是在互斥锁

的保护下进行的。条件变量始终与互斥锁一起使用。

2. 信号量机制(Semaphore)：包括无名线程信号量和命名线程信号量

3. 信号机制(Signal)：类似进程间的信号处理

线程间的通信目的主要是用于线程同步，所以线程没有像进程通信中的用于数据交换的通信机

制。

16.说说 LruCache 底层原理

LruCache 使用一个 LinkedHashMap 简单的实现内存的缓存，没有软引用，都是强引用。如果添

加的数据大于设置的*大值，就删除*先缓存的数据来调整内存。

maxSize 是通过构造方法初始化的值，他表示这个缓存能缓存的*大值是多少。

size 在添加和移除缓存都被更新值，他通过 safeSizeOf 这个方法更新值。safeSizeOf 默认返回 1，

但一般我们会根据 maxSize 重写这个方法，比如认为 maxSize 代表是 KB 的话，那么就以 KB 为单

位返回该项所占的内存大小。

除异常外首先会判断 size 是否超过 maxSize，如果超过了就取出*先插入的缓存，如果不为空就

删掉，并把 size 减去该项所占的大小。这个操作将一直循环下去，直到 size 比 maxSize 小或者缓存

为空。

Android面试题数据结构篇，由本人整理汇总，后续将继续推出系列篇，如果喜欢请持续关注和推荐

List,Set,Map的区别

Set是*简单的一种集合。集合中的对象不按特定的方式排序，并且没有重复对象。 Set接口主要实现了两个实现类：

HashSet： HashSet类按照哈希算法来存取集合中的对象，存取速度比较快
TreeSet ：TreeSet类实现了SortedSet接口，能够对集合中的对象进行排序。
List的特征是其元素以线性方式存储，集合中可以存放重复对象。

ArrayList() :代表长度可以改变得数组。可以对元素进行随机的访问，向ArrayList()中插入与删除元素的速度慢。
LinkedList():在实现中采用链表数据结构。插入和删除速度快，访问速度慢。
Map 是一种把键对象和值对象映射的集合，它的每一个元素都包含一对键对象和值对象。Map没有继承于Collection接口 从Map集合中检索元素时，只要给出键对象，就会返回对应的值对象。

HashMap：Map基于散列表的实现。插入和查询“键值对”的开销是固定的。可以通过构造器设置容量capacity和负载因子load factor，以调整容器的性能。
LinkedHashMap： 类似于HashMap，但是迭代遍历它时，取得“键值对”的顺序是其插入次序，或者是*近*少使用(LRU)的次序。只比HashMap慢一点。而在迭代访问时发而更快，因为它使用链表维护内部次序。
TreeMap ： 基于红黑树数据结构的实现。查看“键”或“键值对”时，它们会被排序(次序由Comparabel或Comparator决定)。TreeMap的特点在 于，你得到的结果是经过排序的。TreeMap是唯一的带有subMap()方法的Map，它可以返回一个子树。
WeakHashMao ：弱键(weak key)Map，Map中使用的对象也被允许释放: 这是为解决特殊问题设计的。如果没有map之外的引用指向某个“键”，则此“键”可以被垃圾收集器回收。
ArrayMap和HashMap的对比

1、存储方式不同，HashMap内部有一个HashMapEntry<K,V>[]对象，每一个键值对都存储在这个对象里，当使用put方法添加键值对时，就会new一个HashMapEntry对象。
2、添加数据时扩容时的处理不一样，进行了new操作，重新创建对象，开销很大。ArrayMap用的是copy数据，所以效率相对要高。
3、ArrayMap提供了数组收缩的功能，在clear或remove后，会重新收缩数组，是否空间
4、ArrayMap采用二分法查找；
HashMap和HashTable的区别

1 HashMap不是线程安全的，效率高一点、方法不是Synchronize的要提供外同步，有containsvalue和containsKey方法。
hashtable是，线程安全，不允许有null的键和值，效率稍低，方法是是Synchronize的。有contains方法方法。Hashtable 继承于Dictionary 类
HashMap与HashSet的区别

hashMap:HashMap实现了Map接口,HashMap储存键值对,使用put()方法将元素放入map中,HashMap中使用键对象来计算hashcode值,HashMap比较快，因为是使用唯一的键来获取对象。
HashSet实现了Set接口，HashSet仅仅存储对象，使用add()方法将元素放入set中，HashSet使用成员对象来计算hashcode值，对于两个对象来说hashcode可能相同，所以equals()方法用来判断对象的相等性，如果两个对象不同的话，那么返回false。HashSet较HashMap来说比较慢。
HashSet与HashMap怎么判断集合元素重复？
HashSet不能添加重复的元素，当调用add（Object）方法时候，首先会调用Object的hashCode方法判hashCode是否已经存在，如不存在则直接插入元素；如果已存在则调用Object对象的equals方法判断是否返回true，如果为true则说明元素已经存在，如为false则插入元素。

ArrayList和LinkedList的区别，以及应用场景
ArrayList是基于数组实现的，ArrayList线程不安全。 LinkedList是基于双链表实现的。 使用场景：

如果应用程序对各个索引位置的元素进行大量的存取或删除操作，ArrayList对象要远优于LinkedList对象；
如果应用程序主要是对列表进行循环，并且循环时候进行插入或者删除操作，LinkedList对象要远优于ArrayList对象；
数组和链表的区别

数组：是将元素在内存中连续存储的；它的优点：因为数据是连续存储的，内存地址连续，所以在查找数据的时候效率比较高；它的缺点：在存储之前，我们需要申请一块连续的内存空间，并且在编译的时候就必须确定好它的空间的大小。在运行的时候空间的大小是无法随着你的需要进行增加和减少而改变的，当数据两比较大的时候，有可能会出现越界的情况，数据比较小的时候，又有可能会浪费掉内存空间。在改变数据个数时，增加、插入、删除数据效率比较低。
链表：是动态申请内存空间，不需要像数组需要提前申请好内存的大小，链表只需在用的时候申请就可以，根据需要来动态申请或者删除内存空间，对于数据增加和删除以及插入比数组灵活。还有就是链表中数据在内存中可以在任意的位置，通过应用来关联数据（就是通过存在元素的指针来联系）
HashMap的实现原理：

HashMap是基于哈希表的map接口的非同步实现，它允许使用null值作为key和value。在Java编程语言中*基本的结构就是两种，一种是数组，另一种是模拟指针（引用）。所有的数据结构都可以用这两个基本的结构来构造，HashMap也不例外。HashMap实际上是一个“链表散列”的数据结构。即数组和链表的结合体。HashMap底层就是一个数据结构，数组中的每一项又是一个链表。

冲突：
HashMap中调用Hashcode()方法计算Hashclde值，由于Java中两个不同的对象可能有一样的Hashcode。就导致了冲突的产生。

解决：
HashMap在put时候，底层源码可以看出，当程序试图将一个key-value对象放入到HashMap中，首先根据该key的hashCode()返回值决定该Entry的存储位置，如果两个Entry的key的hashCode()方法返回值相同，那他们的存储位置相同，如果这两个Entry的key通过equals比较返回true，新添加的Entry的value将会覆盖原来的Entry的value，但是key不会被覆盖，反之，如果返回false，新添加的Entry将与集合中原有的Entry形成Entry链，新添加的位于头部，旧的位于尾部。

原理

利用key的hashCode重新hash计算出当前对象的元素在数组中的下标。
存储时如果出现hash值相同的key，分两种情况：1、如果key相同，则覆盖原来的值。2、如果key不同（出现冲突），则放在链表中。
获取时，直接找到hash值对应的下标，再进一步判断key是否相同，从而拿到对应的值。
Hashmap的核心就是使用数组进行存储，出现key冲突的时候，就存放在链表中。
ConcurrentHashMap内部实现，HashTable的实现被废弃的原因:

1.HashTable容器在竞争激烈的并发环境下表现出效率低下的原因，是因为所有访问HashTable的线程都必须竞争同一把锁，那假如容器里有多把锁，每一把锁用于锁容器其中一部分数据，那么当多线程访问容器里不同数据段的数据时，线程间就不会存在锁竞争，从而可以有效的提高并发访问效率，这就是ConcurrentHashMap所使用的锁分段技术，首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。
2.ConcurrentHashMap是由Segment数组结构和HashEntry数组结构组成。Segment是一种可重入锁ReentrantLock，在ConcurrentHashMap里扮演锁的角色，HashEntry则用于存储键值对数据。一个ConcurrentHashMap里包含一个Segment数组，Segment的结构和HashMap类似，是一种数组和链表结构， 一个Segment里包含一个HashEntry数组，每个HashEntry是一个链表结构的元素，每个Segment守护者一个HashEntry数组里的元素,当对HashEntry数组的数据进行修改时，必须首先获得它对应的Segment锁。
说说 LruCache 底层原理
LruCache 使用一个 LinkedHashMap 简单的实现内存的缓存，没有软引用，都是强引用。如果添加的数据大于设置的*大值，就删除*先缓存的数据来调整内存。
maxSize 是通过构造方法初始化的值，他表示这个缓存能缓存的*大值是多少。
size 在添加和移除缓存都被更新值，他通过safeSizeOf 这个方法更新值。safeSizeOf默认返回1，但一般我们会根据 maxSize重写这个方法，比如认为 maxSize 代表是 KB 的话，那么就以KB为单位返回该项所占的内存大小。
除异常外首先会判断size是否超过maxSize，如果超过了就取出*先插入的缓存，如果不为空就删掉，并把size减去该项所占的大小。这个操作将一直循环下去，直到 size 比 maxSize 小或者缓存为空。

本文完~

Android面试题内存&性能篇，由本人整理汇总，后续将继续推出系列篇，如果喜欢请持续关注和推荐

内存分配

RAM（random access memory）随机存取存储器。说白了就是内存。 一般Java在内存分配时会涉及到以下区域：

寄存器（Registers）：速度*快的存储场所，因为寄存器位于处理器内部，我们在程序中无法控制
栈（Stack）：存放基本类型的数据和对象的引用，但对象本身不存放在栈中，而是存放在堆中
堆（Heap）：堆内存用来存放由new创建的对象和数组。在堆中分配的内存，由Java虚拟机的自动垃圾回收器（GC）来管理。
静态域（static field）： 静态存储区域就是指在固定的位置存放应用程序运行时一直存在的数据，Java在内存中专门划分了一个静态存储区域来管理一些特殊的数据变量如静态的数据变量
常量池（constant pool）：虚拟机必须为每个被装载的类型维护一个常量池。常量池就是该类型所用到常量的一个有序集和，包括直接常量（string,integer和floating point常量）和对其他类型，字段和方法的符号引用。
非RAM存储：硬盘等永久存储空间
堆栈存储特点对比：

栈：当定义一个变量时，Java就在栈中为这个变量分配内存空间，当该变量退出该作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。
堆：当堆中的new产生数组和对象超出其作用域后，它们不会被释放，只有在没有引用变量指向它们的时候才变成垃圾，不能再被使用。即使这样，所占内存也不会立即释放，而是等待被垃圾回收器收走。这也是Java比较占内存的原因。
堆栈运行特点对比：

栈：存取速度比堆要快，仅次于寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。
堆：堆是一个运行时数据区，可以动态地分配内存大小，因此存取速度较慢。也正因为这个特点，堆的生存期不必事先告诉编译器，而且Java的垃圾收集器会自动收走这些不再使用的数据。
对象引用类型：

引用分为四种级别，这四种级别由高到低依次为：强引用>软引用>弱引用>虚引用。

强引用（strong reference）
如：Object object=new Object（），object就是一个强引用了。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。
软引用（SoftReference）
只有内存不够时才回收,常用于缓存；当内存达到一个阀值，GC就会去回收它；
弱引用（WeakReference）
弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它 所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。
虚引用（PhantomReference）
“虚引用”顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。
UI优化

a.合理选择RelativeLayout、LinearLayout、FrameLayout,RelativeLayout会让子View调用2次onMeasure，而且布局相对复杂时，onMeasure相对比较复杂，效率比较低，LinearLayout在weight>0时也会让子View调用2次onMeasure。LinearLayout weight测量分配原则。
b.使用标签<include><merge><ViewStub>
c.减少布局层级，可以通过手机开发者选项>GPU过渡绘制查看，一般层级控制在4层以内，超过5层时需要考虑是否重新排版布局。
d.自定义View时，重写onDraw()方法，不要在该方法中新建对象，否则容易触发GC，导致性能下降
e.使用ListView时需要复用contentView，并使用Holder减少findViewById加载View。
f.去除不必要背景，getWindow().setBackgroundDrawable(null)
g.使用TextView的leftDrawabel/rightDrawable代替ImageView+TextView布局
内存优化

主要为了避免OOM和频繁触发到GC导致性能下降

a.Bitmap.recycle(),Cursor.close,inputStream.close()
b.大量加载Bitmap时，根据View大小加载Bitmap，合理选择inSampleSize，RGB_565编码方式；使用LruCache缓存
c.使用 静态内部类+WeakReference 代替内部类，如Handler、线程、AsyncTask
d.使用线程池管理线程，避免线程的新建
e.使用单例持有Context，需要记得释放，或者使用全局上下文
f.静态集合对象注意释放
g.属性动画造成内存泄露
h.使用webView，在Activity.onDestory需要移除和销毁，webView.removeAllViews()和webView.destory()
备：使用LeakCanary检测内存泄露

响应速度优化

Activity如果5秒之内无法响应屏幕触碰事件和键盘输入事件，就会出现ANR，而BroadcastReceiver如果10秒之内还未执行操作也会出现ANR，Serve20秒会出现ANR 为了避免ANR，可以开启子线程执行耗时操作，但是子线程不能更新UI，因此需要Handler消息机制、AsyncTask、IntentService进行线程通信。

备：出现ANR时，adb pull data/anr/tarces.txt 结合log分析

其他性能优化

a.常量使用static final修饰
b.使用SparseArray代替HashMap
c.使用线程池管理线程
d.ArrayList遍历使用常规for循环，LinkedList使用foreach
e.不要过度使用枚举，枚举占用内存空间比整型大
f.字符串的拼接优先考虑StringBuilder和StringBuffer
g.数据库存储是采用批量插入+事务
Android内存泄露及管理

（1）内存溢出（OOM）和内存泄露（对象无法被回收）的区别。 （2）引起内存泄露的原因
（3）内存泄露检测工具—->LeakCanary

内存溢出 out of memory：是指程序在申请内存时，没有足够的内存空间供其使用，出现out of memory；比如申请了一个integer,但给它存了long才能存下的数，那就是内存溢出。内存溢出通俗的讲就是内存不够用。

内存泄露 memory leak：是指程序在申请内存后，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重，无论多少内存,迟早会被占光

内存泄露原因：

Handler 引起的内存泄漏。
解决：将Handler声明为静态内部类，就不会持有外部类SecondActivity的引用，其生命周期就和外部类无关，如果Handler里面需要context的话，可以通过弱引用方式引用外部类
单例模式引起的内存泄漏。
解决：Context是ApplicationContext，由于ApplicationContext的生命周期是和app一致的，不会导致内存泄漏
非静态内部类创建静态实例引起的内存泄漏。
解决：把内部类修改为静态的就可以避免内存泄漏了
非静态匿名内部类引起的内存泄漏。
解决：将匿名内部类设置为静态的。
注册/反注册未成对使用引起的内存泄漏。
注册广播接受器、EventBus等，记得解绑。
资源对象没有关闭引起的内存泄漏。
在这些资源不使用的时候，记得调用相应的类似close（）、destroy（）、recycler（）、release（）等方法释放。
集合对象没有及时清理引起的内存泄漏。
通常会把一些对象装入到集合中，当不使用的时候一定要记得及时清理集合，让相关对象不再被引用。
JAVA相关性能优化

1 不用new关键词创建类的实例
用new关键词创建类的实例时，构造函数链中的所有构造函数都会被自动调用。但如果一个对象实现了Cloneable接口，我们可以调用它的clone()方法。clone()方法不会调用任何类构造函数。

在使用设计模式（Design Pattern）的场合，如果用Factory模式创建对象，则改用clone()方法创建新的对象实例非常简单。例如，下面是Factory模式的一个典型实现：
public static Credit getNewCredit() {
return new Credit();
}
改进后的代码使用clone()方法，如下所示：
private static Credit BaseCredit = new Credit();
public static Credit getNewCredit() {
return (Credit) BaseCredit.clone();
}
上面的思路对于数组处理同样很有用。

2 使用非阻塞I/O
版本较低的JDK不支持非阻塞I/O API。为避免I/O阻塞，一些应用采用了创建大量线程的办法（在较好的情况下，会使用一个缓冲池）。这种技术可以在许多必须支持并发I/O流的应用中见 到，如Web服务器、报价和拍卖应用等。然而，创建Java线程需要相当可观的开销。 JDK 1.4引入了非阻塞的I/O库（java.nio）。如果应用要求使用版本较早的JDK，在这里有一个支持非阻塞I/O的软件包。

3 慎用异常
异 常对性能不利。抛出异常首先要创建一个新的对象。Throwable接口的构造函数调用名为fillInStackTrace()的本地（Native） 方法，fillInStackTrace()方法检查堆栈，收集调用跟踪信息。只要有异常被抛出，VM就必须调整调用堆栈，因为在处理过程中创建了一个新 的对象。 异常只能用于错误处理，不应该用来控制程序流程。

4 不要重复初始化变量
默认情况下，调用类的构造函数时， Java会把变量初始化成确定的值：所有的对象被设置成null，整数变量（byte、short、int、long）设置成0，float和 double变可柚贸?.0，逻辑值设置成false。当一个类从另一个类派生时，这一点尤其应该注意，因为用new关键词创建一个对象时，构造函数链中 的所有构造函数都会被自动调用。

5 尽量指定类的final修饰符
带有final修饰符的类是不可派生的。在Java核心API中，有许多应用final的例子，例如java.lang.String。为String类指定final防止了人们覆盖length()方法。 另外，如果指定一个类为final，则该类所有的方法都是final。Java编译器会寻找机会内联（inline）所有的final方法（这和具体的编译器实现有关）。此举能够使性能平均提高50%。

6 尽量使用局部变量
调用方法时传递的参数以及在调用中创建的临时变量都保存在栈（Stack）中，速度较快。其他变量，如静态变量、实例变量等，都在堆（Heap）中创建，速度较慢。另外，依赖于具体的编译器/JVM，局部变量还可能得到进一步优化。请参见《尽可能使用堆栈变量》。

7 乘法和除法
考虑下面的代码： for (val = 0; val < 100000; val +=5) { alterX = val * 8; myResult = val * 2; } 用移位操作替代乘法操作可以*大地提高性能。下面是修改后的代码： for (val = 0; val < 100000; val += 5) { alterX = val << 3; myResult = val << 1; }

8.字符串拼接
不要随意的使用stingA=StringB+StringC的写法，有大量拼接操作的地方用StringBuilder代替

本文完~

Android面试题系统原理篇，由本人整理汇总，后续将继续推出系列篇，如果喜欢请持续关注和推荐。

Dalvik虚拟机与JVM有什么区别

Dalvik 基于寄存器，而 JVM 基于栈。基于寄存器的虚拟机对于更大的程序来说，在它们编译的时候，花费的时间更短。 Dalvik执行.dex格式的字节码，而JVM执行.class格式的字节码。

Dalvik基于JVM的改进

几个class变为一个dex，constant pool，省内存 Zygote，copy-on-write shared,省内存，省cpu，省电 基于寄存器的bytecode，省指令，省cpu，省电 Trace-based JIT,省cpu，省电,省内存

apk安装卸载的原理

安装过程：复制apk安装包到data/app目录下，解压并扫描安装包，把dex文件(dalvik字节码)保存到dalvik-cache目录，并data/data目录下创建对应的应用数据目录。

APK打包流程和其内容

1.流程
1.aapt生成R文件
2.aidl生成java文件
3.将全部java文件编译成class文件
4.将全部class文件和第三方包合并成dex文件
5.将资源、so文件、dex文件整合成apk
6.apk签名
7.apk字节对齐
2.内容：so、dex、asset、资源文件
class和dex

1.dvm执行的是dex格式文件，jvm执行的是class文件，android程序编译完之后生产class文件。然后dex工具会把class文件处理成dex文件，然后把资源文件和.dex文件等打包成apk文件。
2.dvm是基于寄存器的虚拟机，而jvm执行是基于虚拟栈的虚拟机。寄存器存取速度比栈快的多，dvm可以根据硬件实现*大的优化，比较适合移动设备。
3.class文件存在很多的冗余信息，dex工具会去除冗余信息，并把所有的class文件整合到dex文件中。减少了I/O操作，提高了类的查找速度
Android采用什么软件架构？整个系统包括哪几个层次？

Android采用堆栈式软件架构，系统分为四个层，从高层到低层分别是：应用程序层、应用程序框架层、系统运行库层和linux核心层。

APP从启动到主页显示经历了哪些过程

①点击桌面App图标，Launcher进程采用Binder IPC向system_server进程发起startActivity请求；
②system_server进程接收到请求后，向zygote进程发送创建进程的请求；
③Zygote进程fork出新的子进程，即App进程；
④App进程，通过Binder IPC向sytem_server进程发起attachApplication请求；
⑤system_server进程在收到请求后，进行一系列准备工作后，再通过binder IPC向App进程发送scheduleLaunchActivity请求；
⑥App进程的binder线程（ApplicationThread）在收到请求后，通过handler向主线程发送LAUNCH_ACTIVITY消息；
⑦主线程在收到Message后，通过发射机制创建目标Activity，并回调Activity.onCreate()等方法。
⑧到此，App便正式启动，开始进入Activity生命周期，执行完onCreate/onStart/onResume方法，UI渲染结束后便可以看到App的主界面。
操作系统如何管理内存的：

1.使用寄存器进行将进程地址和物理内存进行映射
2.虚拟内存进行内存映射到硬盘上增大内存
3.虚拟内存是进行内存分页管理
4.页表实现分页，就是 页+地址偏移。
5.如果程序的内存在硬盘上，那么就需要用页置换算法来将其调入内存中：先进先出、*近未使用*少等等
apk瘦身:

1.classes.dex：通过代码混淆，删掉不必要的jar包和代码实现该文件的优化
2.资源文件：通过Lint工具扫描代码中没有使用到的静态资源
3.图片资源：使用tinypng和webP，下面详细介绍图片资源优化的方案,矢量图
4.SO文件将不用的去掉，目前主流app一般只放一个arm的so包
GC原理

1.搜索算法：
1.引用计数
2.图搜索，可达性分析
2.回收算法：
1.标记清除复制：用于青年代
2.标记整理：用于老年代
3.堆分区：
1.青年区eden 80%、survivor1 10%、survivor2 10%
2.老年区
4.虚拟机栈分区：
1.局部变量表
2.操作数栈
3.动态链接
4.方法返回地址
5.GC Roots:
1.虚拟机栈(栈桢中的本地变量表)中的引用的对象
2.方法区中的类静态属性引用的对象
3.方法区中的常量引用的对象
4.本地方法栈中JNI的引用的对象

本文完~

Android面试题网络篇，由本人整理汇总，后续将继续推出系列篇，如果喜欢请持续关注和推荐。

系列文章目录：

Android面试题View篇
Android面试题进程篇
Android面试题线程篇
TCP和UDP的区别
（TCP）传输控制协议，是一种提供可靠数据传输的通用协议。 （UDP）用户数据报协议，是一个面向无连接的协议。采用该协议不需要两个应用程序先建立连接。UDP协议不提供差错恢复，不能提供数据重传，因此该协议传输数据安全性差。

如何设计在 UDP 上层保证 UDP 的可靠性传输

1.简单来讲，要使用UDP来构建可靠的面向连接的数据传输，就要实现类似于TCP协议的超时重传，有序接受，应答确认，滑动窗口流量控制等机制,等于说要在传输层的上一层（或者直接在应用层）实现TCP协议的可靠数据传输机制。
2.比如使用UDP数据包+序列号，UDP数据包+时间戳等方法，在服务器端进行应答确认机制，这样就会保证不可靠的UDP协议进行可靠的数据传输。
3.基于udp的可靠传输协议有：RUDP、RTP、UDT
OSI与TCP/IP各层的结构与功能，都有哪些协议
OSI开放式系统互联 TCP/IP传输控制协议 OSI模型有7层 TCP/IP模型有5层

OSI模型

物理层：规定通信设备的机械的、电气的、功能的和过程的特性，用以建立、维护和拆除物理链路连接。
数据链路层：传输有MAC地址的帧以及错误检测功能
网络层：（两个主机之间）为数据包（packets）选择路由
传输层：（两个主机的应用进程之间）提供端对端的接口
会话层：访问验证和会话管理等（如服务器验证用户登录）
表示层：数据格式化，代码转换，数据加密等
应用层：为操作系统或网络应用程序提供访问网络服务的接口：文件传输，电子邮件，文件服务，虚拟终端等
TCP/IP模型

网络接口层（对应OSI物理层、数据链路层）
网络层：IP,ICMP
传输层：TCP,UDP
应用层（对应OSI会话层、表示层、应用层）：HTTP,FTP,DNS
TCP原理
可靠连接，三次握手，四次挥手

1.三次握手：防止了服务器端的一直等待而浪费资源，例如只是两次握手，如果s确认之后c就掉线了，那么s就会浪费资源
1.syn-c = x，表示这消息是x序号
2.ack-s = x + 1，表示syn-c这个消息接收成功。syn-s = y，表示这消息是y序号。
3.ack-c = y + 1，表示syn-s这条消息接收成功
2.四次挥手：TCP是全双工模式
1.fin-c = x , 表示现在需要关闭c到s了。ack-c = y,表示上一条s的消息已经接收完毕
2.ack-s = x + 1，表示需要关闭的fin-c消息已经接收到了，同意关闭
3.fin-s = y + 1，表示s已经准备好关闭了，就等c的*后一条命令
4.ack-c = y + 1，表示c已经关闭，让s也关闭
3.滑动窗口，停止等待、后退N、选择重传
4.拥塞控制，慢启动、拥塞避免、加速递减、快重传快恢复
TCP的三次握手过程？为什么会采用三次握手，若采用二次握手可以吗？
答:建立连接的过程是利用客户服务器模式，假设主机A为客户端，主机B为服务器端。

（1）TCP的三次握手过程：主机A向B发送连接请求；主机B对收到的主机A的报文段进行确认；主机A再次对主机B的确认进行确认。
（2）采用三次握手是为了防止失效的连接请求报文段突然又传送到主机B，因而产生错误。失效的连接请求报文段是指：主机A发出的连接请求没有收到主机B的确认，于是经过一段时间后，主机A又重新向主机B发送连接请求，且建立成功，顺序完成数据传输。考虑这样一种特殊情况，主机A*次发送的连接请求并没有丢失，而是因为网络节点导致延迟达到主机B，主机B以为是主机A又发起的新连接，于是主机B同意连接，并向主机A发回确认，但是此时主机A根本不会理会，主机B就一直在等待主机A发送数据，导致主机B的资源浪费。
（3）采用两次握手不行，原因就是上面说的实效的连接请求的特殊情况。
Http位于TCP/IP模型中的第几层？为什么说Http是可靠的数据传输协议？
tcp/ip的五层模型： 从下到上：物理层->数据链路层->网络层->传输层->应用层 其中tcp/ip位于模型中的网络层，处于同一层的还有ICMP（网络控制信息协议）。http位于模型中的应用层 由于tcp/ip是面向连接的可靠协议，而http是在传输层基于tcp/ip协议的，所以说http是可靠的数据传输协议。

HTTP协议的结构？
请求报文：请求行 － 通用信息头 － 请求头 － 实体头 － 报文主体
响应报文：状态行 － 通用信息头 － 响应头 － 实体头 － 报文主体

HTTP怎么处理长连接？
在HTTP/1.0中，默认使用的是短连接。也就是说，浏览器和服务器每进行一次HTTP操作，就建立一次连接，但任务结束就中断连接。 HTTP/1.1起，默认使用长连接，用以保持连接特性。使用长连接的HTTP协议，会在响应头有： Connection:keep-alive。Keep-Alive不会永久保持连接，它有一个保持时间，可以在不同的服务器软件（如Apache）中设定这个时间。实现长连接要客户端和服务端都支持长连接。

http协议有几种版本，它们有什么区别

HTTP/0.9 :只接受GET一种请求方法，没有在通信中指定版本号，且不支持请求头。由于该版本不支持POST方法，因此客户端无法向服务器传递太多信息，已过时。
HTTP/1.0 :*个在通信中指定的版本号，至今被广泛采用，特别是在代理服务器中。
HTTP/1.1 :当前版本号，持久连接被默认采用，并能很好地配合代理服务器工作。还支持以管道方式在同时发送多个请求，以便降低线路负载，提高传输速度。
HTTP/2.0:一个HTTP/2.0连接通过一个TCP连接（上面运行的应用程序级协议[TCP] ）。 客户端是TCP连接发起者。
http get与post方法在项目中如何选择，有何区别
GET一般用于获取/查询资源信息，而POST一般用于更新资源信息

1.根据HTTP规范，GET用于信息获取，而且应该是安全的和幂等的。
(1).所谓安全的意味着该操作用于获取信息而非修改信息。换句话说，GET 请求一般不应产生副作用。就是说，它仅仅是获取资源信息，就像数据库查询一样，不会修改，增加数据，不会影响资源的状态。
注意：这里安全的含义仅仅是指是非修改信息。
(2).幂等的意味着对同一URL的多个请求应该返回同样的结果。
2.根据HTTP规范，POST表示可能修改变服务器上的资源的请求。
3 get提交数据会有大小的限制（1024k），post提交无限制
HTTP HTTPS的区别:
https是用SSL加密的。电脑与服务器之间收发的信息传输将更加安全。
Web服务器启用SSL需要获得一个服务器证书并将该证书与要使用SSL的服务器绑定。
http和https使用的是完全不同的连接方式,用的端口也不一样,前者是80,后者是443。
HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议,要比http协议安全

为什么需要 HTTPS ？
超文本传输协议 (HTTP) 是一个用来通过互联网传输和接收信息的协议。HTTP 使用请求/响应的过程，因此信息可在服务器间快速、轻松而且精确的进行传输。当你访问 Web 页面的时候你就是在使用 HTTP 协议，但 HTTP 是不安全的，可以轻松对窃听你跟 Web 服务器之间的数据传输。在很多情况下，客户和服务器之间传输的是敏感歇息，需要防止未经授权的访问。为了满足这个要求，网景公司(Netscape)推出了HTTPS，也就是基于安全套接字层的 HTTP 协议。

HTTP 和 HTTPS 的不同之处
1.HTTP 的 URL 以 http:// 开头，而 HTTPS 的 URL 以 https:// 开头
2.HTTP 是不安全的，而 HTTPS 是安全的
3.HTTP 标准端口是 80 ，而 HTTPS 的标准端口是 443
4.在 OSI 网络模型中，HTTP 工作于应用层，而 HTTPS 工作在传输层
5.HTTP 无需加密，而 HTTPS 对传输的数据进行加密
6.HTTP 无需证书，而 HTTPS 需要认证证书

HttpClient与HttpUrlConnection的区别
此处延伸：Volley里用的哪种请求方式（2.3前HttpClient，2.3后HttpUrlConnection）
首先HttpClient和HttpUrlConnection 这两种方式都支持Https协议，都是以流的形式进行上传或者下载数据，也可以说是以流的形式进行数据的传输，还有ipv6,以及连接池等功能。HttpClient这个拥有非常多的API，所以如果想要进行扩展的话，并且不破坏它的兼容性的话，很难进行扩展，也就是这个原因，Google在Android6.0的时候，直接就弃用了这个HttpClient. 而HttpUrlConnection相对来说就是比较轻量级了，API比较少，容易扩展，并且能够满足Android大部分的数据传输。比较经典的一个框架volley，在2.3版本以前都是使用HttpClient,在2.3以后就使用了HttpUrlConnection。

Socket建立网络连接的步骤
建立Socket连接至少需要一对套接字，其中一个运行与客户端–ClientSocket，一个运行于服务端–ServiceSocket

1、服务器监听：服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态，等待客户端的连接请求。
2、客户端请求：指客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。注意：客户端的套接字必须描述他要连接的服务器的套接字，指出服务器套接字的地址和端口号，然后就像服务器端套接字提出连接请求。
3、连接确认：当服务器端套接字监听到客户端套接字的连接请求时，就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的描述发给客户端，一旦客户端确认了此描述，双方就正式建立连接。而服务端套接字则继续处于监听状态，继续接收其他客户端套接字的连接请求。
HTTP请求的完整过程？

Http请求的过程，与电脑上访问一个网页大概相同
建立TCP连接
在HTTP工作开始之前，Web浏览器首先要通过网络与Web服务器建立连接，该连接是通过TCP来完成的，该协议与IP协议共同构建Internet，即著名的TCP/IP协议族，因此Internet又被称作是TCP/IP网络。HTTP是比TCP更高层次的应用层协议，根据规则，只有低层协议建立之后才能进行更高层协议的连接，因此，首先要建立TCP连接，一般TCP连接的端口号是80。
Web浏览器向Web服务器发送请求命令
一旦建立了TCP连接，Web浏览器就会向Web服务器发送请求命令。例如：GET/sample/hello.jsp HTTP/1.1。
Web浏览器发送请求头信息
浏览器发送其请求命令之后，还要以头信息的形式向Web服务器发送一些别的信息，之后浏览器发送了一空白行来通知服务器，它已经结束了该头信息的发送。
Web服务器应答 客户机向服务器发出请求后，服务器会客户机回送应答， HTTP/1.1 200 OK ，应答的*部分是协议的版本号和应答状态码。
Web服务器发送应答头信息
正如客户端会随同请求发送关于自身的信息一样，服务器也会随同应答向用户发送关于它自己的数据及被请求的文档。
Web服务器向浏览器发送数据
Web服务器向浏览器发送头信息后，它会发送一个空白行来表示头信息的发送到此为结束，接着，它就以Content-Type应答头信息所描述的格式发送用户所请求的实际数据。
Web服务器关闭TCP连接
一般情况下，一旦Web服务器向浏览器发送了请求数据，它就要关闭TCP连接，然后如果浏览器或者服务器在其头信息加入了这行代码：Connection:keep-alive
TCP连接在发送后将仍然保持打开状态，于是，浏览器可以继续通过相同的连接发送请求。保持连接节省了为每个请求建立新连接所需的时间，还节约了网络带宽。
浏览器输入地址到返回结果发生了什么

1.DNS解析
2.TCP连接
3.发送HTTP请求
4.服务器处理请求并返回HTTP报文
5.浏览器解析渲染页面
6.连接结束
在浏览器中输入www.baidu.com后执行的全部过程

1、客户端浏览器通过DNS解析到www.baidu.com的IP地址220.181.27.48，通过这个IP地址找到客户端到服务器的路径。客户端浏览器发起一个HTTP会话到220.161.27.48，然后通过TCP进行封装数据包，输入到网络层。
2、在客户端的传输层，把HTTP会话请求分成报文段，添加源和目的端口，如服务器使用80端口监听客户端的请求，客户端由系统随机选择一个端口如5000，与服务器进行交换，服务器把相应的请求返回给客户端的5000端口。然后使用IP层的IP地址查找目的端。
3、客户端的网络层不用关心应用层或者传输层的东西，主要做的是通过查找路由表确定如何到达服务器，期间可能经过多个路由器，这些都是由路由器来完成的工作，我不作过多的描述，无非就是通过查找路由表决定通过那个路径到达服务器。
4、客户端的链路层，包通过链路层发送到路由器，通过邻居协议查找给定IP地址的MAC地址，然后发送ARP请求查找目的地址，如果得到回应后就可以使用ARP的请求应答交换的IP数据包现在就可以传输了，然后发送IP数据包到达服务器的地址。
Cookie与Session的作用于原理？

cookie机制：客户端保持状态。“Set-Cookie”域；cookie的内容主要包括：名字，值，过期时间，路径和域。浏览器检查所有存储的cookie，如果某个cookie所声明的作用范围大于等于将要请求的资源所在的位置，则把该cookie附在请求资源的HTTP请求头上发送给服务器。
session机制：服务器端保持状态。 当程序需要为某个客户端的请求创建一个session时，服务器首先检查这个客户端的请求里是否已包含了一个session标识（称为session id），如果已包含则说明以前已经为此客户端创建过session，服务器就按照session id把这个session检索出来使用（检索不到，会新建一个）；如果客户端请求不包含session id，则为此客户端创建一个session并且生成一个与此session相关联的session id，session id的值应该是一个既不会重复，又不容易被找到规律以仿造的字符串，这个session id将被在本次响应中返回给客户端保存。
网络劫持的类型原理

1.DNS劫持、欺骗、污染
2.http劫持：重定向、注入js，http注入、报文扩展

本文完~

Android面试题线程篇，由本人整理汇总，后续将推出系列篇，如果喜欢请持续关注和推荐。

开启线程的三种方式？

java有三种创建线程的方式，分别是继承Thread类、实现Runable接口和使用线程池

线程池：

Android中常见的线程池有四种，FixedThreadPool、CachedThreadPool、ScheduledThreadPool、SingleThreadExecutor。

FixedThreadPool线程池是通过Executors的new FixedThreadPool方法来创建。它的特点是该线程池中的线程数量是固定的。即使线程处于闲置的状态，它们也不会被回收，除非线程池被关闭。当所有的线程都处于活跃状态的时候，新任务就处于队列中等待线程来处理。注意，FixedThreadPool只有核心线程，没有非核心线程。
CachedThreadPool线程池是通过Executors的newCachedThreadPool进行创建的。它是一种线程数目不固定的线程池，它没有核心线程，只有非核心线程，当线程池中的线程都处于活跃状态，就会创建新的线程来处理新的任务。否则就会利用闲置的线程来处理新的任务。线程池中的线程都有超时机制，这个超时机制时长是60s，超过这个时间，闲置的线程就会被回收。这种线程池适合处理大量并且耗时较少的任务。这里得说一下，CachedThreadPool的任务队列，基本都是空的。
ScheduledThreadPool线程池是通过Executors的newScheduledThreadPool进行创建的，它的核心线程是固定的，但是非核心线程数是不固定的，并且当非核心线程一处于空闲状态，就立即被回收。这种线程适合执行定时任务和具有固定周期的重复任务。
SingleThreadExecutor线程池是通过Executors的newSingleThreadExecutor方法来创建的，这类线程池中只有一个核心线程，也没有非核心线程，这就确保了所有任务能够在同一个线程并且按照顺序来执行，这样就不需要考虑线程同步的问题。
sleep(), wait()的区别

sleep不释放同步锁，自动唤醒，需要try catch, wait释放同步锁，需要notify来唤醒
sleep是线程的方法 wait是Object的方法
谈谈wait/notify关键字的理解

等待对象的同步锁,需要获得该对象的同步锁才可以调用这个方法,否则编译可以通过，但运行时会收到一个异常：IllegalMonitorStateException。

调用任意对象的 wait() 方法导致该线程阻塞，该线程不可继续执行，并且该对象上的锁被释放。

唤醒在等待该对象同步锁的线程(只唤醒一个,如果有多个在等待),注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。

调用任意对象的notify()方法则导致因调用该对象的 wait()方法而阻塞的线程中随机选择的一个解除阻塞（但要等到获得锁后才真正可执行）。

Thread中的start()和run()方法有什么区别

start()方法是用来启动新创建的线程，而start()内部调用了run()方法，这和直接调用run()方法是不一样的，如果直接调用run()方法，

如何控制某个方法允许并发访问线程的个数？

semaphore.acquire() 请求一个信号量，这时候的信号量个数-1（一旦没有可使用的信号量，也即信号量个数变为负数时，再次请求的时候就会阻塞，直到其他线程释放了信号量）
semaphore.release() 释放一个信号量，此时信号量个数+1
什么导致线程阻塞？线程如何关闭？

阻塞式方法是指程序会一直等待该方法完成期间不做其他事情，ServerSocket的accept()方法就是一直等待客户端连接。这里的阻塞是指调用结果返回之前，当前线程会被挂起，直到得到结果之后才会返回。此外，还有异步和非阻塞式方法在任务完成前就返回。

一种是调用它里面的stop()方法

另一种就是你自己设置一个停止线程的标记 （推荐这种）

如何保证线程安全？

1.synchronized；
2.Object方法中的wait,notify；
3.ThreadLocal机制 来实现的。
如何实现线程同步？

1、synchronized关键字修改的方法。
2、synchronized关键字修饰的语句块
3、使用特殊域变量（volatile）实现线程同步
线程间操作List

List list = Collections.synchronizedList(new ArrayList());

谈谈对Synchronized关键字，类锁，方法锁，重入锁的理解

java的对象锁和类锁：java的对象锁和类锁在锁的概念上基本上和内置锁是一致的，但是，两个锁实际是有很大的区别的，对象锁是用于对象实例方法，或者一个对象实例上的，类锁是用于类的静态方法或者一个类的class对象上的。我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。但是有一点必须注意的是，其实类锁只是一个概念上的东西，并不是真实存在的，它只是用来帮助我们理解锁定实例方法和静态方法的区别的

synchronized 和volatile 关键字的区别

1.volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取；synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
2.volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的
3.volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性
4.volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。
5.volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化
ReentrantLock 、synchronized和volatile比较

java在过去很长一段时间只能通过synchronized关键字来实现互斥，它有一些缺点。比如你不能扩展锁之外的方法或者块边界，尝试获取锁时不能中途取消等。Java 5 通过Lock接口提供了更复杂的控制来解决这些问题。 ReentrantLock 类实现了 Lock，它拥有与 synchronized 相同的并发性和内存语义且它还具有可扩展性。

线程同步的问题，常用的线程同步

1.sycn：保证了原子性、可见性、有序性
2.锁：保证了原子性、可见性、有序性
1.自旋锁:可以使线程在没有取得锁的时候，不被挂起，而转去执行一个空循环。
1.优点:线程被挂起的几率减少，线程执行的连贯性加强。用于对于锁竞争不是很激烈，锁占用时间很短的并发线程。
2.缺点:过多浪费CPU时间，有一个线程连续两次试图获得自旋锁引起死锁
2.阻塞锁:没得到锁的线程等待或者挂起，Sycn、Lock
3.可重入锁:一个线程可多次获取该锁，Sycn、Lock
4.悲观锁:每次去拿数据的时候都认为别人会修改，所以会阻塞全部其他线程 Sycn、Lock
5.乐观锁:每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。cas
6.显示锁和内置锁:显示锁用Lock来定义、内置锁用synchronized。
7.读-写锁:为了提高性能，Java提供了读
3.volatile
1.只能保证可见性，不能保证原子性
2.自增操作有三步，此时多线程写会出现问题
4.cas
1.操作:内存值V、旧的预期值A、要修改的值B，当且仅当预期值A和内存值V相同时，将内存值修改为B并返回true，否则什么都不做并返回false。
2.解释:本地副本为A，共享内存为V，线程A要把V修改成B。某个时刻线程A要把V修改成B，如果A和V不同那么就表示有其他线程在修改V，此时就表示修改失败，否则表示没有其他线程修改，那么把V改成B。
3.局限:如果V被修改成V1然后又被改成V，此时cas识别不出变化，还是认为没有其他线程在修改V，此时就会有问题
4.局限解决:将V带上版本。
5.线程不安全到底是怎么回事：
1.一个线程写，多个线程读的时候，会造成写了一半就去读
2.多线程写，会造成脏数据
有三个线程T1，T2，T3，怎么确保它们按顺序执行？

在多线程中有多种方法让线程按特定顺序执行，你可以用线程类的join()方法在一个线程中启动另一个线程，另外一个线程完成该线程继续执行。为了确保三个线程的顺序你应该先启动*后一个(T3调用T2，T2调用T1)，这样T1就会先完成而T3*后完成。

Android的多线程模型有哪几种？

Android提供了四种常用的操作多线程的方式，分别是：

Handler+Thread
AsyncTask
ThreadPoolExecutor
IntentService
Android多线程的实现方式有哪些?

Thread & AsyncTask
Thread 可以与Loop 和 Handler 共用建立消息处理队列
AsyncTask 可以作为线程池并行处理多任务
多线程的优劣

使用多进程显而易见的好处就是分担主进程的内存压力。我们的应用越做越大，内存越来越多，将一些独立的组件放到不同的进程，它就不占用主进程的内存空间了。当然还有其他好处，有心人会发现Android后台进程里有很多应用是多个进程的，因为它们要常驻后台，特别是即时通讯或者社交应用，不过现在多进程已经被用烂了。典型用法是在启动一个不可见的轻量级私有进程，在后台收发消息，或者做一些耗时的事情，或者开机启动这个进程，然后做监听等。还有就是防止主进程被杀守护进程，守护进程和主进程之间相互监视，有一方被杀就重新启动它。 坏处的话，多占用了系统的空间，大家都这么用的话系统内存很容易占满而导致卡顿。消耗用户的电量。应用程序架构会变复杂，应为要处理多进程之间的通信。这里又是另外一个问题了。

AsyncTask的工作原理

AsyncTask是Android本身提供的一种轻量级的异步任务类。它可以在线程池中执行后台任务，然后把执行的进度和*终的结果传递给主线程更新UI。实际上，AsyncTask内部是封装了Thread和Handler。虽然AsyncTask很方便的执行后台任务，以及在主线程上更新UI，但是，AsyncTask并不合适进行特别耗时的后台操作，对于特别耗时的任务，个人还是建议使用线程池。

HandlerThread是什么

MessageQueue + Looper + Handler

IntentService是什么

含有HandlerThread的Service，可以多次startService()来多次在子线程中进行 onHandlerIntent()的调用。

线程间如何通信

我们知道线程是CPU调度的*小单位。在Android中主线程是不能够做耗时操作的，子线程是不能够更新UI的。而线程间通信的方式有很多，比如广播，Eventbus，接口回掉，在Android中主要是使用handler。handler通过调用sendmessage方法，将保存消息的Message发送到Messagequeue中，而looper对象不断的调用loop方法，从messageueue中取出message，交给handler处理，从而完成线程间通信。

Android面试题进程篇，由本人整理汇总，后续将推出系列篇，如果喜欢请持续关注和推荐。

操作系统进程和线程的区别

1.简而言之,一个程序至少有一个进程,一个进程至少有一个线程.

2.线程的划分尺度小于进程，使得多线程程序的并发性高。

3.另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而*大地提高了程序的运行效率。

4.多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配

Handler、Looper消息队列模型，各部分的作用

1.MessageQueue：读取会自动删除消息，单链表维护，在插入和删除上有优势。在其next()中会无限循环，不断判断是否有消息，有就返回这条消息并移除。

2.Looper：Looper创建的时候会创建一个MessageQueue，调用loop()方法的时候消息循环开始，loop()也是一个死循环，会不断调用messageQueue的next()，当有消息就处理，否则阻塞在messageQueue的next()中。当Looper的quit()被调用的时候会调用messageQueue的quit(),此时next()会返回null，然后loop()方法也跟着退出。

3.Handler：在主线程构造一个Handler，然后在其他线程调用sendMessage(),此时主线程的MessageQueue中会插入一条message，然后被Looper使用。

4.系统的主线程在ActivityThread的main()为入口开启主线程，其中定义了内部类Activity.H定义了一系列消息类型，包含四大组件的启动停止。

5.MessageQueue和Looper是一对一关系，Handler和Looper是多对一

谈谈你对binder机制的理解?

binder是一种IPC机制,进程间通讯的一种工具. Java层可以利用aidl工具来实现相应的接口.

Android中进程间通信有哪些实现方式？

由于应用程序之间不能共享内存。在不同应用程序之间交互数据（跨进程通讯），在Android SDK中提供了4种用于跨进程通讯的方式。这4种方式正好对应于android系统中4种应用程序组件：Activity、Content Provider、Broadcast和Service:

Activity可以跨进程调用其他应用程序的Activity；

ContentProvider可以跨进程访问其他应用程序中的数据（以Cursor对象形式返回）， 当然，也可以对其他应用程序的数据进行增、删、改操作；

Broadcast可以向android系统中所有应用程序发送广播， 而需要跨进程通讯的应用程序可以监听这些广播；

Service和Content Provider类似，也可以访问其他应用程序中的数据， 但不同的是，ContentProvider返回的是Cursor对象， 而Service返回的是Java对象，这种可以跨进程通讯的服务叫AIDL服务。

android的IPC通信方式，线程（进程间）通信机制有哪些

1.ipc通信方式：binder、contentprovider、socket

2.操作系统进程通讯方式：共享内存、socket、管道

描述一次跨进程通讯

1.client、proxy、serviceManager、BinderDriver、impl、service

2.client发起一个请求service信息的Binder请求到BinderDriver中，serviceManager发现BinderDiriver中有自己的请求 然后将clinet请求的service的数据返回给client这样完成了一次Binder通讯

3.clinet获取的service信息就是该service的proxy，此时调用proxy的方法，proxy将请求发送到BinderDriver中，此时service的 Binder线程池循环发现有自己的请求，然后用impl就处理这个请求*后返回，这样完成了第二次Binder通讯

4.中间client可挂起，也可以不挂起，有一个关键字oneway可以解决这个

Android开发中何时使用多进程？使用多进程的好处是什么？

要想知道如何使用多进程，先要知道Android里的多进程概念。一般情况下，一个应用程序就是一个进程，这个进程名称就是应用程序包名。我们知道进程是系统分配资源和调度的基本单位，所以每个进程都有自己独立的资源和内存空间，别的进程是不能任意访问其他进程的内存和资源的。

如何让自己的应用拥有多个进程？

很简单，我们的四大组件在AndroidManifest文件中注册的时候，有个属性是android:process，1.这里可以指定组件的所处的进程。默认就是应用的主进程。指定为别的进程之后，系统在启动这个组件的时候，就先创建（如果还没创建的话）这个进程，然后再创建该组件。你可以重载Application类的onCreate方法，打印出它的进程名称，就可以清楚的看见了。再设置android:process属性时候，有个地方需要注意：如果是android:process=”:deamon”，以:开头的名字，则表示这是一个应用程序的私有进程，否则它是一个全局进程。私有进程的进程名称是会在冒号前自动加上包名，而全局进程则不会。一般我们都是有私有进程，很少使用全局进程。

如何保证Service不被杀死？

从3个层面入手：

A.提供进程优先级，降低进程被杀死的概率:

方法一：监控手机锁屏解锁事件，在屏幕锁屏时启动1个像素的 Activity，在用户解锁时将 Activity 销毁掉。

方法二：启动前台service。

方法三：提升service优先级： 在AndroidManifest.xml文件中对于intent-filter可以通过android:priority = “1000”这个属性设置*高优先级，1000是*高值，如果数字越小则优先级越低，同时适用于广播。

B. 在进程被杀死后，进行拉活:

方法一：注册高频率广播接收器，唤起进程。如网络变化，解锁屏幕，开机等

方法二：双进程相互唤起。

方法三：依靠系统唤起。

方法四：onDestroy方法里重启service：service +broadcast 方式，就是当service走ondestory的时候，发送一个自定义的广播，当收到广播的时候，重新启动service；

C. 依靠第三方根据终端不同:

在小米手机（包括 MIUI）接入小米推送、华为手机接入华为推送；其他手机可以考虑接入腾讯信鸽或*光推送与小米推送做 A/B Test。

 

讲一下android中进程的优先级？

前台进程 可见进程 服务进程 后台进程 空进程

应用常驻后台，避免被第三方杀掉的方法

Service设置成START_STICKY kill 后会被重启（等待5秒左右），重传Intent，保持与重启前一样

通过 startForeground将进程设置为前台进程， 做前台服务，优先级和前台应用一个级别，除非在系统内存非常缺，否则此进程不会被 kill

双进程Service： 让2个进程互相保护对方，其中一个Service被清理后，另外没被清理的进程可以立即重启进程

用C编写守护进程(即子进程) : Android系统中当前进程(Process)fork出来的子进程，被系统认为是两个不同的进程。当父进程被杀死的时候，子进程仍然可以存活，并不受影响（Android5.0以上的版本不可行）

联系厂商，加入白名单

Android面试题算法篇，由本人整理汇总，后续将继续推出系列篇，如果喜欢请持续关注和推荐，更多精彩内容

红黑树特点

1.root节点和叶子节点是黑色
2.红色节点后必须为黑色节点
3.从root到叶子每条路径的黑节点数量相同
实现阶乘

//采用递归法
public static long factorial(long number) {
if (number <= 1)
return 1;
else
return number * factorial(number – 1);
}
//采用循环连乘法
public static int fact(int num){
int temp=1;
int factorial=1;
while(num>=temp){
factorial=factorial*temp;
temp++;
}
return factorial;
}
二分查找

//递归法
int binarySearch(int array[], int low, int high, int target) {
if (low > high) return -1;
int mid = low + (high – low) / 2;
if (array[mid] > target)
return binarysearch(array, low, mid – 1, target);
if (array[mid] < target)
return binarysearch(array, mid + 1, high, target);
return mid;
}
//循环法
int binarySearch2(int a[], int key) {
int low = 0;
int high = a.length – 1;
while (low <= high) {
int mid = low + (high – low) / 2;
if (a[mid] > key)
high = mid – 1;
else if (a[mid] < key)
low = mid + 1;
else
return mid;
}
return -1;
}
二分查找中值的计算
这是一个经典的话题，如何计算二分查找中的中值？大家一般给出了两种计算方法：
算法一： mid = (low + high) / 2
算法二： mid = low + (high – low)/2
乍看起来，算法一简洁，算法二提取之后，跟算法一没有什么区别。但是实际上，区别是存在的。算法一的做法，在*端情况下，(low+high)存在着溢出的风险，进而得到错误的mid结果，导致程序错误。而算法二能够保证计算出来的mid，一定大于low，小于high，不存在溢出的问题。

二分查找法的缺陷
二分查找法的O(logn)让它成为十分高效的算法。不过它的缺陷却也是那么明显的。就在它的限定之上：必须有序，我们很难保证我们的数组都是有序的。当然可以在构建数组的时候进行排序，可是又落到了第二个瓶颈上：它必须是数组。
数组读取效率是O(1)，可是它的插入和删除某个元素的效率却是O(n)。因而导致构建有序数组变成低效的事情。
解决这些缺陷问题更好的方法应该是使用二叉查找树了，*好自然是自平衡二叉查找树了，既能高效的（O(n log n)）构建有序元素集合，又能如同二分查找法一样快速（O(log n)）的搜寻目标数。

用两个栈实现队列

题目描述：
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

思路：
压入元素直接压入stack1 删除元素先查看stack2是否为空，非空则弹出；空则将stack1中元素取出，置于stack2中

代码：

public class StackQueue {

Stack<Integer> stack1 = new Stack<Integer>();
Stack<Integer> stack2 = new Stack<Integer>();

public void push(int node){
stack1.push(node);
}

public int pop(){
if(stack2.empty()){
while(!stack1.empty())
stack2.push(stack1.pop());
}
return stack2.pop();
}
递归和迭代的区别是什么，各有什么优缺点？

程序调用自身称为递归，利用变量的原值推出新值称为迭代。
递归的优点大问题转化为小问题，可以减少代码量，同时代码精简，可读性好；
缺点就是递归调用浪费了空间，而且递归太深容易造成堆栈的溢出。
迭代的好处就是代码运行效率好，因为时间只因循环次数增加而增加，而且没有额外的空间开销；
缺点就是代码不如递归简洁
判断101-200之间有多少个素数，并输出所有素数
素数又称质数。所谓素数是指除了 1 和它本身以外，不能被任何整数整除的数，例如17就是素数，因为它不能被 2~16 的任一整数整除。

思路1)：因此判断一个整数m是否是素数，只需把 m 被 2 ~ m-1 之间的每一个整数去除，如果都不能被整除，那么 m 就是一个素数。

思路2)：另外判断方法还可以简化。m 不必被 2 ~ m-1 之间的每一个整数去除，只需被 2 ~ 之间的每一个整数去除就可以了。如果 m 不能被 2 ~ 间任一整数整除，m 必定是素数。例如判别 17 是是否为素数，只需使 17 被 2~4 之间的每一个整数去除，由于都不能整除，可以判定 17 是素数。

原因：因为如果 m 能被 2 ~ m-1 之间任一整数整除，其二个因子必定有一个小于或等于 ，另一个大于或等于 。例如 16 能被 2、4、8 整除，16=28，2 小于 4，8 大于 4，16=44，4=√16，因此只需判定在 2~4 之间有无因子即可。

public class mainCase{
public static void main(String args[]){
int i=0;
for(i=101;i<=200;i++)
if(math.isPrime(i)==true)
System.out.println(i);
}
}
class math
{
//方法1
public static boolean isPrime(int x)
{
for (int i=2;i<=x/2;i++)
if (x%2==0)
return false;
return true;
}

//方法2
public static boolean isPrime2(int m)
{
int k=(int)sqrt((double)m);
for (int i=2;i<=k;i++)
if (m%i==0)
return false;
return true;
}
}
字符串小写字母转换成大写字母

public String toUpperCase(String str)
{
if (str != null && str.length() > 0) {
for (int i=0; i<str.length(); i++) {
char c = str.charAt(i);
c += 32;
}
}
return str;
}
进制转换：给定一个十进制数 n 和 一个整数 k, 将 十进制数 n 转换成 k进制数

public String hexConversion(int n, int k) {
StringBuffer resultNumber = new StringBuffer();
tenToK(resultNumber, n, k);
System.out.println(“n:k:result: ” + n +” “+ k + ” ” + resultNumber.toString());

return resultNumber.toString();
}

private void tenToK(StringBuffer stringBuffer, int n, int k) {
int integral = n/k;
int mode = n % k;
stringBuffer.insert(0, mode);
if (integral >= k) {
tenToK(stringBuffer, integral, k);
} else if (integral > 0) {
stringBuffer.insert(0, integral);
}
}
位运算实现加法

public int aplusb(int a, int b) {
int sum_without_carry, carry;

sum_without_carry = a^b; //没有进位的和
carry = (a&b)<<1; //进位
if(carry==0) {
return sum_without_carry;
} else {
return aplusb(sum_without_carry, carry);
}
}
二叉树排序树

首先定义节点类

public class TreeNode {
Object obj;
TreeNode parent;
TreeNode lchild;
TreeNode rchild;

public TreeNode(int obj) {
this.obj = obj;
}
}
然后创建一个树类

public class Tree {

/**
* 先序遍历二叉树
* @param root
*/
public void Fprint(TreeNode root){
if(root!=null){
System.out.println(root.obj);
Fprint(root.lchild);
Fprint(root.rchild);
}
}

/**
* 中序遍历二叉树
* @param root
*/
public void Mprint(TreeNode root){
if(root!=null){
Mprint(root.lchild);
System.out.println(root.obj);

Mprint(root.rchild);
}
}

/**
* 根据一个int数组建立二叉排序树
* @param a 数组
* @return
*/
public TreeNode Build(int[] a){
if(a.length==0){
return null;
}
TreeNode root = new TreeNode(a[0]);
for(int i=1;i<a.length;i++){
TreeNode newnode = new TreeNode(a[i]);
sort(root,newnode);
}
return root;
}
/**
* 在二叉排序树中添加一个节点
* @param root 二叉树的根节点
* @param newnode 新加入的加点
* @return
*/
public void sort(TreeNode root,TreeNode newnode){
TreeNode node = root;
if((Integer)newnode.obj<=(Integer)node.obj){
if(node.lchild==null){
newnode.parent = node;
node.lchild = newnode;
}else{
sort(node.lchild,newnode);
}
}else{
if(node.rchild==null){
newnode.parent = node;
node.rchild = newnode;
}else{
sort(node.rchild,newnode);
}
}
}
}
创建二叉排序树的时候随便传入一个int型数组a[]
然后通过自顶向下的方式一个一个的将a[0]—a[n]个元素创建的节点类一个一个的拼接到树上
此后只需要再创建一个主函数类来调用便行了

public class Test {

public static void main(String[] args) {
int a[] = {100,35,3,44,212,453};
Tree t = new Tree();
TreeNode root = t.Build(a);
t.Mprint(root);
}

}
这样便可通过创建二叉排序树并且中序遍历该二叉树的方式，来将一组混乱的数据整理成一组从小到大的数据了。

冒泡排序

算法描述：对于给定的n个记录，从*个记录开始依次对相邻的两个记录进行比较，当前面的记录大于后面的记录时，交换位置，进行一轮比较和交换后，n个记录中的*大记录将位于第n位；然后对前（n-1）个记录进行第二轮比较；重复该过程直到进行比较的记录只剩下一个为止。

package sorting;

/**
* 冒泡排序
* 平均O(n^2),*好O(n),*坏O(n^2);空间复杂度O(1);稳定;简单
* @author zeng
*
*/
public class BubbleSort {

public static void bubbleSort(int[] a){

int n = a.length;
int temp = 0;
for(int i=0;i<n;i++){
for(int j=0;j<n-i-1;j++){
if(a[j]<a[j+1]){
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
}

public static void main(String[] args){
int[] a ={49,38,65,97,76,13,27,50};
bubbleSort(a);
for(int j:a)
System.out.print(j+” “);
}
}
插入排序

算法描述：对于给定的一个数组，初始时假设*个记录自成一个有序序列，其余记录为无序序列。接着从第二个记录开始，按照记录的大小依次将当前处理的记录插入到其之前的有序序列中，直至*后一个记录插入到有序序列中为止。

package sorting;

/**
* 插入排序
* 平均O(n^2),*好O(n),*坏O(n^2);空间复杂度O(1);稳定;简单
* @author zeng
*
*/
public class InsertionSort {

public static void insertionSort(int[] a) {
int tmp;
for (int i = 1; i < a.length; i++) {
for (int j = i; j > 0; j–) {
if (a[j] < a[j – 1]) {
tmp = a[j – 1];
a[j – 1] = a[j];
a[j] = tmp;
}
}
}
}

public static void main(String[] args) {
int[] a = { 49, 38, 65, 97, 76, 13, 27, 50 };
insertionSort(a);
for (int i : a)
System.out.print(i + ” “);
}
}
选择排序

算法描述：对于给定的一组记录，经过*轮比较后得到*小的记录，然后将该记录与*个记录的位置进行交换；接着对不包括*个记录以外的其他记录进行第二轮比较，得到*小的记录并与第二个记录进行位置交换；重复该过程，直到进行比较的记录只有一个时为止。

package sorting;

/**
* 选择排序
* 平均O(n^2),*好O(n^2),*坏O(n^2);空间复杂度O(1);不稳定;简单
* @author zeng
*
*/
public class SelectionSort {

public static void selectionSort(int[] a) {
int n = a.length;
for (int i = 0; i < n; i++) {
int k = i;
// 找出*小值的小标
for (int j = i + 1; j < n; j++) {
if (a[j] < a[k]) {
k = j;
}
}
// 将*小值放到排序序列末尾
if (k > i) {
int tmp = a[i];
a[i] = a[k];
a[k] = tmp;
}
}
}

public static void main(String[] args) {
int[] b = { 49, 38, 65, 97, 76, 13, 27, 50 };
selectionSort(b);
for (int i : b)
System.out.print(i + ” “);
}
}
快速排序

算法描述：对于一组给定的记录，通过一趟排序后，将原序列分为两部分，其中前一部分的所有记录均比后一部分的所有记录小，然后再依次对前后两部分的记录进行快速排序，递归该过程，直到序列中的所有记录均有序为止。

package sorting;

/**
* 快速排序
* 平均O(nlogn),*好O(nlogn),*坏O(n^2);空间复杂度O(nlogn);不稳定;较复杂
* @author zeng
*
*/
public class QuickSort {

public static void sort(int[] a, int low, int high) {
if(low>=high)
return;
int i = low;
int j = high;
int key = a[i];
while (i < j) {
while (i < j && a[j] >= key)
j–;
a[i++] = a[j];
while (i < j && a[i] <= key)
i++;
a[j–] = a[i];
}
a[i] = key;
sort(a,low,i-1);
sort(a,i+1,high);
}

public static void quickSort(int[] a) {
sort(a, 0, a.length-1);
for(int i:a)
System.out.print(i+” “);
}

public static void main(String[] args) {
int[] a = { 49, 38, 65, 97, 76, 13, 27, 50 };
quickSort(a);
}
}
归并排序

算法描述：对于给定的一组记录，首先将每两个相邻的长度为1的子序列进行归并，得到 n/2（向上取整）个长度为2或1的有序子序列，再将其两两归并，反复执行此过程，直到得到一个有序序列。

package sorting;

/**
* 归并排序
* 平均O(nlogn),*好O(nlogn),*坏O(nlogn);空间复杂度O(n);稳定;较复杂
* @author zeng
*
*/
public class MergeSort {

public static void merge(int[] a, int start, int mid,
int end) {
int[] tmp = new int[a.length];
System.out.println(“merge ” + start + “~” + end);
int i = start, j = mid + 1, k = start;
while (i != mid + 1 && j != end + 1) {
if (a[i] < a[j])
tmp[k++] = a[i++];
else
tmp[k++] = a[j++];
}
while (i != mid + 1)
tmp[k++] = a[i++];
while (j != end + 1)
tmp[k++] = a[j++];
for (i = start; i <= end; i++)
a[i] = tmp[i];
for (int p : a)
System.out.print(p + ” “);
System.out.println();
}

static void mergeSort(int[] a, int start, int end) {
if (start < end) {
int mid = (start + end) / 2;
mergeSort(a, start, mid);// 左边有序
mergeSort(a, mid + 1, end);// 右边有序
merge(a, start, mid, end);
}
}

public static void main(String[] args) {
int[] b = { 49, 38, 65, 97, 76, 13, 27, 50 };
mergeSort(b, 0, b.length – 1);
}
}
希尔排序

算法描述：先将待排序序列的数组元素分成多个子序列，使得每个子序列的元素个数相对较少，然后对各个子序列分别进行直接插入排序，待整个待排序序列“基本有序”后，再对所有元素进行一次直接插入排序。

package sorting;

/**
* 希尔排序
* 平均O(nlogn),*坏O(nlogn);空间复杂度O(1);不稳定;较复杂
* @author zeng
*
*/
public class ShellSort {

public static void shellSort(int[] a) {
int n = a.length;
int d = n / 2;
while (d > 0) {
for (int i = d; i < n; i++) {
int j = i – d;
while (j >= 0 && a[j] > a[j + d]) {
int tmp = a[j];
a[j] = a[j + d];
a[j + d] = tmp;
j = j – d;
}
}
d = d / 2;
}
}

public static void main(String[] args) {
int[] b = { 49, 38, 65, 97, 76, 13, 27, 50 };
shellSort(b);
for (int i : b)
System.out.print(i + ” “);
}
}
基数排序

算法思想：依次按个位、十位…来排序，每一个pos都有分配过程和收集过程，array[i][0]记录第i行数据的个数。

package sorting;

/**
* 基数排序
* 平均O(d(n+r)),*好O(d(n+r)),*坏O(d(n+r));空间复杂度O(n+r);稳定;较复杂
* d为位数,r为分配后链表的个数
* @author zeng
*
*/
public class RadixSort {

//pos=1表示个位，pos=2表示十位
public static int getNumInPos(int num, int pos) {
int tmp = 1;
for (int i = 0; i < pos – 1; i++) {
tmp *= 10;
}
return (num / tmp) % 10;
}

//求得*大位数d
public static int getMaxWeishu(int[] a) {
int max = a[0];
for (int i = 0; i < a.length; i++) {
if (a[i] > max)
max = a[i];
}
int tmp = 1, d = 1;
while (true) {
tmp *= 10;
if (max / tmp != 0) {
d++;
} else
break;
}
return d;
}

public static void radixSort(int[] a, int d) {

int[][] array = new int[10][a.length + 1];
for (int i = 0; i < 10; i++) {
array[i][0] = 0;// array[i][0]记录第i行数据的个数
}
for (int pos = 1; pos <= d; pos++) {
for (int i = 0; i < a.length; i++) {// 分配过程
int row = getNumInPos(a[i], pos);
int col = ++array[row][0];
array[row][col] = a[i];
}
for (int row = 0, i = 0; row < 10; row++) {// 收集过程
for (int col = 1; col <= array[row][0]; col++) {
a[i++] = array[row][col];
}
array[row][0] = 0;// 复位，下一个pos时还需使用
}
}
}

public static void main(String[] args) {
int[] a = { 49, 38, 65, 197, 76, 213, 27, 50 };
radixSort(a, getMaxWeishu(a));
for (int i : a)
System.out.print(i + ” “);
}
}

堆排序

算法描述：对于给定的n个记录，初始时把这些记录看作一棵顺序存储的二叉树，然后将其调整为一个大顶堆，然后将堆的*后一个元素与堆顶元素进行交换后，堆的*后一个元素即为*大记录；接着将前（n-1）个元素重新调整为一个大顶堆，再将堆顶元素与当前堆的*后一个元素进行交换后得到次大的记录，重复该过程直到调整的堆中只剩下一个元素时为止。

package sorting;

/**
* 堆排序
* 平均O(nlogn),*好O(nlogn),*坏O(nlogn);空间复杂度O(1);不稳定;较复杂
* @author zeng
*
*/
public class HeapSort {

public static void heapSort(int[] a) {
int i;
int len = a.length;
// 构建堆
for (i = len / 2 – 1; i >= 0; i–)
heapAdjust(a, i, len – 1);
//交换堆顶元素与*后一个元素的位置
for (i = len – 1; i > 0; i–) {
int tmp = a[0];
a[0] = a[i];
a[i] = tmp;
heapAdjust(a, 0, i – 1);
}
}

public static void heapAdjust(int[] a, int pos, int len) {
int child = 2 * pos + 1;
int tmp = a[pos];
while (child <= len) {
if (child < len && a[child] < a[child + 1])
child++;
if (a[child] > tmp) {
a[pos] = a[child];
pos = child;
child = 2 * pos + 1;
} else
break;
}
a[pos] = tmp;
}

public static void main(String[] args) {
int[] a = { 49, 38, 65, 97, 76, 13, 27, 50 };
heapSort(a);
for (int i : a)
System.out.print(i + ” “);
}
}

 

本文完~

Android面试题View篇，由本人整理汇总，后续将推出系列篇，如果喜欢请持续关注和推荐。

Activity生命周期？

onCreate() -> onStart() -> onResume() -> onPause() -> onStop() -> onDetroy()

Activity的启动过程（不要回答生命周期）

app启动的过程有两种情况，*种是从桌面launcher上点击相应的应用图标，第二种是在activity中通过调用startActivity来启动一个新的activity。 我们创建一个新的项目，默认的根activity都是MainActivity，而所有的activity都是保存在堆栈中的，我们启动一个新的activity就会放在上一个activity上面，而我们从桌面点击应用图标的时候，由于launcher本身也是一个应用，当我们点击图标的时候，系统就会调用startActivitySately(),一般情况下，我们所启动的activity的相关信息都会保存在intent中，比如action，category等等。我们在安装这个应用的时候，系统也会启动一个PackaManagerService的管理服务，这个管理服务会对AndroidManifest.xml文件进行解析，从而得到应用程序中的相关信息，比如service，activity，Broadcast等等，然后获得相关组件的信息。当我们点击应用图标的时候，就会调用startActivitySately()方法，而这个方法内部则是调用startActivty(),而startActivity()方法*终还是会调用startActivityForResult()这个方法。而在startActivityForResult()这个方法。因为startActivityForResult()方法是有返回结果的，所以系统就直接给一个-1，就表示不需要结果返回了。而startActivityForResult()这个方法实际是通过Instrumentation类中的execStartActivity()方法来启动activity，Instrumentation这个类主要作用就是监控程序和系统之间的交互。而在这个execStartActivity()方法中会获取ActivityManagerService的代理对象，通过这个代理对象进行启动activity。启动会就会调用一个checkStartActivityResult()方法，如果说没有在配置清单中配置有这个组件，就会在这个方法中抛出异常了。当然*后是调用的是Application.scheduleLaunchActivity()进行启动activity，而这个方法中通过获取得到一个ActivityClientRecord对象，而这个ActivityClientRecord通过handler来进行消息的发送，系统内部会将每一个activity组件使用ActivityClientRecord对象来进行描述，而ActivityClientRecord对象中保存有一个LoaderApk对象，通过这个对象调用handleLaunchActivity来启动activity组件，而页面的生命周期方法也就是在这个方法中进行调用。

Activity的启动模式

standard:默认标准模式，每启动一个都会创建一个实例，

singleTop：栈顶复用，如果在栈顶就调用onNewIntent复用，从onResume()开始

singleTask：栈内复用，本栈内只要用该类型Activity就会将其顶部的activity出栈

singleInstance：单例模式，除了3中特性，系统会单独给该Activity创建一个栈，

Activity缓存方法

1.配置改变导致Activity被杀死，横屏变竖屏：在onStop之前会调用onSaveInstanceState()保存数据在重建Activity之后，会在onStart()之后调用onRestoreInstanceState(),并把保存下来的Bundle传给onCreate()和它会默认重建Activity当前的视图，我们可以在onCreate()中，回复自己的数据。

2.内存不足杀掉Activity，优先级分别是：前台可见，可见非前台，后台。

Service的生命周期，两种启动方法，有什么区别

context.startService() ->onCreate()- >onStart()->Service running–>(如果调用context.stopService() )->onDestroy() ->Service shut down

1.如果Service还没有运行，则调用onCreate()然后调用onStart()；

2.如果Service已经运行，则只调用onStart()，所以一个Service的onStart方法可能会重复调用多次。

3.调用stopService的时候直接onDestroy，

4.如果是调用者自己直接退出而没有调用stopService的话，Service会一直在后台运行。该Service的调用者再启动起来后可以通过stopService关闭Service。

context.bindService()->onCreate()->onBind()->Service running–>onUnbind() -> onDestroy() ->Service stop

1.onBind将返回给客户端一个IBind接口实例，IBind允许客户端回调服务的方法，比如得到Service运行的状态或其他操作。

2.这个时候会把调用者和Service绑定在一起，Context退出了,Service就会调用onUnbind->onDestroy相应退出。

3.所以调用bindService的生命周期为：onCreate –> onBind(只一次，不可多次绑定) –> onUnbind –> onDestory。

静态的Broadcast 和动态的有什么区别

1.动态的比静态的安全

2.静态在app启动的时候就初始化了 动态使用代码初始化

3.静态需要配置 动态不需要

4.生存期，静态广播的生存期可以比动态广播的长很多

5.优先级动态广播的优先级比静态广播高

6.静态不受页面生命周期的影响，即使退出了页面，也可以收到广播这种广播一般用于想开机自启动啊等等，由于这种注册的方式的广播是常驻型广播，所以会占用CPU的资源。

7.动态叫非常驻型广播，收到生命周期的影响，退出页面后，就不会收到广播，我们通常运用在更新UI方面。这种注册方式优先级较高。*后需要解绑，否会会内存泄露。

8.广播是分为有序广播和无序广播。

Android的布局方式有哪些？

LinearLayout，RelativeLayout，TableLayout，FrameLayout，AbsoluteLayout，GridLayout

在创建fragment时如何传递初始化参数？

Fragment初始化一定要提供默认构造函数。不能用构造函数传递参数！不要写带参数的构造函数。在Fragment里添加获取Fragment的newInstance函数，以后获取Fragment就使用这个函数，不要使用构造函数新建Fragment！使用setArgument和getArgument传递参数

设备横竖屏切换的时候，接下来会发生什么？

1、不设置Activity的android:configChanges时，切屏会重新调用各个生命周期，切横屏时会执行一次，切竖屏时会执行两次

2、设置Activity的android:configChanges=”orientation”时，切屏还是会重新调用各个生命周期，切横、竖屏时只会执行一次

3、设置Activity的android:configChanges=”orientation|keyboardHidden”时，切屏不会重新调用各个生命周期，只会执行onConfigurationChanged方法

Android启动Service的两种方式是什么? 它们的适用情况是什么?

如果后台服务开始后基本可以独立运行的话，可以用startService。音乐播放器就可以这样用。它们会一直运行直到你调用 stopSelf或者stopService。你可以通过发送Intent或者接收Intent来与正在运行的后台服务通信，但大部分时间，你只是启动服务并让它独立运行。如果你需要与后台服务通过一个持续的连接来比较频繁地通信，建议使用bind()。比如你需要定位服务不停地把更新后的地理位置传给UI。Binder比Intent开发起来复杂一些，但如果真的需要，你也只能使用它。

startService：生命周期与调用者不同。启动后若调用者未调用stopService而直接退出，Service仍会运行

bindService：生命周期与调用者绑定，调用者一旦退出，Service就会调用unBind->onDestroy

谈谈你对Android中Context的理解?

Context是一个抽象基类。在翻译为上下文，也可以理解为环境，是提供一些程序的运行环境基础信息。Context下有两个子类，ContextWrapper是上下文功能的封装类，而ContextImpl则是上下文功能的实现类。而ContextWrapper又有三个直接的子类， ContextThemeWrapper、Service和Application。其中，ContextThemeWrapper是一个带主题的封装类，而它有一个直接子类就是Activity，所以Activity和Service以及Application的Context是不一样的，只有Activity需要主题，Service不需要主题。Context一共有三种类型，分别是Application、Activity和Service。这三个类虽然分别各种承担着不同的作用，但它们都属于Context的一种，而它们具体Context的功能则是由ContextImpl类去实现的，因此在*大多数场景下，Activity、Service和Application这三种类型的Context都是可以通用的。不过有几种场景比较特殊，比如启动Activity，还有弹出Dialog。出于安全原因的考虑，Android是不允许Activity或Dialog凭空出现的，一个Activity的启动必须要建立在另一个Activity的基础之上，也就是以此形成的返回栈。而Dialog则必须在一个Activity上面弹出（除非是System Alert类型的Dialog），因此在这种场景下，我们只能使用Activity类型的Context，否则将会出错。

getApplicationContext()和getApplication()方法得到的对象都是同一个application对象，只是对象的类型不一样。 Context数量 = Activity数量 + Service数量 + 1 （1为Application）

理解Activity，View，Window三者关系

这个问题真的很不好回答。所以这里先来个算是比较恰当的比喻来形容下它们的关系吧。Activity像一个工匠（控制单元），Window像窗户（承载模型），View像窗花（显示视图）LayoutInflater像剪刀，Xml配置像窗花图纸。 1：Activity构造的时候会初始化一个Window，准确的说是PhoneWindow。 2：这个PhoneWindow有一个“ViewRoot”，这个“ViewRoot”是一个View或者说ViewGroup，是*初始的根视图。 3：“ViewRoot”通过addView方法来一个个的添加View。比如TextView，Button等 4：这些View的事件监听，是由WindowManagerService来接受消息，并且回调Activity函数。比如onClickListener，onKeyDown等。

Service的onCreate回调在UI线程中吗？

Service生命周期的各个回调和其他的应用组件一样，是跑在主线程中，会影响到你的UI操作或者阻塞主线程中的其他事情。

View的绘制流程

自定义控件： 1、组合控件。这种自定义控件不需要我们自己绘制，而是使用原生控件组合成的新控件。如标题栏。 2、继承原有的控件。这种自定义控件在原生控件提供的方法外，可以自己添加一些方法。如制作圆角，圆形图片。 3、完全自定义控件：这个View上所展现的内容全部都是我们自己绘制出来的。比如说制作水波纹进度条。

View的绘制流程：OnMeasure()——>OnLayout()——>OnDraw()

*步：OnMeasure()：测量视图大小。从顶层父View到子View递归调用measure方法，measure方法又回调OnMeasure。

第二步：OnLayout()：确定View位置，进行页面布局。从顶层父View向子View的递归调用view.layout方法的过程，即父View根据上一步measure子View所得到的布局大小和布局参数，将子View放在合适的位置上。

第三步：OnDraw()：绘制视图。ViewRoot创建一个Canvas对象，然后调用OnDraw()。六个步骤：①、绘制视图的背景；②、保存画布的图层（Layer）；③、绘制View的内容；④、绘制View子视图，如果没有就不用； ⑤、还原图层（Layer）；⑥、绘制滚动条。

View，ViewGroup事件分发

Touch事件分发中只有两个主角:ViewGroup和View。ViewGroup包含onInterceptTouchEvent、dispatchTouchEvent、onTouchEvent三个相关事件。View包含dispatchTouchEvent、onTouchEvent两个相关事件。其中ViewGroup又继承于View。

ViewGroup和View组成了一个树状结构，根节点为Activity内部包含的一个ViwGroup。

触摸事件由Action_Down、Action_Move、Aciton_UP组成，其中一次完整的触摸事件中，Down和Up都只有一个，Move有若干个，可以为0个。

当Acitivty接收到Touch事件时，将遍历子View进行Down事件的分发。ViewGroup的遍历可以看成是递归的。分发的目的是为了找到真正要处理本次完整触摸事件的View，这个View会在onTouchuEvent结果返回true。

当某个子View返回true时，会中止Down事件的分发，同时在ViewGroup中记录该子View。接下去的Move和Up事件将由该子View直接进行处理。由于子View是保存在ViewGroup中的，多层ViewGroup的节点结构时，上级ViewGroup保存的会是真实处理事件的View所在的ViewGroup对象:如ViewGroup0-ViewGroup1-TextView的结构中，TextView返回了true，它将被保存在ViewGroup1中，而ViewGroup1也会返回true，被保存在ViewGroup0中。当Move和UP事件来时，会先从ViewGroup0传递至ViewGroup1，再由ViewGroup1传递至TextView。

当ViewGroup中所有子View都不捕获Down事件时，将触发ViewGroup自身的onTouch事件。触发的方式是调用super.dispatchTouchEvent函数，即父类View的dispatchTouchEvent方法。在所有子View都不处理的情况下，触发Acitivity的onTouchEvent方法。

onInterceptTouchEvent有两个作用：1.拦截Down事件的分发。2.中止Up和Move事件向目标View传递，使得目标View所在的ViewGroup捕获Up和Move事件。

Android中touch事件的传递机制是怎样的?

1.Touch事件传递的相关API有dispatchTouchEvent、onTouchEvent、onInterceptTouchEvent

2.Touch事件相关的类有View、ViewGroup、Activity

3.Touch事件会被封装成MotionEvent对象，该对象封装了手势按下、移动、松开等动作

4.Touch事件通常从Activity#dispatchTouchEvent发出，只要没有被消费，会一直往下传递，到*底层的View

5.如果Touch事件传递到的每个View都不消费事件，那么Touch事件会反向向上传递,*终交由Activity#onTouchEvent处理

6.onInterceptTouchEvent为ViewGroup特有，可以拦截事件

7.Down事件到来时，如果一个View没有消费该事件，那么后续的MOVE/UP事件都不会再给它

Fragment与Fragment、Activity通信的方式

直接在一个Fragment中调用另外一个Fragment中的方法

使用接口回调

使用广播

Fragment直接调用Activity中的public方法

在创建fragment时如何传递初始化参数？

Fragment初始化一定要提供默认构造函数。不能用构造函数传递参数！不要写带参数的构造函数。在Fragment里添加获取Fragment的newInstance函数，以后获取Fragment就使用这个函数，不要使用构造函数新建Fragment！使用setArgument和getArgument传递参数

如何规避oom?

使用更加轻量的数据结构

避免在Android里面使用Enum

减小Bitmap对象的内存占用

使用更小的图片

复用系统自带的资源

注意在ListView/GridView等出现大量重复子组件的图里面对ConvertView的复用

Bitmap对象的复用

避免在onDraw方法里面执行对象的创建

避免对象的内存泄露(重点)

考虑使用Application Context而不是Activity Context

注意WebView的泄漏(重点)

资源文件需要选择合适的文件夹进行存放

谨慎使用static对象(重点)

特别留意单例对象中不合理的持有

珍惜Services资源

谨慎使用“抽象”编程

谨慎使用依赖注入框架

.谨慎使用多进程

Handler的使用（重点）

强软弱虚引用的应用（重点）

主线程操作UI，子线程操作数据（必填）

Android 中如何捕获未捕获的异常

自 定 义 一 个 Application ， 比 如 叫 MyApplication 继 承 Application 实 现 UncaughtExceptionHandler。 覆写 UncaughtExceptionHandler 的 onCreate 和 uncaughtException 方法。

保存Activity状态

onSaveInstanceState(Bundle)会在activity转入后台状态之前被调用，也就是onStop()方法之前，onPause方法之后被调用；

数据存储有哪些方式？

1.sharedpreferences 2.file 3.Sqlite 4.ContentProvide 5.网络存储

如何将一个Activity设置成窗口的样式？

*种方法，在styles.xml文件中，可以新建如下的类似Dialog的style。

<style name=”Theme.FloatActivity” parent=”android:style/Theme.Dialog”> </style>。
第二种方法，在AndroidManifest.xml中在需要显示为窗口的Activity中添加如下属性: android:theme=“@style/Theme.FloatActivity”。 也可以直接添加对应需要展示为Dialog style的Activity的android:theme属性为android:theme=“@android:style/Theme.Dialog”。

ScrollView是否可以和ListView混合使用？如何可以，说明混合使用的方式，如果不行，说明原因。

可以，计算整个ListView的高度，填充数据后重新设置ListView高度，重写onMeasure和onInterceptTouchEvent方法

解决ScrollView嵌套ListView和GridView冲突的方法

重写ListView的onMeasure方法，来自定义高度： 解决ScrollView嵌套ListView和GridView冲突的方法 重写ListView的onMeasure方法，来自定义高度：

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int expandSpec = MeasureSpec.makeMeasureSpec(Integer.MAX_VALUE >> 2, MeasureSpec.AT_MOST);
super.onMeasure(widthMeasureSpec, expandSpec);
}
通过Intent传递一些二进制数据的方法有哪些? 使用Serializable接口实现序列化，这是Java常用的方法。 实现Parcelable接口，这里Android的部分类比如Bitmap类就已经实现了，同时Parcelable在Android AIDL中交换数据也很常见的。

Serializable 和 Parcelable 的区别

在使用内存的时候，Parcelable 类比 Serializable 性能高，所以推荐使用 Parcelable 类。

Serializable 在序列化的时候会产生大量的临时变量，从而引起频繁的 GC。

Parcelable 不能使用在要将数据存储在磁盘上的情况。尽管 Serializable 效率低点，但在这 种情况下，还是建议你用 Serializable 。

Bitmap的处理

1.当使用ImageView的时候，可能图片的像素大于ImageView，此时就可以通过BitmapFactory.Option来对图片进行压缩，inSampleSize表示缩小2^(inSampleSize-1)倍。

2.BitMap的缓存：

1.同步加载只创建一个线程然后按照顺序进行图片加载

2.异步加载使用线程池，让存在的加载任务都处于不同线程

3.为了不开启过多的异步任务，只在列表静止的时候开启图片加载

1.使用LruCache进行内存缓存。

2.使用DiskLruCache进行硬盘缓存。

3.实现一个ImageLoader的流程：同步异步加载、图片压缩、内存硬盘缓存、网络拉取

过度绘制、卡顿优化:

1.过度绘制：

1.移除Window默认的Background：getWidow.setBackgroundDrawable(null);

2.移除XML布局文件中非必需的Background

3.减少布局嵌套(扁平化的一个体现，减少View数的深度，也就减少了View树的遍历时间，渲染的时候，前后期的工作，总是按View树结点来)

4.在引入布局文件里面，*外层可以用merge替代LinearLayout,RelativeLayout，这样把子UI元素直接衔接在include位置

5.工具：HierarchyViewer 查看视图层级

2.卡顿优化：16ms数据更新

view绘制机制和加载过程，请详细说整个流程

1.ViewRootImpl会调用performTraversals(),其内部会调用performMeasure()、performLayout、performDraw()。

2.performMeasure()会调用*外层的ViewGroup的measure()–>onMeasure(),ViewGroup的onMeasure()是抽象方法，但其提供了measureChildren()，这之中会遍历子View然后循环调用measureChild()这之中会用getChildMeasureSpec()+父View的MeasureSpec+子View的LayoutParam一起获取本View的MeasureSpec，然后调用子View的measure()到View的onMeasure()–>setMeasureDimension(getDefaultSize(),getDefaultSize()),getDefaultSize()默认返回measureSpec的测量数值，所以继承View进行自定义的wrap_content需要重写。

3.performLayout()会调用*外层的ViewGroup的layout(l,t,r,b),本View在其中使用setFrame()设置本View的四个顶点位置。在onLayout(抽象方法)中确定子View的位置，如LinearLayout会遍历子View，循环调用setChildFrame()–>子View.layout()。

4.performDraw()会调用*外层ViewGroup的draw():其中会先后调用background.draw()(绘制背景)、onDraw()(绘制自己)、dispatchDraw()(绘制子View)、onDrawScrollBars()(绘制装饰)。

5.MeasureSpec由2位SpecMode(UNSPECIFIED、EXACTLY(对应精确值和match_parent)、AT_MOST(对应warp_content))和30位SpecSize组成一个int,DecorView的MeasureSpec由窗口大小和其LayoutParams决定，其他View由父View的MeasureSpec和本View的LayoutParams决定。ViewGroup中有getChildMeasureSpec()来获取子View的MeasureSpec。

6.三种方式获取measure()后的宽高：

1.Activity#onWindowFocusChange()中调用获取

2.view.post(Runnable)将获取的代码投递到消息队列的尾部。

3.ViewTreeObservable.

Bitmap图像模式有哪几种，给出一张1080 * 1920的，ARGB 8888格式的占用内存是多大

Bitmap.Config ARGB_4444：每个像素占四位，即A=4，R=4，G=4，B=4，那么一个像素点占4+4+4+4=16位

Bitmap.Config ARGB_8888：每个像素占四位，即A=8，R=8，G=8，B=8，那么一个像素点占8+8+8+8=32位

Bitmap.Config RGB_565：每个像素占四位，即R=5，G=6，B=5，没有透明度，那么一个像素点占5+6+5=16位

Bitmap.Config ALPHA_8：每个像素占四位，只有透明度，没有颜色。

ARGB:指的是一种色彩模式，里面A代表Alpha，R表示red，G表示green，B表示blue。 ARGB 8888一个像素占用4个字节，一个字节8位，1080 * 1920 * 4 * 8

图片优化

对图片本身进行操作。尽量不要使用setImageBitmap、setImageResource、BitmapFactory.decodeResource来设置一张大图，因为这些方法在完成decode后， *终都是通过java层的createBitmap来完成的，需要消耗更多内存.

图片进行缩放的比例，SDK中建议其值是2的指数值,值越大会导致图片不清晰。

不用的图片记得调用图片的recycle()方法

Android UI适配

字体使用sp,使用dp，多使用match_parent，wrap_content，weight 图片资源，不同图片的的分辨率，放在相应的文件夹下可使用百分比代替。

Android中的几种动画

帧动画：Drawable Animation，指通过指定每一帧的图片和播放时间，有序的进行播放而形成动画效果，比如想听的律动条。

补间动画：View Animation（Tween Animation），指通过指定View的初始状态、变化时间、方式，通过一系列的算法去进行图形变换，从而形成动画效果，主要有Alpha、Scale、Translate、Rotate四种效果。注意：只是在视图层实现了动画效果，并没有真正改变View的属性，比如滑动列表，改变标题栏的透明度。

属性动画：Property Animation，在Android3.0的时候才支持，通过不断的改变View的属性，不断的重绘而形成动画效果。相比于视图动画，View的属性是真正改变了。比如view的旋转，放大，缩小。

HybridApp WebView和JS交互

Android与JS通过WebView互相调用方法，实际上是： Android去调用JS的代码

通过WebView的loadUrl(),使用该方法比较简洁，方便。但是效率比较低，获取返回值比较困难。

通过WebView的evaluateJavascript(),该方法效率高，但是4.4以上的版本才支持，4.4以下版本不支持。所以建议两者混合使用。 JS去调用Android的代码

通过WebView的addJavascriptInterface（）进行对象映射 ，该方法使用简单，仅将Android对象和JS对象映射即可，但是存在比较大的漏洞。

漏洞产生原因是：当JS拿到Android这个对象后，就可以调用这个Android对象中所有的方法，包括系统类（java.lang.Runtime 类），从而进行任意代码执行。 解决方式： (1)Google 在Android 4.2 版本中规定对被调用的函数以 @JavascriptInterface进行注解从而避免漏洞攻击。 (2)在Android 4.2版本之前采用拦截prompt（）进行漏洞修复。

本文完~