面试问题

J2EE 部分：
1，Switch能否用string做参数？

在 Java 7 之前, switch 只能支持byte,short,char,int 或者其对应的封装类以及 Enum 类型。在JAVA 7中,String 支持被加上了。,

2，equals与==的区别：

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

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

在Object对象中equals方法是return this.obj==obj的，比较的是内存空间的应用，可以重写这个equals方法，比较不同的属性

3，Object有哪些公用方法？
方法equals测试的是两个对象是否相等
方法clone进行对象拷贝
方法getClass返回和当前对象相关的Class对象

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

4，Java的四种引用，强弱软虚，用到的场景

   强引用：如果一个对象具有强引用，它就不会被垃圾回收器回收。即使当前内存空间不足，JVM 也不会回收它，而是抛出 OutOfMemoryError 错误，使程序异常终止。如果想中断强引用和某个对象之间的关联，可以显式地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象
    软引用：在使用软引用时，如果内存的空间足够，软引用就能继续被使用，而不会被垃圾回收器回收，只有在内存不足时，软引用才会被垃圾回收器回收。
    弱引用：具有弱引用的对象拥有的生命周期更短暂。因为当 JVM 进行垃圾回收，一旦发现弱引用对象，无论当前内存空间是否充足，都会将弱引用回收。不过由于垃圾回收器是一个优先级较低的线程，所以并不一定能迅速发现弱引用对象
    虚引用：顾名思义，就是形同虚设，如果一个对象仅持有虚引用，那么它相当于没有引用，在任何时候都可能被垃圾回收器回收。
使用场景：
  利用软引用和弱引用解决OOM问题：用一个HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象所占用的空间，从而有效地避免了OOM的问题
   通过软引用对象重获方法实现Java对象的高速缓存:比如我们创建了一Employee的类，如果每次需要查询一个雇员的信息。哪怕是几秒中之前刚刚查询过的，都要重新构建一个实例，这是需要消耗很多时间的。我们可以通过软引用和 HashMap 的结合，先是保存引用方面：以软引用的方式对一个Employee对象的实例进行引用并保存该引用到HashMap 上，key 为此雇员的 id，value为这个对象的软引用，另一方面是取出引用，缓存中是否有该Employee实例的软引用，如果有，从软引用中取得。如果没有软引用，或者从软引用中得到的实例是null，重新构建一个实例，并保存对这个新建实例的软引用
5，Hashcode的作用，与 equal 有什么区别    HashMap用用到的关键方法
   同样用于鉴定2个对象是否相等的，java集合中有 list 和 set 两类，其中 set不允许元素重复实现，那个这个不允许重复实现的方法，如果用 equal 去比较的话，如果存在1000个元素，你 new 一个新的元素出来，需要去调用1000次 equal 去逐个和他们比较是否是同一个对象，这样会大大降低效率。hashcode实际上是返回对象的存储地址，如果这个位置上没有元素，就把元素直接存储在上面，如果这个位置上已经存在元素，这个时候才去调用equal方法与新元素进行比较，相同的话就不存了，散列到其他地址上
6，String、StringBuffer与StringBuilder的区别
String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象
StringBuffer和StringBuilder底层是 char[]数组实现的

StringBuffer是线程安全的，而StringBuilder是线程不安全的,

7，Override和Overload的含义去区别

    Overload顾名思义是重新加载，它可以表现类的多态性，可以是函数里面可以有相同的函数名但是参数名、返回值、类型不能相同；或者说可以改变参数、类型、返回值但是函数名字依然不变。
    Override(重写)的意思，在子类继承父类的时候子类中可以定义某方法与其父类有相同的名称和参数，当子类在调用这一函数时自动调用子类的方法，而父类相当于被覆盖（重写）了。
8，抽象类和接口的区别
   1.接口和抽象类的概念不一样。接口是对动作的抽象，抽象类是对根源的抽象。
抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.
    2 .一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)，人是根源，吃饭，走路时接口。
    3 .一个类可以实现多个接口，因为一个对象的动作有很多，但是只能继承一个类，因为一个对象的根，本质只有一个。

    4.接口中所有的方法都是抽象的，没有一个有程序体。抽象类是可以有非抽象方法。抽象类和接口中的抽象方法都不实现。

     抽象类：抽象类只关心操作，即只关心方法的名字，类型以及参数，不关心这些操作是怎么实现的，即不关系方法体。设计程序时，可以把几个类的共有的轮廓，重要特征抽象成一个抽象类，不需要关心具体细节。

     接口：

     1.接口体类只能有常量和抽象方法，即方法都是等待实现的方法。
     2.一个类实现了某个接口，必须重写该接口的所有方法。
     3.多个类可以实现同一个接口，一个类可以实现多个接口。

9,解析XML的几种方式的原理与特点：DOM、SAX、PULL
   DOM：消耗内存：先把xml文档都读到内存中，然后再用DOM API来访问树形结构，并获取数据。这个写起来很简单，但是很消耗内存。要是数据过大，手机不够牛逼，可能手机直接死机
   SAX：解析效率高，占用内存少，逐行扫描，基于事件驱动的：更加简单地说就是对文档进行顺序扫描，当扫描到文档(document)开始与结束、元素(element)开始与结束、文档(document)结束等地方时通知事件处理函数，由事件处理函数做相应动作，然后继续同样的扫描，直至文档结束。
  SAX：与 SAX 类似，也是基于事件驱动，我们可以调用它的next（）方法，来获取下一个解析事件（就是开始文档，结束文档，开始标签，结束标签），当处于某个元素时可以调用XmlPullParser的getAttributte()方法来获取属性的值，也可调用它的nextText()获取本节点的值。
