2018Android面试题和答案
l.String str = "3.14" 不用java API 转换成double 3.14
public class Test {
public static void main(String[] args){
String s = "3.14";
double result = 0;
int index = 0;
for(int i =0 ;i < s.length(); i++){
int value = s.charAt(i) - 46;
if(value == 0){
index = i;
}
}
int value;
for (int i =0 ;i 9) {
throw new NumberFormatException();
} else {
result = result * 10 + value;
}
}
double value2;
int m =0;
for (int i = index+1; i< s.length();i++){
value2 = s.charAt(i) - 48;
m++;
double hh = value2 / (Math.pow(10, m));
result = result+ hh;
}
System.out.println(result);
}
}
2.两线程交替打印1，2，1，2，1，2
public class Test {
private static Object lock = new Object();
private static boolean flag = true;
public static void main(String[] args) {
Thread threadOne = new Thread(){
public void run(){
while (true){
synchronized (lock){
System.out.println("Thread One : " + 1);
if(flag){
flag = false;
lock.notify();
try {
lock.wait();
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
}
};
Thread threadTwo = new Thread(){
public void run(){
while (true){
synchronized (lock){
System.out.println("Thread Two : " + 2);
if(!flag){
flag = true;
lock.notify();
try {
lock.wait();
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
}
};
threadOne.start();
threadTwo.start();
}
}
3两个无序链表，代码生成合并成一个有序链表
解题思路
两个无序链表先转换成两个有序单链表
两个有序单链表合并成一个有序单链表
import java.util.*;
//链表
class Node {
int val;
Node next;
public Node(int val) {
this.val = val;
}
}
//自定义比较器
class Comparators {
//单例模式(手动尴尬)
private static Comparator comparator = null;
public static Comparator getComparator() {
if(comparator == null) {
comparator = new Comparator() {
public int compare(Object ob1, Object ob2) {
if(ob1 instanceof Node) return compare((Node)ob1, (Node)ob2);
return 1;
}
//自定义链表排序规则
public int compare(Node n1, Node n2) {
return n1.val - n2.val;
}
};
}
return comparator;
}
}
public class Test {
//将无序单链表转化为有序单链表
public static Node sortOfList(Node p) {
//暂存链表结点
ArrayList arr = new ArrayList();
Node temp = p;
while(temp != null) {
arr.add(temp);
temp = temp.next;
}
Collections.sort(arr, Comparators.getComparator());
Node ans = arr.get(0);
Node temp2 = ans;
for(int i = 1; i < arr.size(); i++) {
temp2.next = arr.get(i);
temp2 = temp2.next;
}
temp2 = null;
return ans;
}
//两个无序单链表p1,p2合并成一个有序单链表
public static Node mergeList(Node p1, Node p2) {
//得到有序单链表
Node p11 = sortOfList(p1);
Node p22 = sortOfList(p2);
//合并单链表
Node ans;
Node temp1 = p11;
Node temp2 = p22;
if(temp1.val <= temp2.val) {
ans = temp1;
temp1 = temp1.next;
} else {
ans = temp2;
temp2 = temp2.next;
}
Node temp = ans;
while(temp1 != null && temp2 != null) {
if(temp1.val <= temp2.val) {
temp.next = temp1;
temp1 = temp1.next;
} else {
temp.next = temp2;
temp2 = temp2.next;
}
temp = temp.next;
}
while(temp1 != null) {
temp.next = temp1;
temp = temp.next;
temp1 = temp1.next;
}
while(temp2 != null) {
temp.next = temp2;
temp = temp.next;
temp2 = temp2.next;
}
temp = null;
return ans;
}
//测试
public static void main(String[] args) {
Node p1 = new Node(3);
p1.next = new Node(5);
p1.next.next = new Node(4);
p1.next.next.next = new Node(6);
p1.next.next.next.next = new Node(7);
Node p2 = new Node(8);
p2.next = new Node(9);
p2.next.next = new Node(10);
p2.next.next.next = new Node(2);
p2.next.next.next.next = new Node(1);
p2.next.next.next.next.next = new Node(11);
Node ans = mergeList(p1, p2);
Node temp = ans;
while(temp != null) {
System.out.print(temp.val+" ");
temp = temp.next;
}
System.out.println();
}
} 4写一个单例，并说明优缺点
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}5一个方法参数有int a, int b, 用代码方式实现返回值为a的b次方（不能用API）
递归方法
public class Test {
public long power(int a,int b) {
if (b == 1)
return a;
return a * power(a,b-1);
}
public static void main(String[] args){
System.out.print(new Test().power(2,3));
}
}6利用二分法查找一个数字在数组中的位置
1 递归方法
public class Test {
/**
*
* @param arr
* @param key
* @param startNum 数组位置号，为数组下标+1
* @param endNum 数组位置号，为数组下标+1
* @return
*/
public static int getLocation(int[] arr,int key,int startNum,int endNum) {
if (arr==null) return -1;
int middleNum=(startNum+endNum)/2;
System.out.println("中间值："+middleNum);
if (startNum第二种实现方式为非递归实现，则利用循环
public class Test {
public static int getLocation(int[] arr,int key) {
if (arr==null) return -1;
int middleNum=arr.length/2;
if (key==arr[middleNum]) {
return middleNum+1;
}
int startNum=0; //数组下标
int endNum=arr.length-1; //数组下标
while (startNum<=endNum) {
middleNum=(startNum+endNum)/2;
if (keyarr[middleNum]) {
startNum=middleNum;
} else {
return middleNum+1;
}
}
return -1;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr={1,3,4,5,6,7,11,46,255,743,888};
int temp=getLocation(arr,5);
System.out.println(temp);
}
}
7 两个数组合并成一个数组并去重
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class Test {
/**
* 两个数组合并，去掉重复的，然后再排序
*/
public static void main(String[] args) {
int[] arr2 = {3,2,3,1,5};
int[] arr1 = {3,4,5,6,7};
//Set是不允许重复的，所以将数组的值全部放在Set对象中
Set set = new HashSet();
for(int i = 0; i < arr1.length ; i++){
set.add(arr1[i]);
}
for(int i = 0; i < arr2.length ; i++){
set.add(arr2[i]);
}
//得到的是不重复的值，Set的长度
System.out.println(set.size());
Iterator i = set.iterator();
int[] arrays = new int[set.size()];
int num=0;
while(i.hasNext()){
int a = (Integer)i.next();
arrays[num] = a;
num = num + 1;
System.out.println(num);
}
for(int s = 0; s < arrays.length ; s++){
System.out.println(arrays[s]);
}
//对结果进行排序
Arrays.sort(arrays);
System.out.println(Arrays.toString(arrays));
}
} 问答题
1 Service中如何处理耗时操作
不可以直接处理耗时操作。
Service和Activity是运行在当前app所在的main thread（UI主线程）中的，而耗时操作（如：网络请求、拷贝数据、大文件）会阻塞主线程，给用户不好的体验。
如果需要在服务中进行耗时操作，可以选择IntentService， IntentService是Service的子类，用来处理异步请求。
IntentService在onCreate()方法中通过HandlerThread单独开启一个线程来处理Intent请求对象所对应的任务，这样可以避免事务处理阻塞主线程。
2ContentProvider create(),insert(),delete(),update()，是在UI线程吗
我们知道像Activity这样的组件，它的生命周期回调函数是在UI线程中运行的，ContentProvider的onCreate()也是在UI线程运行，回答这个面试题前，我们要搞清楚ContentProvider的query()，insert()，delete()，update()这几个方法是在UI线程中运行的吗？
如果是，那么就等于说在这里做长时间的操作的话，就会有ANR的问题。如果不是，那是在一个工作线程还是多个线程中呢，即ContentProvider是否支持并发操作？
ContentResolver与ContentProvider类隐藏了实现细节，但是ContentProvider所提供的query()，insert()，delete()，update()都是在ContentProvider进程的线程池中被调用执行的，而不是进程的主线程中。因为那些方法可能同时被多个线程所调用，所以他们都应该是线程安全的。
ContentProvider实现了进程间通信也是基于Binder机制的，所以会回到Binder的线程处理问题。并不是每个ContentProvider都会有一个线程池，而一个进程会共有一个线程池，其实就是Binder线程池。
3HashMap原理
HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。
数组：存储区间连续，占用内存严重，寻址容易，插入删除困难；
链表：存储区间离散，占用内存比较宽松，寻址困难，插入删除容易；
Hashmap综合应用了这两种数据结构，实现了寻址容易，插入删除也容易。
基本原理：先声明一个下标范围比较大的数组来存储元素。另外设计一个哈希函数（也叫做散列函数）来获得每一个元素的Key（关键字）的函数值（即数组下标，hash值）相对应，数组存储的元素是一个Entry类，这个类有三个数据域，key、value（键值对），next(指向下一个Entry)。
HashMap的工作原理 ：HashMap是基于散列法（又称哈希法hashing）的原理，使用put(key, value)存储对象到HashMap中，使用get(key)从HashMap中获取对象。当我们给put()方法传递键和值时，我们先对键调用hashCode()方法，返回的hashCode用于找到bucket（桶）位置来储存Entry对象。”HashMap是在bucket中储存键对象和值对象，作为Map.Entry。并不是仅仅只在bucket中存储值
4磁盘缓存和内存缓存先后顺序，图片缓存是根据什么来区分每一个图片的地址
缓存读取顺序是 内存–>磁盘–>网络
三级缓存原理
网络缓存, 不优先加载, 速度慢,浪费流量
本地缓存, 次优先加载, 速度快
内存缓存, 优先加载, 速度最快
首次加载 Android App 时，肯定要通过网络交互来获取图片，之后我们可以将图片保存至本地SD卡和内存中
之后运行 App 时，优先访问内存中的图片缓存，若内存中没有，则加载本地SD卡中的图片
总之，只在初次访问新内容时，才通过网络获取图片资源
可以使用MD5加密图片的Url，来作为图片的名称保存
通过 HashMap
5线程如何中断，wait(),nofity()原理
终止线程的三种方法：
1. 使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。 (volatile boolean exit = false)
2. 使用stop方法强行终止线程（这个方法不推荐使用，因为stop和suspend、resume一样，也可能发生不可预料的结果）。
3. 使用interrupt方法中断线程。
6Handler机制原理，Looper死循环为什么不会卡死
7给一张切图的单位是px,如何给不同屏幕适配，转换dp方式
8简述滑动窗口协议
9HashMap如何解决hash冲突的问题
10 Vector和CopyOnWriteArrayList的区别
11 java 8 lambda 表达式是否持有外部类的this引用
12简述Activity的启动模式和Task Affinity属性
13如何在Activity之间传递一个Bitmap
14如何判断一个应用在前台
15Application和Activity 的Context对象的区别
16RecyclerView LayoutManager 的作用是什么，如何自定义LayoutManager,写出思路
17 为什么在JNI调用 env->FindClass(className)在拼写正确的情况下会找不到类，说明原因以及可能发生错误的场景
18 ThreadLocal 原理
19什么是内存泄漏，并列出Android开发中的常见场景
20Rxjava中 map()和flatMap()区别
21Android事件分发机制
22SharedPreferences是进程安全的吗
23 volatile原理
24 两个Acitivy交提的生命周期，A启动B，B按返回键的生命周期，Activity和Frament绑定的生命周期
25