Android校招复习全书（1）-j2se

一、九种基本数据类型的大小，以及他们的封装类

关于JAVA基本数据类型

名称	解释	长度（位）	默认值	封装类
byte	字节	8	0	Byte
shot	短整型	16	0	Short
int	整型	32	0	Integer
long	长整型	64	0	Long
float	浮点型	32	0.0f	Float
double	双精度	64	0.0d	Double
char	字符型	16	‘\u0000’	Character
boolean	布尔型	1	false	Boolean
void

操作系统16位的时候，int 2字节，操作系统32位的时候，int 4字节，由于32位系统之前占主流地位，实际现在就算是64位系统，出于兼容性考虑，int也是4字节的。
Java的类型分成两种，一种是基本类型，一种是引用类型。两种的本质区别就是：基本类型是在堆栈处分配空间存“值”。但是引用类型，是在堆里面分配空间存“值”。Void是不能new出来，也就是不能在堆里面分配空间存对应的值。那就是一开始在堆栈处分配好空间了。所以，有些人将Void归成基本类型，也有道理。

二、Switch能否用string做参数？

• JDK1.7之前不能用，JDK1.7后可以用。
• switch后面的括号里面只能放int类型的值，但由于byte，short，char类型，它们会 自动 转换为int类型（精精度小的向大的转化），所以它们也支持。
• 我们也可以用枚举类型实现switch可传入string参数。

三、equals与==的区别

前者比较值，后者比较在内存中地址的位置。
String比较特殊重写了equals方法

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

如果自定义的类重写了equals值，用于比较值相同，一定要重写hashcode方法，因为在HashSet/HashMap/HashTable进行查重比较的时候，用于hashcode

四、Object有哪些公用方法？

1.protected Object clone()创建并返回此对象的一个副本。

1)浅复制和深复制的概念

 浅复制：被复制的对象的所有变量都与原来的对象有相同的值，但是指向的引用的对象相同，即地址相同，操作一个对象，另一个也会改变。
 深复制：被复制的对象的所有变量都与原来的对象有相同的值，但是复制了引用的对象不相同，即地址不同，操作一个对象，另一个不会改变。

2)Java的clone()方法

package com.li;
public class Test4
{
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        Student s1 = new Student("zhangsan", 12);
        Student s2 = (Student) s1.clone();
        s2.name="lisi";    
        s2.age=20;   
        System.out.println("name="+s1.name+","+"age="+s1.age);//   name=zhangsan,age=12
    }
}

class Student implements Cloneable
{
    String name;    
    int age;    
    Student(String name,int age)    
    {    
       this.name=name;    
       this.age=age;    
    }    

    @Override
    protected Object clone()
    {
        Object o = null;
        try
        {
            o = (Student)super.clone();
            return o;
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        return o;
    }
}

①为什么我们在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。
②继承自java.lang.Object类的clone()方法是浅复制。以下代码可以证明之。

package com.li;

public class Test4
{
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        Professor p = new Professor("jiaoshou",50);
        Student s1 = new Student("li", 20, p);
        Student s2 = (Student) s1.clone();
        s2.p.name = "jiaoshou2";
        s2.p.age = 55;
        //如果加了注释输出：name=jiaoshou2,age=55
        System.out.println("name="+s1.p.name+","+"age="+s1.p.age);
        //如果不加注释输出：name=jiaoshou,age=50
    }
}

class Professor implements Cloneable
{
    String name;
    int age;
    public Professor(String name, int age)
    {
        this.name = name;
        this.age = age;
    }
    /*
    @Override
    protected Object clone()
    {
        Professor o = null;
        try
        {
            o = (Professor) super.clone();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return o;
    }*/
}

class Student implements Cloneable
{
    String name;
    int age;
    Professor p;
    public Student(String name, int age, Professor p)
    {
        this.name=name;    
        this.age=age;    
        this.p=p; 
    }