10,wait()和sleep()的区别
sleep来自Thread类，和wait来自Object类
调用sleep()方法的过程中，线程不会释放对象锁。而 调用 wait 方法线程会释放对象锁
sleep睡眠后不出让系统资源，wait让出系统资源其他线程可以占用CPU
sleep(milliseconds)需要指定一个睡眠时间，时间一到会自动唤醒
11，JAVA 中堆和栈的区别，说下java 的内存机制
基本数据类型比变量和对象的引用都是在栈分配的
堆内存用来存放由new创建的对象和数组
类变量（static修饰的变量），程序在一加载的时候就在堆中为类变量分配内存，堆中的内存地址存放在栈中
实例变量：当你使用java关键字new的时候，系统在堆中开辟并不一定是连续的空间分配给变量，是根据零散的堆内存地址，通过哈希算法换算为一长串数字以表征这个变量在堆中的"物理位置”,实例变量的生命周期--当实例变量的引用丢失后，将被GC（垃圾回收器）列入可回收“名单”中，但并不是马上就释放堆中内存

局部变量: 由声明在某方法，或某代码段里（比如for循环），执行到它的时候在栈中开辟内存，当局部变量一但脱离作用域，内存立即释放

    java堆：

   1，存放的是由new创建的对象和数组，每个对象包含一个与之对应的Class信息

   2，Java堆被线程所共享，只存放对象本身

   3，java堆的结构：eden区，survivor区，老年区，永久区，以及分配策略，GC回收

   java栈：

   1，每个线程包括一个java栈，java栈中只保存基础数据类型的对象和自定义对象的引用

   2，每个栈的数据都是线程私有的，其他线程不能访问

   3，java栈以栈帧为基础，每调用一个方法就产生一个栈帧分为三部分：基本类型变量区，执行环境上下文，操作指令区

12，JAVA多态的实现原理
抽象的来讲，多态的意思就是,同一个类的对象对同一个消息产生不同响应（发送消息就是函数调用）
实现的原理是动态绑定，程序调用的方法在运行期才动态绑定，追溯源码可以发现，JVM 通过参数的自动转型来找到合适的办法。
13，JAVA 垃圾回收机制
什么是垃圾回收机：释放那些不再持有引用的对象的内存
怎么判断一个对象是否需要收集？
   引用计数（最简单古老的方法）：指将资源（可以是对象、内存或磁盘空间等等）的被引用次数保存起来，当被引用次数变为零时就将其释放的过程，不能解决两个对象相互引用的问题。
   对象引用遍历（现在大多数 jvm 使用的方法）：对象引用遍历从一组对象开始，沿着整个对象图上的每条链接，递归确定可到达（reachable）的对象。如果某对象不能从这些根对象的一个（至少一个）到达，则将它作为垃圾收集

几种垃圾回收机制：

   引用计数法（最简单古老的方法）：指将资源（可以是对象、内存或磁盘空间等等）的被引用次数保存起来，当被引用次数变为零时就将其释放的过程，不能解决两个对象相互引用的问题。   

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

   标记-压缩回收法：前期与第一种方法相同，只是多了一步，将所有的存活对象压缩到内存的一端，这样内存碎片就可以合成一大块可再利用的内存区域，提高了内存利用率
   复制回收法：把现有内存空间分成两部分，gc运行时，它把可到达对象复制到另一半空间，再清空正在使用的空间的全部对象。这种方法适用于短生存期的对象，持续复制长生存期的对象则导致效率降低。

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

14，讲讲 Java 中的集合有多少种，区别是什么？

     ArrayList、LinkedList、Vector的区别：ArrayList 和Vector底层是采用数组方式存储数据，Vector由于使用了synchronized方法（线程安全）所以性能上比ArrayList要差，

              ArrayList    Vector

安全       不安全         安全

扩容        1.5 倍           2倍

LinkedList使用双向链表实现存储，随机存取比较慢

HashMap的底层源码实现：当我们往HashMap中put元素的时候，先根据key的hashCode重新计算hash值，根据hash值得到这个元素在数组中的位置（即下标），如果数组该位置上已经存放有其他元素了，那么在这个位置上的元素将以链表的形式存放，新加入的放在链头，最先加入的放在链尾。如果数组该位置上没有元素，就直接将该元素放到此数组中的该位置上。
Fail-Fast机制:在使用迭代器的过程中有其他线程修改了map，那么将抛出ConcurrentModificationException，这就是所谓fail-fast机制。这一机制在源码中的实现是通过modCount域，modCount顾名思义就是修改次数，对HashMap内容的修改都将增加这个值，那么在迭代器初始化过程中会将这个值赋给迭代器的expectedModCount。在迭代过程中，判断modCount跟expectedModCount是否相等，如果不相等就表示已经有其他线程修改了Map.
15，HashMap和 HashTable 的区别：
HashTable比较老，是基于Dictionary 类实现的，HashTable 则是基于 Map接口实现的
HashTable 是线程安全的， HashMap 则是线程不安全的
HashMap可以让你将空值作为一个表的条目的key或value

                        HashMap     HashTable     

空key               允许一个       不允许

继承                   map接口      Dictionary 类

安全                  不安全            安全

初始容量           16                      11

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

ConcurrentHashMap 有锁分段技术，是安全高效的hashmap。HashTable在竞争激烈的并发环境下效率低下，因为HashTable的线程竞争同一把锁。ConcurrentHashMap 首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用访问一段数据时，其他线程也能访问其他段的数据

ConcurrentHashMap 的结构：

ConcurrentHashMap 是Segment数组和HashEntry数据结构组成。

ConcurrentHashMap 类中有个Segment<K,V>[] segment=new Segment<K,V>[];数组每一个元素都是Segment对象，在Segment<K,V>类中的结构中有一个HashEntry<K,V>的table数组，HashEntry<K,V>就是节点，包含key，value，hash，next，segments等字段。

就是ConcurrentHashMap 维持了一个Segment<K,V>数组，每个segment元素维持了一个HashEntry<K,V>数组，HashEntry<K,V>就是数组+链表结构

get方法是先定位到segment元素的索引再在这个segment元素的HashEntry中找key，就和HashMap的过程是一样的了

17. TreeMap、HashMap、LindedHashMap 的区别。

