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 <index ;i++){
            value = s.charAt(i)-48;
            if(value<0 || value>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<Node> arr = new ArrayList<Node>();
        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;

    }

}

第一次加载StaticClassSingleton类时，并不会实例化instance，只有第一次调用getInstance方法时，Java虚拟机才会去加载SingletonHolder类，继而实例化instance，这样延时实例化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<endNum) {
                if (key==arr[middleNum]) {
                    return middleNum+1;
                } else if (key<arr[middleNum]) {
                    return getLocation(arr,key,startNum,middleNum);
                } else {
                    return getLocation(arr,key,middleNum,endNum);
                }
            } else if (startNum==endNum) {
                return startNum;
            } else {
                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,11,1,11);
            System.out.println(temp);
            
        }

    }

第二种实现方式为非递归实现，则利用循环

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 (key<arr[middleNum]) {
                    endNum=middleNum;
                } else if (key>arr[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<Integer>();

            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<String,Bitmap>键值对的方式保存图片，key为地址，value为图片对象Bitmap

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