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 {
        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 task = new FutureTask(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能否转为List