Hashmap 是一个最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值，具有很快的访问速度，遍历时，取得数据的顺序是完全随机的。HashMap最多只允许一条记录的键为Null;允许多条记录的值为 Null;HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap;可能会导致数据的不一致。如果需要同步，可以用 Collections的synchronizedMap方法使HashMap具有同步的能力，或者使用ConcurrentHashMap。
Hashtable与 HashMap类似,它继承自Dictionary类，不同的是:它不允许记录的键或者值为空;它支持线程的同步，即任一时刻只有一个线程能写Hashtable,因此也导致了 Hashtable在写入时会比较慢。
LinkedHashMap保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的.也可以在构造时用带参数，按照应用次数排序。在遍历的时候会比HashMap慢，不过有种情况例外，当HashMap容量很大，实际数据较少时，遍历起来可能会比LinkedHashMap慢，因为LinkedHashMap的遍历速度只和实际数据有关，和容量无关，而HashMap的遍历速度和他的容量有关。
TreeMap实现SortMap接口，能够把它保存的记录根据键排序,默认是按键值的升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。

一般情况下，我们用的最多的是HashMap,HashMap里面存入的键值对在取出的时候是随机的,它根据键的HashCode值存储数据,根据键可以直接获取它的值，具有很快的访问速度。在Map 中插入、删除和定位元素，HashMap 是最好的选择。
TreeMap取出来的是排序后的键值对。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。
LinkedHashMap 是HashMap的一个子类，如果需要输出的顺序和输入的相同,那么用LinkedHashMap可以实现,它还可以按读取顺序来排列，像连接池中可以应用。

18. Collection 包结构，与 Collections 的区别

java.util.Collection 是一个集合接口（集合类的一个顶级接口）。

java.util.Collections 是一个包装类（工具类/帮助类）。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，用于对集合中元素进行排序、搜索以及线程安全等各种操作，服务于Java的Collection框架。

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

会执行
20. Excption 与 Error 包结构。OOM 你遇到过哪些情况，SOF 你遇到过哪些情况。

包名：java.lang.Exception

1，Throwable
Throwable是 Java 语言中所有错误或异常的超类。
Throwable包含两个子类: Error 和 Exception 。它们通常用于指示发生了异常情况。
Throwable包含了其线程创建时线程执行堆栈的快照，它提供了printStackTrace()等接口用于获取堆栈跟踪数据等信息。

2. Exception
Exception及其子类是 Throwable 的一种形式.Exception是可恢复的异常，是编译器可以捕捉到的。包含两种异常：

     检查异常：比如IO和SQL异常，需要用try-catch语句。发生在编译阶段，编译器强制程序去捕获此类型的异常。

     运行时异常：就是在运行时出现的异常，编译器没有强制捕获处理。比如空指针异常，类型转换异常，数组越界异常。

3. Error
和Exception一样， Error也是Throwable的子类。Error表示程序运行期间出现严重的错误，是不仅可恢复的，大多是属于JVM层次的严重错误，这种中错误会导致程序终止执行。

堆内存溢出：

一般出现情况：加载的图片太多或图片过大时、分配特大的数组、内存相应资源过多没有来不及释放

栈溢出的原因：
     递归调用
     大量循环或死循环
     全局变量是否过多
     数组、List、map数据过大

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

封装：也就是把客观事物封装成抽象的类。对这些数据和操作加上3种访问权限，某些数据可以是私有的，不能被外界访问。一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。

      继承：是指可以让某个类型的对象获得另一个类型的对象的属性的方法。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”

    多态就是指一个类实例的相同方法在不同情形有不同表现形式。重载和重写

20. java 多态的实现原理。重载和重写
21. 实现多线程的两种方法：Thread 与 Runable。

22. 线程同步的方法：sychronized、lock、reentrantLock 等。
23. 锁的等级：方法锁、对象锁、类锁。
24. 写出生产者消费者模式。

http://blog.csdn.net/monkey_d_meng/article/details/6251879

http://www.cnblogs.com/chenpi/p/5553325.html

（1）wait() / notify()方法

