Android客户端面试题集锦

声明：本文问题来自但不限于Xoper.ducky大牛的面试总结，网址：http://www.nowcoder.com/discuss/3043，欢迎各位进行补充

JAVA SE

1. 九种基本数据类型的大小，以及他们的封装类。

int                  Integer

short              Short

long                Long

byte                Byte

float               Float

double           Double

char              Char

boolean        Boolean

String（不算基本数据类型） Stringbuffer、Stringbuilder（非线程安全）

2. Switch能否用string做参数？

Java 1.7之前只能支持byte、short、int、char或其封装类及enum类型，1.7及以上才支持string，boolean类型也是不支持的，会报以下错误：Cannot switch on a value of type boolean. Only convertible int values or enum constants are permitted

3. equals与==的区别。

（1） 对字符串变量来说：==比较两个对象的地址是否一致，equals比较两个对象的值.

String s3 = “abc”, s4 = “abc”

String s1 = new String(“abc”);

String s2 = new String(“abc”);

s1 == s2 //false 因为两个对象存放的地址不一致

s1.equals(s2) // true 因为两个对象的值都是”abc”

（2） 对于基本数据类型，只能用==判断，不能用equals()，而对于基本数据类型的封装类或者其他自定义类（没有重写equals方法）来说，==比较的是地址，equals()比较的是内容

（3） s3 == s4 // true，因为s3和s4指向的都是同一块内存地址

（4） StringBuffer s5 = new StringBuffer(“a”) ;

StringBuffer s6 = new StringBuffer(“a”) ;

s5.equals(s6) // false ，因为StringBuffer没有重写equals()方法，比较的还是内存地址，显然两个对象内存地址是不一样的。

4. Object有哪些公用方法？

wait()、notify()、notifyAll()、equals()---用来比较两个对象地址是否一致

hashCode() – 标志对象的唯一值

toString() – 对象的字符串表达形式

5. Java的四种引用，强弱软虚，用到的场景。

强引用（StrongReference）--- 强引用是使用最普遍的引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。

软引用（SoftReference）---如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。

软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。SoftReference是强引用，它保存的对象实例，除非JVM即将OutOfMemory，否则不会被GC回收。这个特性使得它特别适合设计对象Cache。对于Cache，我们希望被缓存的对象最好始终常驻内存，但是如果JVM内存吃紧，为了不发生OutOfMemoryError导致系统崩溃，必要的时候也允许JVM回收Cache的内存，待后续合适的时机再把数据重新Load到Cache中

弱引用（WeakReference）---WeakReference是弱引用，其中保存的对象实例可以被GC回收掉。这个类通常用于在某处保存对象引用，而又不干扰该对象被GC回收，通常用于Debug、内存监视工具等程序中。因为这类程序一般要求即要观察到对象，又不能影响该对象正常的GC过程。

虚引用（PhantomReference）---就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。

虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列 （ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之 关联的引用队列中。

6. HashCode的作用

对象区别于其他对象的标识

7. ArrayList、LinkedList、Vector的区别

ArrayList类似于C中的数组，查找方便，插入复杂，LinedList类似于C中的链表，插入简单，查找复杂度较高。而Vector类似于ArrayList，但是在Java 1.5以后就不推荐使用了。

8. String、StringBuffer与StringBuilder的区别。

StringBuffer是String的封装类，都是线程安全的，如果字符串的内容经常改变，则最好用，StringBuffer，而StringBuilder也是可变字符串，但是非线程安全，因此正常情况下会比StringBuffer快。

9. Map、Set、List、Queue、Stack的特点与用法。

map 根据key 找value

set 元素不能重复

list 类似数组

Queue 队列，先进先出

Stack 栈，后进先出

10. HashMap和HashTable的区别。

1. 当需要同步时，用Hashtable，反之用HashMap。但是，因为在需要时，HashMap可以被同步，HashMap的功能比Hashtable的功能更多，而且它不是基于一个陈旧的类的，所以有人认为，在各种情况下，HashMap都优先于Hashtable。

2. 只有HashMap可以让你将空值作为一个表的条目的key或value。HashMap中只有一条记录可以是一个空的key，但任意数量的条目可以是空的value

11. HashMap和ConcurrentHashMap的区别，HashMap的底层源码。

有并发访问的时候用ConcurrentHashMap，效率比用锁的HashMap好。

HashMap底层源码用(Entry)数组+链表的形式实现，详情请看这里：