    @Override
    protected Object clone()
    {
        Student o = null;
        try
        {
            o = (Student) super.clone();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        /*o.p = (Professor) p.clone();*/
        return o;
    }
}

2. boolean equals(Object obj)指示其他某个对象是否与此对象“相等”。

3. protected void finalize()当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

C++析构函数和Java的finalize()方法不一样。前者是在对象消亡时运行，如果是自己new，即在堆中申请的内存，需要自己手动delete，所以析构函数中经常做一些文件保存之类的收尾工作；后者在Java中很不幸，如果内存总是充足的，那么垃圾回收可能永远不会进行，也就是说filalize()可能永远不被执行，显然指望它做收尾工作是靠不住的，它最主要的用途是回收特殊渠道申请的内存。Java程序有垃圾回收器，所以一般情况下内存问题不用程序员操心。但有一种JNI(Java Native Interface)调用non-Java程序（C或C++），finalize()的工作就是回收这部分的内存。

4. Class getClass() 返回此 Object 的运行时类。

5. int hashCode() 返回该对象的哈希码值。

6. void notify() 唤醒在此对象监视器上等待的单个线程。

7. void notifyAll() 唤醒在此对象监视器上等待的所有线程。

8. String toString() 返回该对象的字符串表示。

public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

9. void wait() 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。

10. void wait(long timeout) 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。

11. void wait(long timeout, int nanos) 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量前，导致当前线程等待。

//以纳秒为单位进行精确控制
public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0) {
            timeout++;
        }

        wait(timeout);
    }

五、Java的四种引用，强软弱虚，用到的场景。

1.强引用

以前我们使用的大部分引用实际上都是强引用，这是使用最普遍的引用。如果一个对象具有强应用，那就类似必不可少的生活用品，垃圾回收器绝不会回收它。当内存空间不足，jvm宁愿跑出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。

2.软引用（SoftReference）

如果一个对象具有软引用，类似与生活可有可无的生活用品。如果内存足，GC就不会回收，如果不足，GC就会回收。软引用可以用来实现内存敏感的高速缓存。软引用可以和一个引用队列联合使用，如果软引用所引用的对象被GC回收，JVM就会把这个软引用加入到与之关联的引用队列中。

3.弱引用（WeakReference）

如果一个对象具有软引用，类似与生活可有可无的生活用品。与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在GC线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存足够与否，都会回收它的内存。不过，由于GC是个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。弱引用可以和一个引用队列联合使用，如果弱引用所引用的对象被GC回收，JVM就会把这个弱引用加入到与之关联的引用队列中。

4.虚引用（PhantomReference）

如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用以及弱引用的区别在于：虚引用必须和引用队列联合使用。当GC准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

package com.li;
import java.lang.ref.SoftReference;

//软引用实例代码
public class Test4
{
    public static void main(String[] args)
    {
        A a = new A();
        SoftReference<A> sr = new SoftReference<A>(a);
        a = null;
        if(sr != null)
        {    
            a = sr.get();
        }
        else
        {
            a = new A();
            sr = new SoftReference<A>(a);
        }
    }
}
class A{
    int[] a ;
    public A(){
        a = new int[100000000];
    }
}

六、Hashcode的作用。

• hashCode的存在主要是用于查找的快捷性，如Hashtable，HashMap等，hashCode是用来在散列存储结构中确定对象的存储地址的；
• 如果两个对象相同，就是适用于equals(java.lang.Object) 方法，那么这两个对象的hashCode一定要相同；
• 如果对象的equals方法被重写，那么对象的hashCode也尽量重写，并且产生hashCode使用的对象，一定要和equals方法中使用的一致，否则就会违反上面提到的第2点；
• 两个对象的hashCode相同，并不一定表示两个对象就相同，也就是不一定适用于equals(java.lang.Object) 方法，只能够说明这两个对象在散列存储结构中，如Hashtable，他们“存放在同一个篮子里”。
• 以下代码证明，先比较hash，如果hash相同比较equals。自己敲一遍，事半功倍。

package com.li;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;