import java.util.LinkedList;/** * 仓库类Storage实现缓冲区 *  * Email:[e-mail] *  * @author MONKEY.D.MENG 2011-03-15 *  */public class Storage{// 仓库最大存储量private final int MAX_SIZE = 100;// 仓库存储的载体private LinkedList<Object> list = new LinkedList<Object>();// 生产num个产品public void produce(int num){// 同步代码段synchronized (list){// 如果仓库剩余容量不足while (list.size() + num > MAX_SIZE){System.out.println("【要生产的产品数量】:" + num + "/t【库存量】:"        + list.size() + "/t暂时不能执行生产任务!");try{// 由于条件不满足，生产阻塞list.wait();}catch (InterruptedException e){e.printStackTrace();}}// 生产条件满足情况下，生产num个产品for (int i = 1; i <= num; ++i){list.add(new Object());}System.out.println("【已经生产产品数】:" + num + "/t【现仓储量为】:" + list.size());list.notifyAll();}}// 消费num个产品public void consume(int num){// 同步代码段synchronized (list){// 如果仓库存储量不足while (list.size() < num){System.out.println("【要消费的产品数量】:" + num + "/t【库存量】:"        + list.size() + "/t暂时不能执行生产任务!");try{// 由于条件不满足，消费阻塞list.wait();}catch (InterruptedException e){e.printStackTrace();}}// 消费条件满足情况下，消费num个产品for (int i = 1; i <= num; ++i){list.remove();}System.out.println("【已经消费产品数】:" + num + "/t【现仓储量为】:" + list.size());list.notifyAll();}}// get/set方法public LinkedList<Object> getList(){return list;}public void setList(LinkedList<Object> list){this.list = list;}public int getMAX_SIZE(){return MAX_SIZE;}}/** * 生产者类Producer继承线程类Thread *  * Email:[e-mail] *  * @author MONKEY.D.MENG 2011-03-15 *  */public class Producer extends Thread{// 每次生产的产品数量private int num;// 所在放置的仓库private Storage storage;// 构造函数，设置仓库public Producer(Storage storage){this.storage = storage;}// 线程run函数public void run(){produce(num);}// 调用仓库Storage的生产函数public void produce(int num){storage.produce(num);}// get/set方法public int getNum(){return num;}public void setNum(int num){this.num = num;}public Storage getStorage(){return storage;}public void setStorage(Storage storage){this.storage = storage;}}/** * 消费者类Consumer继承线程类Thread *  * Email:[e-mail] *  * @author MONKEY.D.MENG 2011-03-15 *  */public class Consumer extends Thread{// 每次消费的产品数量private int num;// 所在放置的仓库private Storage storage;// 构造函数，设置仓库public Consumer(Storage storage){this.storage = storage;}// 线程run函数public void run(){consume(num);}// 调用仓库Storage的生产函数public void consume(int num){storage.consume(num);}// get/set方法public int getNum(){return num;}public void setNum(int num){this.num = num;}public Storage getStorage(){return storage;}public void setStorage(Storage storage){this.storage = storage;}}/** * 测试类Test *  * Email:[e-mail] *  * @author MONKEY.D.MENG 2011-03-15 *  */public class Test{public static void main(String[] args){// 仓库对象Storage storage = new Storage();// 生产者对象Producer p1 = new Producer(storage);Producer p2 = new Producer(storage);Producer p3 = new Producer(storage);Producer p4 = new Producer(storage);Producer p5 = new Producer(storage);Producer p6 = new Producer(storage);Producer p7 = new Producer(storage);// 消费者对象Consumer c1 = new Consumer(storage);Consumer c2 = new Consumer(storage);Consumer c3 = new Consumer(storage);// 设置生产者产品生产数量p1.setNum(10);p2.setNum(10);p3.setNum(10);p4.setNum(10);p5.setNum(10);p6.setNum(10);p7.setNum(80);// 设置消费者产品消费数量c1.setNum(50);c2.setNum(20);c3.setNum(30);// 线程开始执行c1.start();c2.start();c3.start();p1.start();p2.start();p3.start();p4.start();p5.start();p6.start();p7.start();}}【要消费的产品数量】:50【库存量】:0暂时不能执行生产任务!【要消费的产品数量】:30【库存量】:0暂时不能执行生产任务!【要消费的产品数量】:20【库存量】:0暂时不能执行生产任务!【已经生产产品数】:10【现仓储量为】:10【要消费的产品数量】:20【库存量】:10暂时不能执行生产任务!【要消费的产品数量】:30【库存量】:10暂时不能执行生产任务!【要消费的产品数量】:50【库存量】:10暂时不能执行生产任务!【已经生产产品数】:10【现仓储量为】:20【要消费的产品数量】:50【库存量】:20暂时不能执行生产任务!【要消费的产品数量】:30【库存量】:20暂时不能执行生产任务!【已经消费产品数】:20【现仓储量为】:0【已经生产产品数】:10【现仓储量为】:10【已经生产产品数】:10【现仓储量为】:20【已经生产产品数】:80【现仓储量为】:100【要生产的产品数量】:10【库存量】:100暂时不能执行生产任务!【已经消费产品数】:30【现仓储量为】:70【已经消费产品数】:50【现仓储量为】:20【已经生产产品数】:10【现仓储量为】:30【已经生产产品数】:10【现仓储量为】:40

BlockingQueue阻塞队列方法

import java.util.concurrent.LinkedBlockingQueue;/** * 仓库类Storage实现缓冲区 *  * Email:[e-mail] *  * @author MONKEY.D.MENG 2011-03-15 *  */public class Storage{// 仓库最大存储量private final int MAX_SIZE = 100;// 仓库存储的载体private LinkedBlockingQueue<Object> list = new LinkedBlockingQueue<Object>(        100);// 生产num个产品public void produce(int num){// 如果仓库剩余容量为0if (list.size() == MAX_SIZE){System.out.println("【库存量】:" + MAX_SIZE + "/t暂时不能执行生产任务!");}// 生产条件满足情况下，生产num个产品for (int i = 1; i <= num; ++i){try{// 放入产品，自动阻塞list.put(new Object());}catch (InterruptedException e){e.printStackTrace();}System.out.println("【现仓储量为】:" + list.size());}}// 消费num个产品public void consume(int num){// 如果仓库存储量不足if (list.size() == 0){System.out.println("【库存量】:0/t暂时不能执行生产任务!");}// 消费条件满足情况下，消费num个产品for (int i = 1; i <= num; ++i){try{// 消费产品，自动阻塞list.take();}catch (InterruptedException e){e.printStackTrace();}}System.out.println("【现仓储量为】:" + list.size());}// set/get方法public LinkedBlockingQueue<Object> getList(){return list;}public void setList(LinkedBlockingQueue<Object> list){this.list = list;}public int getMAX_SIZE(){return MAX_SIZE;}}【库存量】:0暂时不能执行生产任务!【库存量】:0暂时不能执行生产任务!【现仓储量为】:1【现仓储量为】:1【现仓储量为】:3【现仓储量为】:4【现仓储量为】:5【现仓储量为】:6【现仓储量为】:7【现仓储量为】:8【现仓储量为】:9【现仓储量为】:10【现仓储量为】:11【现仓储量为】:1【现仓储量为】:2【现仓储量为】:13【现仓储量为】:14【现仓储量为】:17【现仓储量为】:19【现仓储量为】:20【现仓储量为】:21【现仓储量为】:22【现仓储量为】:23【现仓储量为】:24【现仓储量为】:25【现仓储量为】:26【现仓储量为】:12【现仓储量为】:1【现仓储量为】:1【现仓储量为】:2【现仓储量为】:3【现仓储量为】:4【现仓储量为】:5【现仓储量为】:6【现仓储量为】:7【现仓储量为】:27【现仓储量为】:8【现仓储量为】:6【现仓储量为】:18【现仓储量为】:2【现仓储量为】:3【现仓储量为】:4【现仓储量为】:5【现仓储量为】:6【现仓储量为】:7【现仓储量为】:8【现仓储量为】:9【现仓储量为】:10【现仓储量为】:16【现仓储量为】:11【现仓储量为】:12【现仓储量为】:13【现仓储量为】:14【现仓储量为】:15【现仓储量为】:1【现仓储量为】:2【现仓储量为】:3【现仓储量为】:3【现仓储量为】:15【现仓储量为】:1【现仓储量为】:0【现仓储量为】:1【现仓储量为】:1【现仓储量为】:1【现仓储量为】:2【现仓储量为】:3【现仓储量为】:4【现仓储量为】:0【现仓储量为】:1【现仓储量为】:5【现仓储量为】:6【现仓储量为】:7【现仓储量为】:8【现仓储量为】:9【现仓储量为】:10【现仓储量为】:11【现仓储量为】:12【现仓储量为】:13【现仓储量为】:14【现仓储量为】:15【现仓储量为】:16【现仓储量为】:17【现仓储量为】:1【现仓储量为】:1【现仓储量为】:2【现仓储量为】:3【现仓储量为】:4【现仓储量为】:5【现仓储量为】:6【现仓储量为】:3【现仓储量为】:3【现仓储量为】:1【现仓储量为】:2【现仓储量为】:3【现仓储量为】:4【现仓储量为】:5【现仓储量为】:6【现仓储量为】:7【现仓储量为】:8【现仓储量为】:9【现仓储量为】:10【现仓储量为】:11【现仓储量为】:12【现仓储量为】:13【现仓储量为】:14【现仓储量为】:15【现仓储量为】:16【现仓储量为】:17【现仓储量为】:18【现仓储量为】:19【现仓储量为】:6【现仓储量为】:7【现仓储量为】:8【现仓储量为】:9【现仓储量为】:10【现仓储量为】:11【现仓储量为】:12【现仓储量为】:13【现仓储量为】:14【现仓储量为】:15【现仓储量为】:16【现仓储量为】:17【现仓储量为】:18【现仓储量为】:19【现仓储量为】:20【现仓储量为】:21【现仓储量为】:22【现仓储量为】:23【现仓储量为】:24【现仓储量为】:25【现仓储量为】:26【现仓储量为】:27【现仓储量为】:28【现仓储量为】:29【现仓储量为】:30【现仓储量为】:31【现仓储量为】:32【现仓储量为】:33【现仓储量为】:34【现仓储量为】:35【现仓储量为】:36【现仓储量为】:37【现仓储量为】:38【现仓储量为】:39【现仓储量为】:40

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

26. ThreadPool 用法与优势。

ThreadLocal类允许我们创建只能被同一个线程读写的变量。因此，如果一段代码含有一个ThreadLocal变量的引用，即使两个线程同时执行这段代码，它们也无法访问到对方的ThreadLocal变量

如何创建ThreadLocal变量
以下代码展示了如何创建一个ThreadLocal变量

private ThreadLocal myThreadLocal = new ThreadLocal();

通过这段代码实例化了一个ThreadLocal对象。我们只需要实例化对象一次，并且也不需要知道它是被哪个线程实例化。虽然所有的线程都能访问到这个ThreadLocal实例，但是每个线程却只能访问到自己通过调用ThreadLocal的set()方法设置的值。即使是两个不同的线程在同一个ThreadLocal对象上设置了不同的值，他们仍然无法访问到对方的值。

一个完整的ThreadLocal例子

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();    }}