http://liaokang-java.iteye.com/blog/1098404

12. TreeMap、HashMap、LindedHashMap的区别。

LinkedHashMap也是一个HashMap,但是内部维持了一个双向链表,可以保持顺序

TreeMap 可以用于排序（根据键排序，默认是升序），HashSet是通过HashMap实现的,TreeSet是通过TreeMap实现的,只不过Set用的只是Map的key，Map的key和Set都有一个共同的特性就是集合的唯一性.TreeMap更是多了一个排序的功能.

13. Collection包结构，与Collections的区别。

Collection ---List ---ArrayList, LinkedList, Vector

Set ---HashSet, TreeSet

Map—HashMap,TreeMap,HashTable

Collection是集合类的上级接口，子接口主要有Set 和List、Map。

Collections是针对集合类的一个帮助类，提供了操作集合的工具方法：一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

14. try catch finally，try里有return，finally还执行么？

必须执行.如果try里有return，finally也有return，会执行finally中的return.

15. Excption与Error包结构。OOM你遇到过哪些情况，SOF你遇到过哪些情况。

16. Java面向对象的三个特征与含义。

继承

封装

多态.

17. Override和Overload的含义去区别。

override --- 重写父类的函数

overload – 是函数重载，根据传入的参数（个数、类型）不同来区别

18. Interface与abstract类的区别。

interface 是接口，可以有常量，所有方法都默认是public，而且不能实现

abstract类 比其他普通类多了个抽象方法，而且是必须有抽象方法

19. Static class 与non static class的区别。

内部静态类不需要有指向外部类的引用。但非静态内部类需要持有对外部类的引用。非静态内部类能够访问外部类的静态和非静态成员。静态类不能访问外部类的非静态成员。他只能访问外部类的静态成员

20. java多态的实现原理。

java中 实例方法才有多态的，在运行时动态绑定，类的成员变量是在编译时就决定了。

class A { 

int a =1; 

int method() { 

return a ; 

} 

} 

class B extends A { 

int a = 2 ; 

int Method() { 

return a ; 

} 

} 

B bb = new B() ; 

System.out.println(bb.a) //结果是2 

System.out.println(bb.method() ) //结果是2 

A aa =(B) new B() ; 

System.out.println(aa.a ) // 结果是1 

System.out.println(aa.method() ) //结果还是是2，多态

21. 实现多线程的两种方法：Thread与Runable。

1. 继承Thread类，重写run方法

2. 实现Runnable接口

3. 想要有返回值，用FutureTask，和Callable接口

例子：

public class CallableTest {
    // 创建一个计算任务，返回累加结果，构造器的参数是上界
    static class SumCaller implements Callable<Long> {
        private Integer count;

        public SumCaller(Integer count) {
            this.count = count;
        }

        public Long call() throws Exception {
            long sum = 0;
            for (int i = 0; i < count; i++) {
                sum += i;
            }
            return sum;
        }
    }

    private static Integer COUNT = 1000000000;

    public static void main(String[] args) throws InterruptedException,
            ExecutionException {
        SumCaller caller = new SumCaller(COUNT);
        FutureTask<Long> task = new FutureTask<Long>(caller);

        Thread thread = new Thread(task);
        thread.start();

        long sum = task.get();
        System.out.println("sum from 1 to " + COUNT + " result = " + sum);

    }
}

22. 线程同步的方法：synchronized、lock、reentrantLock等。

lock.lock()，加锁，lock.unlock()释放锁，

reentrantLock，可重入锁

synchronized 只有单一条件，不能设置加锁时间等，也不能设置多个锁

23. 锁的等级：方法锁、对象锁、类锁。

对象锁是用于对象实例方法，或者一个对象实例上的，类锁是用于类的静态方法或者一个类的class对象上的，我们知道，类的对象实例可以有很多个，但是每个类只有一个class对象，所以不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁。

24. 写出生产者消费者模式。

25. ThreadLocal的设计理念与作用。

Java中的ThreadLocal类允许我们创建只能被同一个线程读写的变量。因此，如果一段代码含有一个ThreadLocal变量的引用，即使两个线程同时执行这段代码，它们也无法访问到对方的ThreadLocal变量。虽然所有的线程都能访问到这个ThreadLocal实例，但是每个线程却只能访问到自己通过调用ThreadLocal的set()方法设置的值。即使是两个不同的线程在同一个ThreadLocal对象上设置了不同的值，他们仍然无法访问到对方的值。内部实现用同步Map。

