Android面试题总结

抽象类和接口的区别

进程和线程的区别

Activity的四种启动模式，四大组件

在 service 的生命周期方法 onstartConmand()可不可以执行网络操

作？如何在 service 中执行网络操作？

OOM内存溢出

事件分发

MVC和MVP的区别

设计模式六大原则

单一职责，开闭原则，里氏替换原则，依赖倒置原则，接口分离原则，最少知识原则

设计模式

单利设计模式

工厂设计模式

建造者设计模式 产品类，建造者类，抽象建造者类，导演类

适配器模式

装饰设计模式

观察者设计模式

模板模式

Activity堆栈 ActivityAffinal

Handler机制和异步任务的底层实现原理，异步任务在不同版本的api中有何区别

Android新特性在低版本

上传文件基本步骤

性能优化

数据库跨版本升级

属性动画的版本兼容性

布局优化

二分法查找

gradle脚本

hashmap，arraylist和linkdlist查找速度，HashMap底层实现原理

单利模式的线程安全问题

MVC和MVP

hashcode equals

如何定位ANR，卡顿监控

okhttp的好处

定位卡顿

翻转二叉树

内存管理机制

AIDL

线程池的种类

tcp和udp的区别和使用场景

Android View的绘制流程

Android热修复

Java内存模型

四种引用类型

强引用：即使是内存不足的情况下，GC也不会回收，只会报OOM异常

软引用：内存不足的情况下，可能会被GC回收，也可能不会回收，但是在内存充足的情况下，绝对不会回收。软引用多用来实现对内存敏感的高速缓存

弱引用：与软引用的区别在于，一旦垃圾回收期发现了弱引用对象，不管当前内存是否充足，都会回收此对象，不过垃圾回收线程优先级很低，不一定很快发现此对象，可能运行多次GC后才会被发现。

虚引用：跟没有引用一样，随时可以被回收。

从上面可以看出，不同的引用类型，在GC时的策略不同。

activity亲和度

算法题：

算法：1.求数组中第二大数
/**
*求一个数组中的第二大数
*
*@parama
*@return
*/
public intgetSecondMax(inta[])
{
intmaxN
= a[0];
intsencodeMaxN =0;
for(inti
=0;i < a.length;i++)
{
if(a[i]
> maxN) {
sencodeMaxN = maxN;
maxN = a[i];
}else{
sencodeMaxN = a[i];
}
}
returnsencodeMaxN;
}
2.倒序输出一个字符串
public staticStringfunc(String
s){
System.out.println("s:"+
s);
returns.length() >0?func(s.substring(1))+
s.charAt(0):"";
}
3.冒泡排序

//冒泡排序时间复杂度O(n2)
public voidmaopaoSort(inta[]){

intsize
= a.length;

for(inti
=0;i<size-1;i++){
for(intj
=0;j<size-1-i;j++){
if(a[j]>a[j+1]){
swap(a[j],a[j+1]);
}
}
}
}

4.用一个循环一个变量打印9*9乘法表

public voidprintlnXForm()
{
for(inti
=1;i <=81;i++)
{
if(i
/9>= i %9)
{
System.out.print(i
/ 9+"x"+
i %9+"="+
(i /9) * (i %9));
}
if(i
%9==9)
{
System.out.println();
return;
}
}
}

5.二分查找法
int[]
a = {1,2,3,4,5,6,7,8};
System.out.print(search(a,9));
}

public static intsearch(int[]
a, intkey) {
intlow
=0;
inthigh = a.length-1;

while(low < high) {
intmid
= (low + high) /2;
if(key > a[mid])
low = mid +1;
else if(key < a[mid])
high = mid -1;
else
returnmid;
}
return-1;
}

单利模式的线程安全高效率的写法，

public classMySingleTon {
volatile private staticMySingleTonmySingleTon=null;//volatile声明多线程可访问
privateMySingleTon() {
}
public staticMySingleTongetInstance()
{
try{
if(mySingleTon==null)
{

synchronized(MySingleTon.class)
{
if(mySingleTon==null)
{
mySingleTon=newMySingleTon();
}
}

}
}catch(Exception
e) {
e.printStackTrace();
}
returnmySingleTon;
}
}

快速排序 时间复杂度O(nlog2n)

public void quickSort(int[] data, int start, int end) {
if (start > end) {
return;
}

//以起始索引为分界点
int pivot = data[start];
int i = start + 1;
int j = end;
while (true) {
while (i < end && data[i] < pivot)
i++;
while (j > start && data[j] > pivot)
j++;

if (i < j) {
swap(data, i, j);
} else {
break;
}
}
//交换j和分界点的值
swap(data, start, j);
//递归左子序列
quickSort(data, start, j - 1);
//递归右子序列
quickSort(data, j + 1, end);
}

直接插入排序 时间复杂度O(n2)

public static void insertSort(int [] data){
for (int i = 1;i<data.length;i++){
//缓存i处的元素值
int temp = data[i];
if (data[i]<data[i-1]){
int j = i-1;
//整体后移一格
while(j>=0 && data[j] >temp){
data[j+1] = data[j];
j--;
}
//最后将tmep的值插入合适的位置
data[j+1] = temp;
}
}
}

rtmp和rtsp的区别