27. Java 与 C++对比。平台，指针，继承，内存方面

1，java是解释性语言，运行过程是：程序源码经过java编译器编译成字节码，然后由java虚拟机解释执行。C++是编译型语言，源代码经过编译链接生成可执行的二进制代码

2，java具有平台无关性

3，java无指针的概念，头文件，结构体的概念

4，java不支持多继承，可以实现多个接口

5，java的内存是由虚拟机管理的，C++是开发人员管理内存

28. Java1.7 与 1.8 新特性。

比如Java1.7的switch参数可以是字符串了，Java1.8中的HashMap的hash算法和红黑树。
36. 设计模式：单例、工厂、适配器、责任链、观察者等等。
37. JNI 的使用

JVM
1. 内存模型以及分区，需要详细到每个区放什么。
2. 堆里面的分区：Eden，survival from to，老年代，各自的特点。
3. 对象创建方法，对象的内存分配，对象的访问定位。
4. GC 的两种判定方法：引用计数与引用链。
5. GC 的三种收集方法：标记清除、标记整理、复制算法的原理与特点，分别用在什么
地方，如果让你优化收集方法，有什么思路？
6. GC 收集器有哪些？CMS 收集器与 G1 收集器的特点。
7. Minor GC 与 Full GC 分别在什么时候发生？

从年轻代空间（包括 Eden 和 Survivor 区域）回收内存被称为 Minor GC。

当 JVM 无法为一个新的对象分配空间时会触发 Minor GC，比如当 Eden 区满了。所以分配率越高，越频繁执行 Minor GC。

Minor GC 的情况就相当清楚了——每次 Minor GC 会清理年轻代的内存。

Major GC 是清理永久代。
Full GC 是清理整个堆空间—包括年轻代和永久代。
8. 几种常用的内存调试工具：jmap、jstack、jconsole。

http://www.open-open.com/lib/view/open1390916852007.html
9. 类加载的五个过程：加载、验证、准备、解析、初始化。

加载：

需要完成三件事情：

（1）通过一个类的全限定名来获取其定义的二进制字节流。
（2）将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
（3）在内存中生成一个代表这个类的Java.lang.Class对象

验证：

验证阶段的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求

（1）文件格式验证
   这一阶段是要验证字节流是否符合Class文件格式的规范

   - 主、次版本号是否在当前虚拟机处理范围之内
   - 常量池的常量中是否有不被支持的常量类型（检查常量tag标志）
   - 指向常量的各种索引值中是否有指向不存在的常量或不符合类型的常量
   - CONSTANT_Utf8_info 型的常量中是否有不符合UTF8 编码的数据
   - Class 文件中各个部分以及文件本身是否有被删除的或被附加的其它信息