　 private Map values = Collections.synchronizedMap(new HashMap());

public class ThreadLocalExample {
    public static class MyRunnable implements Runnable {
        private ThreadLocal threadLocal = new ThreadLocal();
        @Override
        public void run() {
            threadLocal.set((int) (Math.random() * 100D));
            try {
            Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
            System.out.println(threadLocal.get());
        }
    }

    public static void main(String[] args) {
         MyRunnable sharedRunnableInstance = new MyRunnable();
         Thread thread1 = new Thread(sharedRunnableInstance);
         Thread thread2 = new Thread(sharedRunnableInstance);
         thread1.start();
         thread2.start();
    }
}

26. ThreadPool用法与优势。

在多线程环境中使用Thread Pool，可以提高运行效率，不用每次新建一个线程，循环利用线程。

public class TestFixedThreadPool {
    public static void main(String[] args) {
        //创建一个可重用固定线程数的线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        //创建实现了Runnable接口对象，Thread对象当然也实现了Runnable接口
        Thread t1 = new MyThread();
        Thread t2 = new MyThread();
        Thread t3 = new MyThread();
        Thread t4 = new MyThread();
        Thread t5 = new MyThread();
        //将线程放入池中进行执行
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        //关闭线程池
        pool.shutdown();
    }
}

27. Concurrent包里的其他东西：ArrayBlockingQueue、CountDownLatch等等。

28. wait()和sleep()的区别。

1. sleep()不释放同步锁,wait()释放同步锁.

2. sleep是Thread类的方法，wait是Object的方法。wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用

29. foreach与正常for循环效率对比。

使用for，更高效率。 使用foreach，更安全。

如果在使用foreach遍历对象的过程中，其他线程修改了List的内容，例如添加或者删除，就会出现不可知的错误，而使用foreach则能够正确抛出错误信息。

30. Java IO与NIO。

字符流：reader

writer

字节流：inputStream

outputStream

NIO ： Buffer和channel

31. 反射的作用与原理。

指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程
序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods.

用途：Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

32. 泛型常用特点，List<String>能否转为List<Object>。

如果List<Object>作为函数参数，List<String>作为要传进来的参数，答案是不能。正确理解泛型概念的首要前提是理解类型擦除（type erasure）。 Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节代码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会被编译器在编译的时候去掉。这个过程就称为类型擦除。如在代码中定义的List<Object>和List<String>等类型，在编译之后都会变成List。JVM看到的只是List，而由泛型附加的类型信息对JVM来说是不可见的。

public void inspect(List<Object> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
    list.add(1); //这个操作在当前方法的上下文是合法的。
}
public void test() {
    List<String> strs = new ArrayList<String>();
    inspect(strs); //编译错误
}

public void wildcard(List<?> list) {
    list.add(1);//编译错误
}

如上所示，试图对一个带通配符的泛型类进行操作的时候，总是会出现编译错误。其原因在于通配符所表示的类型是未知的。

因为对于List<?>中的元素只能用Object来引用，在有些情况下不是很方便。在这些情况下，可以使用上下界来限制未知类型的范围。 如List<? extends Number>说明List中可能包含的元素类型是Number及其子类。而List<? super Number>则说明List中包含的是Number及其父类。当引入了上界之后，在使用类型的时候就可以使用上界类中定义的方法。比如访问 List<? extends Number>的时候，就可以使用Number类的intValue等方法。

更多请看这里：http://www.infoq.com/cn/articles/cf-java-generics

33. 解析XML的几种方式的原理与特点：DOM、SAX、PULL。

DOM解析：将整个XML加载到内存中，比较方便插入和查找相邻节点，但是耗内存，手机用得较少

SAX解析：simple API for XML，SAX解析XML文件采用的是事件驱动，进而调用一些回调方法（CallBack），比如

            startDocument()

            endDocument()

            startElement(String namespaceURI, String localName, String qName, Attributes atts)

            endElement(String uri, String localName, String name)

            characters(char[] ch, int start, int length)

            SAX解析适用于移动设备

   PULL解析：和SAX类似，Android自带jar包，根据EventType来进行，比如

             XmlPullParser.START_DOCUMENT

             XmlPullParser.END_DOCUMENT

             XmlPullParser.START_TAG

             XmlPullParser.END_TAG

             XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
              XmlPullParser parser = factory.newPullParser();
              parser.setInput(inputStream, "utf-8");
              int eventType = parser.getEventType();

             eventType = parser.next();

34. Java与C++对比。

35. Java1.7与1.8新特性。

1.7

1. map集合支持并发请求，且可以写成 Map map = {name:"xxx",age:18};

2．switch中可以使用字串了

3. 运用List<String> tempList = new ArrayList<>(); 即泛型实例化类型自动推断

4. 两个char间的equals bool Character.equalsIgnoreCase(char ch1, char ch2)

1.8

1. lambda 表达式：

原来代码：

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return b.compareTo(a);
    }
});
加入lambda表达式：
Collections.sort(names, (String a, String b) -> {
    return b.compareTo(a);
});

加入lambda表达式：

Collections.sort(names, (String a, String b) -> { 

return b.compareTo(a); 

});

更简洁：

Collections.sort(names, (String a, String b) -> b.compareTo(a));

更更简洁：

Collections.sort(names, (a, b) -> b.compareTo(a));

2 函数式接口：

更多请看这里：http://www.jb51.net/article/48304.htm

36. 设计模式：单例、工厂、适配器、责任链、观察者等等。

37. JNI的使用。

JVM

1. 内存模型以及分区，需要详细到每个区放什么。

2. 堆里面的分区：Eden，survival from to，老年代，各自的特点。

3. 对象创建方法，对象的内存分配，对象的访问定位。

4. GC的两种判定方法：引用计数与引用链。

5. GC的三种收集方法：标记清除、标记整理、复制算法的原理与特点，分别用在什么地方，如果让你优化收集方法，有什么思路？

6. GC收集器有哪些？CMS收集器与G1收集器的特点。

7. Minor GC与Full GC分别在什么时候发生？

8. 几种常用的内存调试工具：jmap、jstack、jconsole。

9. 类加载的五个过程：加载、验证、准备、解析、初始化。

10. 双亲委派模型：Bootstrap ClassLoader、Extension ClassLoader、ApplicationClassLoader。

11. 分派：静态分派与动态分派。

操作系统

1. 进程和线程的区别。

线程作为调度和分配的基本单位，进程作为拥有资源的基本单位

2. 死锁的必要条件，怎么处理死锁。

1. 循环等待

2. 非抢占

3. 互斥使用

4.占有并等待

处理死锁：死锁避免----银行家算法-包含资源请求算法和安全性算法

死锁检测算法

3. Window内存管理方式：段存储，页存储，段页存储。

4. 进程的几种状态。

运行、就绪、阻塞

5. IPC几种通信方式。

共享内存、消息传递、管道、信号量

6. 什么是虚拟内存。

操作系统的主要组成部分：进程和线程的管理，存储管理，设备管理，文件管理。虚拟内存是一些系统页文件，存放在磁盘上，每个系统页文件大小为4K，物 理内存也被分页，每个页大小也为4K，这样虚拟页文件和物理内存页就可以对应，实际上虚拟内存就是用于物理内存的临时存放的磁盘空间。页文件就是内存页， 物理内存中每页叫物理页，磁盘上的页文件叫虚拟页，物理页+虚拟页就是系统所有使用的页文件的总和。

7. 虚拟地址、逻辑地址、线性地址、物理地址的区别。

计算机网络

1. OSI与TCP/IP各层的结构与功能，都有哪些协议。

OSI分层 （7层）：物理层、数据链路层、网络层、传输层、会话层、表示层、应用层。

TCP/IP分层（4层）：网络接口层、 网际层、运输层、 应用层。

五层协议     （5层）：物理层、数据链路层、网络层、运输层、 应用层。

每一层的协议如下：

物理层：RJ45、CLOCK、IEEE802.3    （中继器，集线器，网关）

数据链路：PPP、FR、HDLC、VLAN、MAC  （网桥，交换机）

网络层：IP、ICMP、ARP、RARP、OSPF、IPX、RIP、IGRP、 （路由器）

传输层：TCP、UDP、SPX

会话层：NFS、SQL、NETBIOS、RPC

表示层：JPEG、MPEG、ASII

应用层：FTP、DNS、Telnet、SMTP、HTTP、WWW、NFS

每一层的作用如下：

物理层：通过媒介传输比特,确定机械及电气规范（比特Bit）

数据链路层：将比特组装成帧和点到点的传递（帧Frame）

网络层：负责数据包从源到宿的传递和网际互连（包PackeT）