public class Test6
{
    public static void main(String[] args)
    {
        Test6 a = new Test6();
        a.SetI(1);
        Test6 b = new Test6();
        b.SetI(1);
        Set<Test6> set = new HashSet<Test6>();
        set.add(a);
        System.out.println("----------");
        set.add(b);
        System.out.println("----------");
        System.out.println(set.toString());//默认调用toString方法，toString()源码调用了hashCode()
        /*输出
        hashcode
        ----------
        hashcode
        equlas
        ----------
        hashcode
        [com.li.Test6@1]
        */
    }
    public int i;

    public int getI()
    {
        return i;
    } 
    public void SetI(int i)
    {
        this.i = i;
    }
    public int hashCode()
    {
        System.out.println("hashcode");
        return i%10;   
    }
    public boolean equals(Object object) {  
        System.out.println("equlas");
        if (object == null) {  
            return false;  
        }  
        if (object == this) {  
            return true;  
        }  
        if (!(object instanceof Test6)) {  
            return false;  
        }  
        Test6 other = (Test6) object;  
        if (other.getI() == this.getI()) {  
            return true;  
        }  
        return false;  
    }
}

七、ArrayList、LinkedList、Vector的区别。

1.ArrayList

以下代码来自1.8Jdk的ArrayList.java源码

    /**
     * Default initial capacity.
     * 默认数组初始容量大小为10
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * The size of the ArrayList (the number of elements it contains).
     * 数组里面实际元素的个数
     * @serial
     */
    private int size;

    /**
     * 最大容量
     * The maximum size of array to allocate.
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /**
    * 记录操作次数，快速失败机制，在迭代器中使用，remove抛出异常
    */
    protected transient int modCount = 0;

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!增加一个
        elementData[size++] = e;
        return true;
    }

    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    /**
    * 实现自增的核心代码，1.5倍递增
    */
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

2.Vector

以下代码来自1.8Jdk的Vector.java源码

    /**
    * 实现自增的核心代码，2.0倍递增
    */
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    /**
    * 主要区别，使用了synchronized修饰，线程安全
    */
    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

3.LinkedList

以下代码来自1.8Jdk的LinkedList.java源码

    /**
    * 私有内部类。用于链表操作
    */
    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

总：
时间复杂度：ArrayList、Vector都为动态数组，LinkedList为链表。前者适合查找，后者适合修改删除。
空间复杂度：ArrayList开辟1.5倍、Vector开辟2.0倍，LinkedList每增加一个多一个内部类对象。前两者可以使用trimToSize()方法将多余的空间删除。
线程安全性：ArrayList、LinkedList不安全，但是可以自己实现线程安全。Vector线程安全。

八、String、StringBuffer与StringBuilder的区别。

String使用+""会创建一个新的对象，StringBuffer是线程安全的，使用append在一个对象进行修改，StringBuilder是1.5之后出现的，和StringBuffer基本一样，只是它不是线程安全的。

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

十、HashMap和HashTable的区别。

• 前者是线程非安全的，并能传递null作为键值对。内部维护了一个链表，通过数组和链表进行存储
• 后者是线程安全的，不能传递null作为键值对。
• 参考：http://www.importnew.com/7099.html

十一、HashMap和ConcurrentHashMap的区别，HashMap的底层源码。

以下是Jdk1.8的HashMap.java源码

    /**默认大小16
     * The default initial capacity - MUST be a power of two.
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

    /**最大容量 <= 1<<30
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**默认装载因子
     * The load factor used when none specified in constructor.
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

十二、 TreeMap、HashMap、LindedHashMap的区别。

十三、Collection包结构，与Collections的区别。

十四、try catch finally，try里有return，finally还执行么？

public class HelloJ {
    public static void  main(String[] args)
    {
        int i = g();
        System.out.println(i);
        /*输出
          ---
          1
        */
    }
    static int g(){
        int i = 0;
        try{
            return i++;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            System.out.println("---");
            return i++;
        }
    }
}

十五、Excption与Error包结构。OOM你遇到过哪些情况，SOF你遇到过哪些情况。

参考：http://www.mamicode.com/info-detail-1091344.html

十六、Java面向对象的三个特征与含义。