（2）元数据验证
   对字节码描述的信息进行语义分析，以保证其描述的信息符合Java语言规范的要求，   主要是验证类的继承关系、数据类型是否符合

   等验证

准备：

   准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行分配

解析：

   解析阶段是虚拟机将常量池中的符号引用转化为直接引用的过程。
    - 符号引用（Symbolic References）：即用一组符号来描述所引用的目标。它与虚拟机的内存布局无关，引用的目标不一定已经加载到内存中。
    - 直接引用（Direct References）：直接引用可以是指向目标的指针、相对偏移量或是一个能间接定位到目标的句柄。它是和虚拟机内存布局相关的，如果有了直接引用，那引用的目标必定已经在内存中存在了。

初始化：

   而在初始化阶段，则会根据程序员的意愿给类变量和其他资源赋值。主要是通过<clinit>()方法来执行的：

    当初始化一个类的时候，如果发现其父类还没有进行过初始化、则需要先出发其父类的初始化
    .jvm启动时，用户指定一个执行的主类(包含main方法的那个类)，虚拟机会先初始化这个类

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

双亲委派模型要求除了顶层的启动类加载器，其余的类加载器都应该有自己的父类加载器。这里类加载器之间的父子关系一般不会以继承关系来实现，而是使用组合关系来复用父加载器的代码。
双亲委派模型的工作过程是：如果一个类加载器收到了类加载器的请求，它首先不会自己尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器中，只有当父类加载器反馈自己无法完成这个加载请求（它的搜索范围中没有找到所需的类时），子加载类才会尝试自己去加载。

操作系统
1. 进程和线程的区别。
2. 死锁的必要条件，怎么处理死锁。

什么是死锁？
如果一个进程集合里面的每个进程都在等待只能由这个集合中的其他一个进程（包括他自身）才能引发的事件，这种情况就是死锁。
这个定义可能有点拗口，下面用一个简单例子说明。
　　资源A、B，进程C、D描述如下：
　　资源A和资源B，都是不可剥夺资源，
　　现在进程C已经申请了资源A，进程D也申请了资源B，
　　进程C接下来的操作需要用到资源B，而进程D恰好也在申请资源A，
　　进程C、D都得不到接下来的资源，那么就引发了死锁。

       就是吃着碗里看着锅里
然后套用回去定义：如果一个进程集合里面（进程C和进 程D）的每个进程（进程C和进程D）都在等待只能由这个集合中的其他一个进程（对于进程C，他在等进程D；对于进程D，他在等进程C）才能引发的事件（释放相应资源）。
这里的资源包括了软的资源（代码块）和硬的资源（例如扫描仪）。资源一般可以分两种：可剥夺资源（Preemptable）和不可剥夺资源 （Nonpreemptable）。一般来说对于由可剥夺资源引起的死锁可以由系统的重新分配资源来解决，所以一般来说大家说的死锁都是由于不可剥夺资源 所引起的。
死锁的四个必要条件
  互斥条件（Mutual exclusion）：资源不能被共享，只能由一个进程使用。
  请求与保持条件（Hold and wait）：已经得到资源的进程可以再次申请新的资源。
  非剥夺条件（No pre-emption）：已经分配的资源不能从相应的进程中被强制地剥夺。
  循环等待条件（Circular wait）：系统中若干进程组成环路，该环路中每个进程都在等待相邻进程正占用的资源。
处理死锁的策略
1.忽略该问题。例如鸵鸟算法，该算法可以应用在极少发生死锁的的情况下。为什么叫鸵鸟算法呢，因为传说中鸵鸟看到危险就把头埋在地底下，可能鸵鸟觉得看不到危险也就没危险了吧。跟掩耳盗铃有点像。
2.检测死锁并且恢复。
3.仔细地对资源进行动态分配，以避免死锁。
4.通过破除死锁四个必要条件之一，来防止死锁产生。
3. Window 内存管理方式：段存储，页存储，段页存储。
4. 进程的几种状态。新建，可运行，运行，阻塞，死亡
5. IPC 几种通信方式。

# 管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。
# 有名管道 (named pipe) ： 有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。
# 信号量( semophore ) ： 信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
# 消息队列( message queue ) ： 消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。
# 信号 ( sinal ) ： 信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。
# 共享内存( shared memory ) ：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。
# 套接字( socket ) ： 套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同及其间的进程通信。
6. 什么是虚拟内存。

虚拟内存是什么 
首先大家要知道内存是什么。内存是内存储器的简称，我们的电脑在工作的时候正在执行的程序就是在这个里面的。内存的最大优点就是物美价廉，速度虽然比CPU寄存器要慢一点但是容量巨大，CPU寄存器的大小通常按MB甚至KB来计算，而内存呢已经按GB算了。不过虽然便宜那也是相对寄存器的天价来说的，比起硬盘来说还是贵不少的。内存的另一个特点是断电之后内存数据就没有了，所以我们还需要一个东西用来在断电或者程序不运行时保留数据，这个东西就是外存。外存的全称是外部存储器，常见的有硬盘，u盘，软盘，光盘等。 虚拟内存的作用 
而虚拟内存，顾名思义就是把不是内存的东西当内存用。实际上就是把外存当内存用。但是一个很严重的问题就是外存的速度相对于内存要缓慢的多，所以虚拟内存虽然在一定程度上增加了可用内存但是在总体上降低了内存响应速度。 
那么为什么要用虚拟内存？它有什么用呢？内存的大小直接决定我们的电脑可运行程序的多少，当运行的程序超过内存大小时系统会变卡。而虚拟内存的出现就在一定程度上扩展了内存的大小，让电脑能运行更多的程序。
7. 虚拟地址、逻辑地址、线性地址、物理地址的区别。
TCP/IP