传输层：提供端到端的可靠报文传递和错误恢复（段Segment）

会话层：建立、管理和终止会话（会话协议数据单元SPDU）

表示层：对数据进行翻译、加密和压缩（表示协议数据单元PPDU）

应用层：允许访问OSI环境的手段（应用协议数据单元APDU）

2. TCP与UDP的区别。

TCP提供面向连接的、可靠的数据流传输，而UDP提供的是非面向连接的、不可靠的数据流传输。

TCP传输单位称为TCP报文段，UDP传输单位称为用户数据报。

TCP注重数据安全性，UDP数据传输快，因为不需要连接等待，少了许多操作，但是其安全性却一般。

3. TCP报文结构。

4. TCP的三次握手与四次挥手过程，各个状态名称与含义，TIMEWAIT的作用。

5. TCP拥塞控制。

6. TCP滑动窗口与回退N针协议。

7. Http的报文结构。

8. Http的状态码含义。

状态码
状态描述
简要说明

200
OK
客户端请求成功

201
Created
请求已经被实现，而且有一个新的资源已经依据请求的需要而创建，且其URI已经随Location头信息返回。

301
Moved Permanently
被请求的资源已永久移动到新位置，并且将来任何对此资源的引用都应该使用本响应返回的若干个URI之一

302
Found
在响应报文中使用首部“Location: URL”指定临时资源位置

304
Not Modified
条件式请求中使用

403
Forbidden
请求被服务器拒绝

404
Not Found
服务器无法找到请求的URL

405
Method Not Allowed
不允许使用此方法请求相应的URL

500
Internal Server Error
服务器内部错误

502
Bad Gateway
代理服务器从上游收到了一条伪响应

503
Service Unavailable
服务器此时无法提供服务，但将来可能可用

505
HTTP Version Not Supported
服务器不支持，或者拒绝支持在请求中使用的HTTP版本。这暗示着服务器不能或不愿使用与客户端相同的版本。响应中应当包含一个描述了为何版本不被支持以及服务器支持哪些协议的实体。

9. Http request的几种类型。

OPTIONS：返回服务器针对特定资源所支持的HTTP请求方法。也可以利用向Web服务器发送'*'的请求来测试服务器的功能性。

HEAD：向服务器索要与GET请求相一致的响应，只不过响应体将不会被返回。这一方法可以在不必传输整个响应内容的情况下，就可以获取包含在响应消息头中的元信息。

GET：向特定的资源发出请求。

POST：向指定资源提交数据进行处理请求（例如提交表单或者上传文件）。数据被包含在请求体中。POST请求可能会导致新的资源的创建和/或已有资源的修改。

PUT：向指定资源位置上传其最新内容。

DELETE：请求服务器删除Request-URI所标识的资源。

TRACE：回显服务器收到的请求，主要用于测试或诊断。

CONNECT：HTTP/1.1协议中预留给能够将连接改为管道方式的代理服务器。

10. Http1.1和Http1.0的区别

1. HTTP 1.0规定浏览器与服务器只保持短暂的连接，而HTTP 1.1 支持长连接

2. HTTP 1.1支持持久连接，在一个TCP连接上可以传送多个HTTP请求和响应，减少了建立和关闭连接的消耗和延迟。HTTP1.1还允许客户端不用等待上一次请求结果返回，就可以发出下一次请求，但服务器端必须按照接收到客户端请求的先后顺序依次回送响应结果，以保证客户端能够区分出每次请求的响应内容，这样也显著地减少了整个下载过程所需要的时间。

3. HTTP 1.1还提供了与身份认证、状态管理和Cache缓存等机制相关的请求头和响应头。

4. HTTP 1.1中增加Host请求头字段后，WEB浏览器可以使用主机头名来明确表示要访问服务器上的哪个WEB站点，这才实现了在一台WEB服务器上可以在同一个IP地址和端口号上使用不同的主机名来创建多个虚拟WEB站点。

11. Http怎么处理长连接。

http长连接即持久连接是http1.1版本的一个特性，即一个http连接建立完成一个请求-回应后，可以不需要立刻关闭，可以重复使用。http的长连接是可以发送多个请求而不用等待每个响应的。

12. Cookie与Session的作用于原理。

13. 电脑上访问一个网页，整个过程是怎么样的：DNS、HTTP、TCP、OSPF、IP、ARP。

14. Ping的整个过程。ICMP报文是什么。