0.http 和 socket 的区别，两个协议哪个更高效一点 ？

HTTP：超文本传输协议，首先它是一个协议，并且是基于TCP/IP协议基础之上的应用层协议。TCP/IP协议是传输层协议，主要解决数据如何在网络中传输，HTTP是应用层协议，主要解决如何包装数据。HTTP协议详细规定了浏览器与服务器之间相互通信的规则，是万维网交换信息的基础。HTTP是基于请求-响应形式并且是短连接，并且是无状态的协议。针对其无状态特性，在实际应用中又需要有状态的形式，因此一般会通过session/cookie技术来解决此问题。

Socket：Socket不属于协议范畴，而是一个调用接口（API），Socket是对TCP/IP协议的封装，通过调用Socket，才能使用TCP/IP协议。Socket连接是长连接，理论上客户端和服务器端一旦建立连接将不会主动断开此连接。Socket连接属于请求-响应形式，服务端可主动将消息推送给客户端。
1. OSI 与 TCP/IP 各层的结构与功能，都有哪些协议。
2. TCP 与 UDP 的区别。
3. TCP 报文结构。
4. TCP 的三次握手与四次挥手过程，各个状态名称与含义，TIMEWAIT 的作用。
5. TCP 拥塞控制。
6. TCP 滑动窗口与回退 N 针协议。7. Http 的报文结构。
8. Http 的状态码含义。
9. Http request 的几种类型。
10. Http1.1 和 Http1.0 的区别

HTTP 1.0规定浏览器与服务器只保持短暂的连接，浏览器的每次请求都需要与服务器建立一个TCP连接，服务器完成请求处理后立即断开TCP连接，服务器不跟踪每个客户也不记录过去的请求。

区别： 1，HTTP/1.0协议使用非持久连接,即在非持久连接下,一个tcp连接只传输一个Web对象,； 2，HTTP/1.1默认使用持久连接(然而,HTTP/1.1协议的客户机和服务器可以配置成使用非持久连接)。 在持久连接下,不必为每个Web对象的传送建立一个新的连接...
11. Http 怎么处理长连接。
12. Cookie 与 Session 的作用于原理。
13. 电脑上访问一个网页，整个过程是怎么样的：DNS、HTTP、TCP、OSPF、IP、
ARP。
14. Ping 的整个过程。ICMP 报文是什么。
15. C/S 模式下使用 socket 通信，几个关键函数。
16. IP 地址分类。
17. 路由器与交换机区别。
网络其实大体分为两块，一个 TCP 协议，一个 HTTP 协议，只要把这两块以及相关协
议搞清楚，一般问题不大。

数据结构与算法
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 个数.........等等

Android部分:
注册广播有哪几种方式,有什么区别
绘制 Activity 的生命流程图
注册Service需要注意什么
Service与Activity怎么实现通信
Handle通信具体到源码，是怎么实现的
Handle的机制
怎么实现ListView多种布局？
ListView与数据库绑定的实现
怎么实现一个部分更新的 ListView？

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

1..Adapter的getView方法里面convertView没有使用setTag和getTag方式；
2.在getView方法里面ViewHolder初始化后的赋值或者是多个控件的显示状态和背景的显示没有优化好，抑或是里面含有复杂的计算和耗时操作；
3.在getView方法里面 inflate的row 嵌套太深（布局过于复杂）或者是布局里面有大图片或者背景所致；
4.Adapter多余或者不合理的notifySetDataChanged；
5.listview 被多层嵌套，多次的onMessure导致卡顿，如果多层嵌套无法避免，建议把listview的高和宽设置为fill_parent. 如果是代码继承的listview，那么也请你别忘记为你的继承类添加上LayoutPrams，注意高和宽都是fill_parent的;

Android中的动画有哪些，区别是什么

补间动画和Frame动画的定义：
　　所谓补间动画，是指通过指定View的初末状态和变化时间、方式，对View的内容完成一系列的图形变换来实现动画效果。主要包括四种效果：Alpha、Scale、Translate和Rotate。
帧动画就是Frame动画，即指定每一帧的内容和停留时间，然后播放动画。。

JNI怎么使用
说说内存泄露的情况有哪些
OOM是怎么引起的？怎么尽量避免 OOM 问题的出现

什么是 ANR 问题？为什么会引起 ANR 问题？

无响应问题，如果你在activity中有进行耗时长的问题，就会产生这个问题。开个线程去处理耗时长的问题就可以了

1，主线程中处理耗时任务，2，频繁点击组件来不及响应

Socker编程的步骤
设计一个图片缓存加载机制
Fragment嵌套多个Fragment会出现bug吗
Activity中如何动态的添加Fragment。用FragmentManager，FragmentTransion
内存不足时，怎么保持Activity的一些状态，在哪个方法里面做具体操作？

Scrollview怎么判断是否滑倒底部

滚动到顶部判断:
getScrollY() == 0
滚动到底部判断:
View childView = getChildAt(0);
childView.getMeasuredHeight() <= getScrollY() + getHeight();
其中getChildAt表示得到ScrollView的child View
childView.getMeasuredHeight()表示得到子View的高度,
getScrollY()表示得到y轴的滚动距离，
getHeight()为scrollView的高度
getScrollY()达到最大时加上scrollView的高度就的就等于它内容的高度了.

ViewPager 的怎么做性能优化
Asynctask具体用法？
Asynctask的Do in background方法是怎么通知UI线程刷新进度条的？
Asynctask的Do in background方法默认是返回 true ，表示任务完成，如果想返回具体的数据呢，怎么做。如果Activity被销毁了，还会执行到postexcutd方法吗？
View中onTouch，onTouchEvent，onClick的执行顺序

不使用动画，怎么实现一个动态的 View？

使用Timer定时器可以实现简单的View的动画，或者使用线程操作