15. C/S模式下使用socket通信，几个关键函数。

Server : listen(port)

accept()

Client :   connect(ip_address, port)

16. IP地址分类。

A : 0开头   （1.0.0.0 ~ 126.255.255.255）  政府

B：10开头  （128.0.0.0 ~ 191.255.255.255） 企业

C：110开头 （192.0.0.0 ~ 233.255.255.255）  个人

D：1110开头（224.0.0.1~239.255.255.254） 组播

E：11110开头（240.0.0.1~255.255.255.254）  实验

全1 ： 广播地址

全0 ： 网络地址

17. 路由器与交换机区别。

路由器是3层设备，工作在网络层，交换机工作与数据链路层，是第2层设备。交换机内部的CPU会在每个端口成功连接时，通过ARP协议学习它的MAC地址，保存成一张 ARP表。在今后的通讯中，发往该MAC地址的数据包将仅送往其对应的端口，而不是所有的端口。因此，交换机可用于划分数据链路层广播，即冲突域；但它不 能划分网络层广播，即广播域。路由器的一个作用是连通不同的网络，另一个作用是选择信息传送的线路。

Android

1. Activity与Fragment的生命周期。

2. Acitivty的四中启动模式与特点。

3. Activity缓存方法。

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

5. 怎么保证service不被杀死。

6. 广播的两种注册方法，有什么区别。

7. Intent的使用方法，可以传递哪些数据类型。

8. ContentProvider使用方法。

9. Thread、AsycTask、IntentService的使用场景与特点。

10. FrameLayout , LinearLayout  AbsoluteLayout 、 RelativeLayout 、 TableLayout各自特点及绘制效率对比。

11. Android的数据存储形式。

12. Sqlite的基本操作。

13. Android中的MVC模式。

14. Merge、ViewStub的作用。

15. Json有什么优劣势。

16. 动画有哪两类，各有什么特点？

17. Handler、Loop消息队列模型，各部分的作用。

18. 怎样退出终止App。

19. Asset目录与res目录的区别。

20. Android怎么加速启动Activity。

21. Android内存优化方法：ListView优化，及时关闭资源，图片缓存等等。

22. Android中弱引用与软引用的应用场景。

23. Bitmap的四中属性，与每种属性队形的大小。

24. View与View Group分类。自定义View过程：onMeasure()、onLayout()、onDraw()。

25. Touch事件分发机制。

26. Android长连接，怎么处理心跳机制。

27. Zygote的启动过程。

28. Android IPC:Binder原理。

29. 你用过什么框架，是否看过源码，是否知道底层原理。

30. Android5.0、6.0新特性。

数据结构于算法

1. 链表与数组。

2. 队列和栈，出栈与入栈。

3. 链表的删除、插入、反向。

4. 字符串操作。

5. Hash表的hash函数，冲突解决方法有哪些。

6. 各种排序：冒泡、选择、插入、希尔、归并、快排、堆排、桶排、基数的原理、平均时间复杂度、最坏时间复杂度、空间复杂度、是否稳定。

7. 快排的partition函数与归并的Merge函数。

8. 对冒泡与快排的改进。

9. 二分查找，与变种二分查找。

10. 二叉树、B+树、AVL树、红黑树、哈夫曼树。

11. 二叉树的前中后续遍历：递归与非递归写法，层序遍历算法。

12. 图的BFS与DFS算法，最小生成树prim算法与最短路径Dijkstra算法。

13. KMP算法。

14. 排列组合问题。

15. 动态规划、贪心算法、分治算法。（一般不会问到）

16. 大数据处理：类似10亿条数据找出最大的1000个数.........等等

项目

1. XXX（某个比较重要的点）是怎么实现的？

2. 你在项目中遇到的最大的困难是什么，怎么解决的？

3. 项目某个部分考虑的不够全面，如果XXXX，你怎么优化？

4. XXX（一个新功能）需要实现，你有什么思路？

其他（问面试官的问题）

1. 贵公司一向以XXX著称，能不能说明一下公司这方面的特点？

2. 贵公司XXX业务发展很好，这是公司发展的重点么？

3. 对技术和业务怎么看？

4. 贵公司一般的团队是多大，几个人负责一个产品或者业务？

5. 贵公司的开发中是否会使用到一些最新技术？

6. 对新人有没有什么培训，会不会安排导师？

7. 对Full Stack怎么看？

8. 你觉得我有哪些需要提高的地方？