Postvalidata与Validata有什么区别？
Asset与raw都能存放资源，他们有什么区别？
如何自定义ViewGroup？
什么是 MVC 模式？MVC 模式的好处是什么？
JVM 和Dalvik虚拟机的区别
应用常驻后台，避免被第三方杀掉的方法，讲讲你用过的奇淫巧技？

数据持久化的四种方式有哪些？

json 传输数据有什么不好 ？http://www.cnblogs.com/SanMaoSpace/p/3139186.html
XML的缺点
　　A.XML文件庞大，文件格式复杂，传输占带宽；
　　B.服务器端和客户端都需要花费大量代码来解析XML，导致服务器端和客户端代码变得异常复杂且不易维护；
　　C.客户端不同浏览器之间解析XML的方式不一致，需要重复编写很多代码；

JSON的缺点
　　A.没有XML格式这么推广的深入人心和喜用广泛，没有XML那么通用性；
　　B.JSON格式目前在Web Service中推广还属于初级阶段。

1. Activity 与 Fragment 的生命周期。
2. Acitivty 的四中启动模式与特点。
3. Activity 缓存方法。
4. Service 的生命周期，两种启动方法，有什么区别。
5. 怎么保证 service 不被杀死。

onStartCommand方法，返回START_STICKY

提升service优先级

onDestroy方法里重启service：service +broadcast 方式，就是当service走ondestory的时候，发送一个自定义的广播，当收到广播的时候，重新启动service
6. 广播的两种注册方法，有什么区别。

区别：
     在AndroidManifest中进行注册后，不管改应用程序是否处于活动状态，都会进行监听，比如某个程序时监听 内存的使用情况的，当在手机上安装好后，不管改应用程序是处于什么状态，都会执行改监听方法中的内容。
      在代码中进行注册后，当应用程序关闭后，就不再进行监听。我们读知道，应用程序是否省电，决定了该应用程序的受欢迎程度，所以，对于那些没必要在程序关闭后仍然进行监听的Receiver，在代码中进行注册，无疑是一个明智的选择

7. Intent 的使用方法，可以传递哪些数据类型。
8. ContentProvider 使用方法。
9. Thread、AsycTask、IntentService 的使用场景与特点。
10. 五 种 布 局 ： FrameLayout 、 LinearLayout 、 AbsoluteLayout 、
RelativeLayout 、 TableLayout 各自特点及绘制效率对比。
11. Android 的数据存储形式。
12. Sqlite 的基本操作。
13. Android 中的 MVC 模式。

Android中MVC的理解：
(1).视图层（view）：一般采用xml文件进行界面的描述，使用的时候可以非常方便的引入，当然，如何你对android了解的比较的多了话，就一定可以想到在android中也可以使用javascript+html等的方式作为view层，当然这里需要进行java和javascript之间的通信，幸运的是，android提供了它们之间非常方便的通信实现。
(2).控制层（controller）：android的控制层的重任通常落在了众多的acitvity的肩上，这句话也就暗含了不要在acitivity中写代码，要通过activity交割model业务逻辑层处理，这样做的另外一个原因是android中的acitivity的响应时间是5s，如果耗时的操作放在这里，程序就很容易被回收掉。
(3).模型层（model）：对数据库的操作、对网络等的操作都应该在model里面处理，当然对业务计算等操作也是必须放在该层的。
总的概述如下：
model是对数据的处理、操作、访问。
view是显示数据的。
Activity在中间起了组织的作用。
14. Merge、ViewStub 的作用。
15. Json 有什么优劣势。
16. 动画有哪两类，各有什么特点？
17. Handler、Loop 消息队列模型，各部分的作用。
18. 怎样退出终止 App。
19. Asset 目录与 res 目录的区别。

一、assets目录下的资源文件不会在R.Java自动生成ID，所以读取assets目录下的文件必须指定文件的路径。

二，assets目录下可以访问子目录，只需要相对路径和文件名就能访问

三，assets目录是原生资源，对原生资源就要使用出入输出流来读写

1. assets目录

AssetManager a = getAssets()  ;//fileName为assets目录下需要访问的文件的名称InputStream is = a.open(fileName) ;//然后就可以通过输入流来读取fileName的内容了。

2. res/raw目录

InputStream is = getResources().openRawResource(R.id.fileNameID) ;//R.id.fileNameID为需要访问的文件对应的资源ID.接着我们就可以通过输入流来读取相应文件的内容了

20. Android 怎么加速启动 Activity。
21. Android 内存优化方法：ListView 优化，及时关闭资源，图片缓存等等。
22. Android 中弱引用与软引用的应用场景。HashMap的图片缓存
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 新特性

数据结构与算法部分：
给最外层的rootview，把这个根视图下的全部button背景设置成红色，手写代码，不许用递归
给一串字符串比如abbbcccd，输出a1b3c3d1，手写代码（注意有个别字符可能会出现十次以上的情况）
一个序列，它的形式是12349678，9是最高峰，经历了一个上升又下降的过程，找出里面的最大值的位置，要求效率尽可能高
二叉查找树的删除操作，手写代码
反转链表，手写代码
二分查找，手写代码
有海量条 url，其中不重复的有300万条，现在希望挑选出重复出现次数最高的 url，要求效率尽可能的高
一篇英语文章，去掉字符只留下k个，如何去掉才能使这k个字符字典序最小
弗洛伊德算法和 Dijkstra算法的区别？复杂度是多少？讲讲 Dijkstra算法的具体过程
反转字符串，要求手写代码，优化速度、优化空间
给出两个无向图，找出这2个无向图中相同的环路。手写代码
单例模式，手写代码
生产者与消费者，手写代码
二叉树镜像，手写代码
最长不重复子串（最长重复子串），手写代码

操作系统部分：
分别从操作系统的内存角度与进程线程角度解释分析堆，栈二者的区别
什么是事务？
OSI七层模型有哪些，各层次的作用
TCP的三次握手过程，四次挥手过程，为什么需要三次？
说说操作系统中进程的通信方式
浏览器输入地址之后，之后的过程
谈谈 HTTP 中Get 和 Post 方法的区别？