Java面试（1）

一、Java基础

什么是字符串常量池？

Java中的字符串常量池（String Pool）是存储在Java堆内存中的字符串池；

String是java中比较特殊的类，我们可以使用new运算符创建String对象，也可以用双引号（”“）创建字串对象。

如果池中没有字符串字面量“Cat”，那么首先在池中创建，然后在堆空间中创建，因此将创建总共2个字符串对象。

之所以有字符串常量池，是因为String在Java中是不可变（immutable）的，它是String interning概念的实现。字符串常量池也是亨元模式（Flyweight）的实例。

字符串常量池有助于为Java运行时节省大量空间，虽然创建字符串时需要更多的时间。

当我们使用双引号创建一个字符串时，首先在字符串常量池中查找是否有相同值的字符串，如果发现则返回其引用，否则它会在池中创建一个新的字符串，然后返回新字符串的引用。

如果使用new运算符创建字符串，则会强制String类在堆空间中创建一个新的String对象。我们可以使用intern()方法将其放入字符串常量池或从字符串常量池中查找具有相同的值字符串对象并返回其引用

String为什么是不可变的？

value，offset和count这三个变量都是private的，并且没有提供setValue， setOffset和setCount等公共方法来修改这些值，所以在String类的外部无法修改String。也就是说一旦初始化就不能修改， 并且在String类的外部不能访问这三个成员。此外，value，offset和count这三个变量都是final的， 也就是说在String类内部，一旦这三个值初始化了， 也不能被改变。所以可以认为String对象是不可变的了。 
那么在String中，明明存在一些方法，调用他们可以得到改变后的值。这些方法包括substring， replace， replaceAll， toLowerCase等。例如如下代码：

String a = "ABCabc";
System.out.println("a = " + a);
a = a.replace('A', 'a');
System.out.println("a = " + a);

那么a的值看似改变了，其实也是同样的误区。再次说明， a只是一个引用， 不是真正的字符串对象，在调用a.replace('A', 'a')时， 方法内部创建了一个新的String对象，并把这个心的

对象重新赋给了引用a。String中replace方法的源码可以说明问题

String s = new String("xyz");究竟产生了几个对象，从JVM角度谈谈

答：一个或者两个；

声明：s不是对象，不是对象，不是对象，s是指针引用

判断  ：

if（"xyz"在常量池中存在）{

          只会在堆中创建一个new String("xyz") ；一个对象

} else {

            会现在常量池中创建一个“xyz”,然后在堆中创建一个new String("xyz")；两个对象

}

String拼接字符串效率低，你知道原因吗？

如果在循环体中用 “+” 拼接字符串，每次循环都会new一个StringBuilder；而在循环体外面先把StringBuilder创建出来，循环体中就不用每次都new一个了；所以在循环体中用 “+” 拼接字符串效率慢；

public class StringAdd {

    /**
    public static void f1();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, locals=2, args_size=0
         0: ldc           #19                 // String
         2: astore_0
         3: iconst_0
         4: istore_1
         5: goto          31
         8: new           #21                 // class java/lang/StringBuilder
        11: dup
        12: aload_0
        13: invokestatic  #23                 // Method java/lang/String.valueOf:(Ljava/lang/Object;)Ljava/lang/String;
        16: invokespecial #29                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V   new StringBuilder（src）
        19: ldc           #32                 // String A
        21: invokevirtual #34                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        24: invokevirtual #38                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        27: astore_0
        28: iinc          1, 1
        31: iload_1
        32: bipush        10
        34: if_icmplt     8
        37: getstatic     #42                 // Field java/lang/System.out:Ljava/io/PrintStream;
        40: aload_0
        41: invokevirtual #48                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        44: return
     * */
    public static void f1() {
        String src = "";
        for(int i=0;i<10;i++) {
            //每一次循环都会new一个StringBuilder
            src = src + "A";
        }
        System.out.println(src);
    }

    public static void f2() {
        //只要一个StringBuilder
        StringBuilder src = new StringBuilder();
        for(int i=0;i<10;i++) {
            src.append("A");
        }
        System.out.println(src);
    }

    public static void main(String[] args) {
    }
}

你真的了解String的常见API吗

String是我们开发中使用频率最高的类，它有哪些方法，大家一定不会陌生，例如：

length();//计算字符串的长度

charAt();//截取一个字符

getChars();//截取多个字符

equals();//比较两个字符串

equalsIgnoreCase();//比较两个字符串,忽略大小写

startsWith();//startsWith()方法决定是否以特定字符串开始

endWith();//方法决定是否以特定字符串结束

indexOf();//查找字符或者子串第一次出现的地方。

lastIndexOf();//查找字符或者子串是后一次出现的地方。

substring();//截取字符串

concat();//连接两个字符串

replace();//替换

trim();//去掉起始和结尾的空格

valueOf();//转换为字符串

toLowerCase();//转换为小写

toUpperCase();// 转换为大写

但是像replace()，substring()，toLowerCase()这三个方法需要注意一下，我们看下下面一段代码：

import java.util.*;
public class StringTest {
     public static void main(String[] args){
      String ss = "123456";
      System.out.println("ss = " + ss);
      ss.replace('1', '0');
      System.out.println("ss = " + ss);
      }
}
打印结果：

ss = 123456
ss = 123456
如果你不了解replace方法的源码，可能会认为最后的打印结果为 "ss = 023456"，但是实际上方法内部创建了一个新的String对象，并将这个新的String对象返回。对ss是没有做任何操作的，我们也知道String是不可变的嘛。源码如下：

public String replace(char oldChar, char newChar) {
    // 判断替换字符和被替换字符是否相同
    if (oldChar != newChar) {
        int len = value.length;
        int i = -1;
        // 将源字符串转换为字符数组
        char[] val = value; /* avoid getfield opcode */
        while (++i < len) {
           // 判断第一次被替换字符串出现的位置
            if (val[i] == oldChar) {
                break;
            }
        }
        // 从出现被替换字符位置没有大于源字符串长度
        if (i < len) {
            char buf[] = new char[len];
            for (int j = 0; j < i; j++) {
                // 将源字符串，从出现被替换字符位置前的字符将其存放到字符串数组中
                buf[j] = val[j];
            }
            while (i < len) {
                char c = val[i];
                // 开始进行比较；如果相同的字符串替换，如果不相同按原字符串
                buf[i] = (c == oldChar) ? newChar : c;
                i++;
            }
            // 使用String的构造方法进行重新创建String
            return new String(buf, true);
        }
    }
    return this;
}
方法内部最后重新创建新的String对象，并且返回这个新的对象，原来的对象是不会被改变的。substring()，toLowerCase()方法也是如此。

还有诸如contact()方法，源码如下：

public String concat(String str) {
    int otherLen = str.length();
    if (otherLen == 0) {
        return this;
    }
    int len = value.length;
    char buf[] = Arrays.copyOf(value, len + otherLen);
    str.getChars(buf, len);
    return new String(buf, true);
}
从上可知参数str不能为null，否则就会包空指针异常。用contact()拼接字符串速度也很快，因为直接Arrays.copyOf，直接内存复制。

Java中的subString()真的会引起内存泄露么？

JVM提供了内存管理机制，有垃圾回收器帮助回收不需要的对象。但实际中一些不当的使用仍然会导致一系列的内存问题，常见的就是内存泄漏和内存溢出

内存溢出（out of memory ）：通俗的说就是内存不够用了，比如在一个无限循环中不断创建一个大的对象，很快就会引发内存溢出。

内存泄漏（leak of memory）：是指为一个对象分配内存之后，在对象已经不在使用时未及时的释放，导致一直占据内存单元，使实际可用内存减少，就好像内存泄漏了一样。

1、substring的作用

substring(int beginIndex, int endIndex)方法返回一个子字符串,从父字符串的beginIndex开始，结束于endindex-1。父字符串的下标从0开始，子字符串包含beginIndex而不包含endIndex。

String x= "abcdef";
x= str.substring(1,3);
System.out.println(x);
上述程序的输出是“bc”

2、实现原理

String类是不可变变，当上述第二句中x被重新赋值的时候，它会指向一个新的字符串对象，就像下面的这幅图所示：

然而，这幅图并没有准确说明的或者代表堆中发生的实际情况，当substring被调用的时候真正发生的才是这两者的差别。

JDK6中的substring实现

String对象被当作一个char数组来存储，在String类中有3个域：char[] value、int offset、int count，分别用来存储真实的字符数组，数组的起始位置，String的字符数。由这3个变量就可以决定一个字符串。当substring方法被调用的时候，它会创建一个新的字符串，但是上述的char数组value仍然会使用原来父数组的那个value。父数组和子数组的唯一差别就是count和offset的值不一样，下面这张图可以很形象的说明上述过程。

看一下JDK6中substring的实现源码：

public String substring(int beginIndex, int endIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    if (endIndex > count) {
        throw new StringIndexOutOfBoundsException(endIndex);
    }
    if (beginIndex > endIndex) {
        throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
    }
    return ((beginIndex == 0) && (endIndex == count)) ? this :
        new String(offset + beginIndex, endIndex - beginIndex, value); //使用的是和父字符串同一个char数组value
    }

String(int offset, int count, char value[]) {
    this.value = value;
    this.offset = offset;
    this.count = count;
    }

由此引发的内存泄漏泄漏情况：

String str = "abcdefghijklmnopqrst";
String sub = str.substring(1, 3);
str = null;
这段简单的程序有两个字符串变量str、sub。sub字符串是由父字符串str截取得到的，假如上述这段程序在JDK1.6中运行，我们知道数组的内存空间分配是在堆上进行的，那么sub和str的内部char数组value是公用了同一个，也就是上述有字符a~字符t组成的char数组，str和sub唯一的差别就是在数组中其实beginIndex和字符长度count的不同。在第三句，我们使str引用为空，本意是释放str占用的空间，但是这个时候，GC是无法回收这个大的char数组的，因为还在被sub字符串内部引用着，虽然sub只截取这个大数组的一小部分。当str是一个非常大字符串的时候，这种浪费是非常明显的，甚至会带来性能问题，解决这个问题可以是通过以下的方法：

String str = "abcdefghijklmnopqrst";
String sub = str.substring(1, 3) + "";
str = null;

利用的就是字符串的拼接技术，它会创建一个新的字符串，这个新的字符串会使用一个新的内部char数组存储自己实际需要的字符，这样父数组的char数组就不会被其他引用，令str=null，在下一次GC回收的时候会回收整个str占用的空间。但是这样书写很明显是不好看的，所以在JDK7中，substring 被重新实现了。

JDK7中的substring实现

在JDK7中改进了substring的实现，它实际是为截取的子字符串在堆中创建了一个新的char数组用于保存子字符串的字符。下面的这张图说明了JDK7中substring的实现过程：

查看JDK7中String类的substring方法的实现源码：

public String substring(int beginIndex, int endIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        if (endIndex > value.length) {
            throw new StringIndexOutOfBoundsException(endIndex);
        }
        int subLen = endIndex - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return ((beginIndex == 0) && (endIndex == value.length)) ? this
                : new String(value, beginIndex, subLen);
    }

public String(char value[], int offset, int count) {
        if (offset < 0) {
            throw new StringIndexOutOfBoundsException(offset);
        }
        if (count < 0) {
            throw new StringIndexOutOfBoundsException(count);
        }
        // Note: offset or count might be near -1>>>1.
        if (offset > value.length - count) {
            throw new StringIndexOutOfBoundsException(offset + count);
        }
        this.value = Arrays.copyOfRange(value, offset, offset+count);
    }

Arrays类的copyOfRange方法：

public static char[] copyOfRange(char[] original, int from, int to) {
        int newLength = to - from;
        if (newLength < 0)
            throw new IllegalArgumentException(from + " > " + to);
        char[] copy = new char[newLength];   //是创建了一个新的char数组
        System.arraycopy(original, from, copy, 0,
                         Math.min(original.length - from, newLength));
        return copy;
    }

可以发现是去为子字符串创建了一个新的char数组去存储子字符串中的字符。这样子字符串和父字符串也就没有什么必然的联系了，当父字符串的引用失效的时候，GC就会适时的回收父字符串占用的内存空间。

浅析Java中的final关键字？

　在Java中，final关键字可以用来修饰类、方法和变量（包括成员变量和局部变量）。下面就从这三个方面来了解一下final关键字的基本用法。

　　1.修饰类

　　当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。

　　在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。

　　2.修饰方法

　　下面这段话摘自《Java编程思想》第四版第143页：

　　“使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。“

　　因此，如果只有在想明确禁止 该方法在子类中被覆盖的情况下才将方法设置为final的。

　　注：类的private方法会隐式地被指定为final方法。

　　3.修饰变量

　　修饰变量是final用得最多的地方，也是本文接下来要重点阐述的内容。首先了解一下final变量的基本语法：

　　对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。

　　举个例子：

　　

　　上面的一段代码中，对变量i和obj的重新赋值都报错了。

二.深入理解final关键字
　　在了解了final关键字的基本用法之后，这一节我们来看一下final关键字容易混淆的地方。

1.类的final变量和普通变量有什么区别？

　　当用final作用于类的成员变量时，成员变量（注意是类的成员变量，局部变量只需要保证在使用之前被初始化赋值即可）必须在定义时或者构造器中进行初始化赋值，而且final变量一旦被初始化赋值之后，就不能再被赋值了。

　　那么final变量和普通变量到底有何区别呢？下面请看一个例子：
public class Test {
    public static void main(String[] args)  {
        String a = "hello2";
        final String b = "hello";
        String d = "hello";
        String c = b + 2;
        String e = d + 2;
        System.out.println((a == c));
        System.out.println((a == e));
    }
}
　　

　　大家可以先想一下这道题的输出结果。为什么第一个比较结果为true，而第二个比较结果为fasle。这里面就是final变量和普通变量的区别了，当final变量是基本数据类型以及String类型时，如果在编译期间能知道它的确切值，则编译器会把它当做编译期常量使用。也就是说在用到该final变量的地方，相当于直接访问的这个常量，不需要在运行时确定。这种和C语言中的宏替换有点像。因此在上面的一段代码中，由于变量b被final修饰，因此会被当做编译器常量，所以在使用到b的地方会直接将变量b 替换为它的  值。而对于变量d的访问却需要在运行时通过链接来进行。想必其中的区别大家应该明白了，不过要注意，只有在编译期间能确切知道final变量值的情况下，编译器才会进行这样的优化，比如下面的这段代码就不会进行优化：

public class Test {
    public static void main(String[] args)  {
        String a = "hello2";
        final String b = getHello();
        String c = b + 2;
        System.out.println((a == c));

    }

    public static String getHello() {
        return "hello";
    }
}
　　这段代码的输出结果为false。

2.被final修饰的引用变量指向的对象内容可变吗？

　　在上面提到被final修饰的引用变量一旦初始化赋值之后就不能再指向其他的对象，那么该引用变量指向的对象的内容可变吗？看下面这个例子：
public class Test {
    public static void main(String[] args)  {
        final MyClass myClass = new MyClass();
        System.out.println(++myClass.i);

    }
}

class MyClass {
    public int i = 0;
}
　　这段代码可以顺利编译通过并且有输出结果，输出结果为1。这说明引用变量被final修饰之后，虽然不能再指向其他对象，但是它指向的对象的内容是可变的。

3.final和static

　　很多时候会容易把static和final关键字混淆，static作用于成员变量用来表示只保存一份副本，而final的作用是用来保证变量不可变。看下面这个例子：
public class Test {
    public static void main(String[] args)  {
        MyClass myClass1 = new MyClass();
        MyClass myClass2 = new MyClass();
        System.out.println(myClass1.i);
        System.out.println(myClass1.j);
        System.out.println(myClass2.i);
        System.out.println(myClass2.j);

    }
}

class MyClass {
    public final double i = Math.random();
    public static double j = Math.random();
}
　　运行这段代码就会发现，每次打印的两个j值都是一样的，而i的值却是不同的。从这里就可以知道final和static变量的区别了。

4.匿名内部类中使用的外部局部变量为什么只能是final变量？

　　这个问题请参见上一篇博文中《Java内部类详解》中的解释，在此处不再赘述。

5.关于final参数的问题

　　关于网上流传的”当你在方法中不需要改变作为参数的对象变量时，明确使用final进行声明，会防止你无意的修改而影响到调用方法外的变量“这句话，我个人理解这样说是不恰当的。

　　因为无论参数是基本数据类型的变量还是引用类型的变量，使用final声明都不会达到上面所说的效果。

　　看这个例子就清楚了：

　　上面这段代码好像让人觉得用final修饰之后，就不能在方法中更改变量i的值了。殊不知，方法changeValue和main方法中的变量i根本就不是一个变量，因为java参数传递采用的是值传递，对于基本类型的变量，相当于直接将变量进行了拷贝。所以即使没有final修饰的情况下，在方法内部改变了变量i的值也不会影响方法外的i。

　　再看下面这段代码：
public class Test {
    public static void main(String[] args)  {
        MyClass myClass = new MyClass();
        StringBuffer buffer = new StringBuffer("hello");
        myClass.changeValue(buffer);
        System.out.println(buffer.toString());
    }
}

class MyClass {

    void changeValue(final StringBuffer buffer) {
        buffer.append("world");
    }
}
　　运行这段代码就会发现输出结果为 helloworld。很显然，用final进行修饰并没有阻止在changeValue中改变buffer指向的对象的内容。有人说假如把final去掉了，万一在changeValue中让buffer指向了其他对象怎么办。有这种想法的朋友可以自己动手写代码试一下这样的结果是什么，如果把final去掉了，然后在changeValue中让buffer指向了其他对象，也不会影响到main方法中的buffer，原因在于java采用的是值传递，对于引用变量，传递的是引用的值，也就是说让实参和形参同时指向了同一个对象，因此让形参重新指向另一个对象对实参并没有任何影响。

浅析Java中的static关键字？

方便在没有创建对象的情况下来进行调用（方法/变量）。

　　很显然，被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

　　static可以用来修饰类的成员方法、类的成员变量，另外可以编写static代码块来优化程序性能。

1）static方法

　　static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。

　　但是要注意的是，虽然在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法/变量的。举个简单的例子：

　　在上面的代码中，由于print2方法是独立于对象存在的，可以直接用过类名调用。假如说可以在静态方法中访问非静态方法/变量的话，那么如果在main方法中有下面一条语句：

　　MyObject.print2();

　　此时对象都没有，str2根本就不存在，所以就会产生矛盾了。同样对于方法也是一样，由于你无法预知在print1方法中是否访问了非静态成员变量，所以也禁止在静态成员方法中访问非静态成员方法。

　　而对于非静态成员方法，它访问静态成员方法/变量显然是毫无限制的。

　　因此，如果说想在不创建对象的情况下调用某个方法，就可以将这个方法设置为static。我们最常见的static方法就是main方法，至于为什么main方法必须是static的，现在就很清楚了。因为程序在执行main方法的时候没有创建任何对象，因此只有通过类名来访问。

　　另外记住，关于构造器是否是static方法可参考：http://blog.csdn.net/qq_17864929/article/details/48006835

2）static变量

　　static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

　　static成员变量的初始化顺序按照定义的顺序进行初始化。

3）static代码块

　　static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

　　为什么说static块可以用来优化程序性能，是因为它的特性:只会在类加载的时候执行一次。下面看个例子:
class Person{
    private Date birthDate;

    public Person(Date birthDate) {
        this.birthDate = birthDate;
    }

    boolean isBornBoomer() {
        Date startDate = Date.valueOf("1946");
        Date endDate = Date.valueOf("1964");
        return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
    }
}
　　isBornBoomer是用来这个人是否是1946-1964年出生的，而每次isBornBoomer被调用的时候，都会生成startDate和birthDate两个对象，造成了空间浪费，如果改成这样效率会更好：
class Person{
    private Date birthDate;
    private static Date startDate,endDate;
    static{
        startDate = Date.valueOf("1946");
        endDate = Date.valueOf("1964");
    }

    public Person(Date birthDate) {
        this.birthDate = birthDate;
    }

    boolean isBornBoomer() {
        return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;
    }
}
　　因此，很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。

二.static关键字的误区
1.static关键字会改变类中成员的访问权限吗？

　　有些初学的朋友会将java中的static与C/C++中的static关键字的功能混淆了。在这里只需要记住一点：与C/C++中的static不同，Java中的static关键字不会影响到变量或者方法的作用域。在Java中能够影响到访问权限的只有private、public、protected（包括包访问权限）这几个关键字。看下面的例子就明白了：

　　提示错误"Person.age 不可视"，这说明static关键字并不会改变变量和方法的访问权限。

2.能通过this访问静态成员变量吗？

　　虽然对于静态方法来说没有this，那么在非静态方法中能够通过this访问静态成员变量吗？先看下面的一个例子，这段代码输出的结果是什么？
public class Main {　　
    static int value = 33;

    public static void main(String[] args) throws Exception{
        new Main().printValue();
    }

    private void printValue(){
        int value = 3;
        System.out.println(this.value);
    }
}

　　这里面主要考察队this和static的理解。this代表什么？this代表当前对象，那么通过new Main()来调用printValue的话，当前对象就是通过new Main()生成的对象。而static变量是被对象所享有的，因此在printValue中的this.value的值毫无疑问是33。在printValue方法内部的value是局部变量，根本不可能与this关联，所以输出结果是33。在这里永远要记住一点：静态成员变量虽然独立于对象，但是不代表不可以通过对象去访问，所有的静态方法和静态变量都可以通过对象访问（只要访问权限足够）。

3.static能作用于局部变量么？

　　在C/C++中static是可以作用域局部变量的，但是在Java中切记：static是不允许用来修饰局部变量。不要问为什么，这是Java语法的规定。

　　具体原因可以参考这篇博文的讨论：http://www.debugease.com/j2se/178932.html

三.常见的笔试面试题
　　下面列举一些面试笔试中经常遇到的关于static关键字的题目，仅供参考，如有补充欢迎下方留言。

1.下面这段代码的输出结果是什么？
public class Test extends Base{

    static{
        System.out.println("test static");
    }

    public Test(){
        System.out.println("test constructor");
    }

    public static void main(String[] args) {
        new Test();
    }
}

class Base{

    static{
        System.out.println("base static");
    }

    public Base(){
        System.out.println("base constructor");
    }
}

　　至于为什么是这个结果，我们先不讨论，先来想一下这段代码具体的执行过程，在执行开始，先要寻找到main方法，因为main方法是程序的入口，但是在执行main方法之前，必须先加载Test类，而在加载Test类的时候发现Test类继承自Base类，因此会转去先加载Base类，在加载Base类的时候，发现有static块，便执行了static块。在Base类加载完成之后，便继续加载Test类，然后发现Test类中也有static块，便执行static块。在加载完所需的类之后，便开始执行main方法。在main方法中执行new Test()的时候会先调用父类的构造器，然后再调用自身的构造器。因此，便出现了上面的输出结果。

2.这段代码的输出结果是什么？
public class Test {
    Person person = new Person("Test");
    static{
        System.out.println("test static");
    }

    public Test() {
        System.out.println("test constructor");
    }

    public static void main(String[] args) {
        new MyClass();
    }
}

class Person{
    static{
        System.out.println("person static");
    }
    public Person(String str) {
        System.out.println("person "+str);
    }
}

class MyClass extends Test {
    Person person = new Person("MyClass");
    static{
        System.out.println("myclass static");
    }

    public MyClass() {
        System.out.println("myclass constructor");
    }
}

　　类似地，我们还是来想一下这段代码的具体执行过程。首先加载Test类，因此会执行Test类中的static块。接着执行new MyClass()，而MyClass类还没有被加载，因此需要加载MyClass类。在加载MyClass类的时候，发现MyClass类继承自Test类，但是由于Test类已经被加载了，所以只需要加载MyClass类，那么就会执行MyClass类的中的static块。在加载完之后，就通过构造器来生成对象。而在生成对象的时候，必须先初始化父类的成员变量，因此会执行Test中的Person person = new Person()，而Person类还没有被加载过，因此会先加载Person类并执行Person类中的static块，接着执行父类的构造器，完成了父类的初始化，然后就来初始化自身了，因此会接着执行MyClass中的Person person = new Person()，最后执行MyClass的构造器。

3.这段代码的输出结果是什么？
public class Test {

    static{
        System.out.println("test static 1");
    }
    public static void main(String[] args) {

    }

    static{
        System.out.println("test static 2");
    }
}

　　虽然在main方法中没有任何语句，但是还是会输出，原因上面已经讲述过了。另外，static块可以出现类中的任何地方（只要不是方法内部，记住，任何方法内部都不行），并且执行是按照static块的顺序执行的。

你对Java中的volatile关键字了解多少？

https://www.cnblogs.com/dolphin0520/p/3920373.html

i++是线程安全的吗？如何解决线程安全性？

"原子操作(atomic operation)是不需要synchronized"，

答案是否定的，i++和++i都不具有原子性。
i++：先赋值再自加。
++i：先自加再赋值。
i++和++i的线程安全分为两种情况：
1、如果i是局部变量（在方法里定义的），那么是线程安全的。因为局部变量是线程私有的，别的线程访问不到，其实也可以说没有线程安不安全之说，因为别的线程对他造不成影响。
2、如果i是全局变量，则同一进程的不同线程都可能访问到该变量，因而是线程不安全的，
会产生脏读
AtomicInteger，一个提供原子操作的Integer的类。在Java语言中，++i和i++操作并不是线程安全的，在使用的时候，不可避免的会用到synchronized关键字。而AtomicInteger则通过一种线程安全的加减操作接口。

从字节码角度深度解析 i++ 和 ++i 线程安全性原理？

https://blog.csdn.net/hotchange/article/details/79844565

请谈谈什么是CAS？

CAS 是 Yale （耶鲁）大学发起的一个开源项目，旨在为 Web 应用系统提供一种可靠的单点登录方法，CAS 在 2004 年 12 月正式成为 JA-SIG 的一个项目。CAS 具有以下特点：

【1】开源的企业级单点登录解决方案。

【2】CAS Server 为需要独立部署的 Web 应用。

【3】CAS Client 支持非常多的客户端(这里指单点登录系统中的各个 Web 应用)，包括 Java, .Net, PHP, Perl, Apache, uPortal, Ruby 等。

从结构上看，CAS 包含两个部分： CAS Server 和 CAS Client。CAS Server 需要独立部署，主要负责对用户的认证工作；CAS Client 负责处理对客户端受保护资源的访问请求，需要登录时，重定向到 CAS Server。下图是 CAS 最基本的协议过程：

SSO单点登录访问流程主要有以下步骤：

1. 访问服务：SSO客户端发送请求访问应用系统提供的服务资源。

2. 定向认证：SSO客户端会重定向用户请求到SSO服务器。

3. 用户认证：用户身份认证。

4. 发放票据：SSO服务器会产生一个随机的Service Ticket。

5. 验证票据：SSO服务器验证票据Service Ticket的合法性，验证通过后，允许客户端访问服务。

6. 传输用户信息：SSO服务器验证票据通过后，传输用户认证结果信息给客户端

从源码角度看看ArrayList的实现原理？

https://blog.csdn.net/xfhy_/article/details/80193648

手写LinkedList的实现，彻底搞清楚什么是链表？

https://blog.csdn.net/qq_33471403/article/details/80109620

Java中方法参数的传递规则？

问：当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
　　答:是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是该对象的引用一个副本。指向同一个对象,对象的内容可以在被调用的方法中改变，但对象的引用(不是引用的副本)是永远不会改变的。

　　Java参数，不管是原始类型还是引用类型，传递的都是副本(有另外一种说法是传值，但是说传副本更好理解吧，传值通常是相对传址而言)。

　　如果参数类型是原始类型，那么传过来的就是这个参数的一个副本，也就是这个原始参数的值，这个跟之前所谈的传值是一样的。如果在函数中改变了副本的值不会改变原始的值.
　　如果参数类型是引用类型，那么传过来的就是这个引用参数的副本，这个副本存放的是参数的地址。如果在函数中没有改变这个副本的地址，而是改变了地址中的 值，那么在函数内的改变会影响到传入的参数。如果在函数中改变了副本的地址，如new一个，那么副本就指向了一个新的地址，此时传入的参数还是指向原来的 地址，所以不会改变参数的值。
基本类型参数传递：不改变值

引用类型参数传递：改变值

无论是什么语言，要讨论参数传递方式，就得从内存模型说起，主要是我个人觉得从内存模型来说参数传递更为直观一些。闲言少叙，下面我们就通过内存模型的方式来讨论一下Java中的参数传递。

这里的内存模型涉及到两种类型的内存：栈内存(stack)和堆内存(heap)。基本类型作为参数传递时，传递的是这个值的拷贝。无论你怎么改变这个拷贝，原值是不会改变的。看下边的一段代码，然后结合内存模型来说明问题：

1
2
3
4
5
6
7
8
9
10
11
12
public class ParameterTransfer {
     public static void main(String[] args) {
        int num = 30;
        System.out.println("调用add方法前num=" + num);
        add(num);
        System.out.println("调用add方法后num=" + num);
     }

     public static void add(int param) {
          param = 100;
     }
}
这段代码运行的结果如下：

1
2
调用add方法前num=30
调用add方法后num=30
程序运行的结果也说明这一点，无论你在add()方法中怎么改变参数param的值，原值num都不会改变。

　　下边通过内存模型来分析一下。

　　当执行了int num = 30;这句代码后，程序在栈内存中开辟了一块地址为AD8500的内存，里边放的值是30，内存模型如下图：

                    Java中的参数传递方式
　　执行到add()方法时，程序在栈内存中又开辟了一块地址为AD8600的内存，将num的值30传递进来，此时这块内存里边放的值是30，执行param = 100;后，AD8600中的值变成了100。内存模型如下图：
                 Java中的参数传递方式

　　地址AD8600中用于存放param的值，和存放num的内存没有任何关系，无论你怎么改变param的值，实际改变的是地址为AD8600的内存中的值，而AD8500中的值并未改变，所以num的值也就没有改变。
　　 以上是基本类型参数的传递方式，下来我们讨论一下对象作为参数传递的方式。

　　先看下边的示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
public class ParameterTransfer {
     public static void main(String[] args) {
          String[] array = new String[] {"huixin"};
          System.out.println("调用reset方法前array中的第0个元素的值是:" + array[0]);
          reset(array);
          System.out.println("调用reset方法后array中的第0个元素的值是:" + array[0]);
     }

     public static void reset(String[] param) {
          param[0] = "hello, world!";
     }
}
运行的结果如下：

1
2
调用reset方法前array中的第0个元素的值是:huixin
调用reset方法后array中的第0个元素的值是:hello, world!
当对象作为参数传递时，传递的是对象的引用，也就是对象的地址。下边用内存模型图来说明。

       Java中的参数传递方式

　　当程序执行了String[] array = new String[] {"huixin"}后，程序在栈内存中开辟了一块地址编号为AD9500内存空间，用于存放array[0]的引用地址，里边放的值是堆内存中的一个地址，示例中的值为BE2500，可以理解为有一个指针指向了堆内存中的编号为BE2500的地址。堆内存中编号为BE2500的这个地址中存放的才是array[0]的值：huixin。

　　当程序进入reset方法后，将array的值，也就是对象的引用BE2500传了进来。这时，程序在栈内存中又开辟了一块编号为AD9600的内存空间，里边放的值是传递过来的值，即AD9600。可以理解为栈内存中的编号为AD9600的内存中有一个指针，也指向了堆内存中编号为BE2500的内存地址，如图所示：

       Java中的参数传递方式

　　这样一来，栈内存AD9500和AD9600(即array[0]和param的值)都指向了编号为BE2500的堆内存。

　　在reset方法中将param的值修改为hello, world!后，内存模型如下图所示：

       Java中的参数传递方式

　　改变对象param的值实际上是改变param这个栈内存所指向的堆内存中的值。param这个对象在栈内存中的地址是AD9600，里边存放的值是BE2500，所以堆内存BE2500中的值就变成了hello,world!。程序放回main方法之后，堆内存BE2500中的值仍然为hello,world!，main方法中array[0]的值时，从栈内存中找到array[0]的值是BE2500，然后去堆内存中找编号为BE2500的内存，里边的值是hello,world!。所以main方法中打印出来的值就变成了hello,world!

　　

小结：

　　无论是基本类型作为参数传递，还是对象作为参数传递，实际上传递的都是值，只是值的的形式不用而已。第一个示例中用基本类型作为参数传递时，将栈内存中的值30传递到了add方法中。第二个示例中用对象作为参数传递时，将栈内存中的值BE2500传递到了reset方法中。当用对象作为参数传递时，真正的值是放在堆内存中的，传递的是栈内存中的值，而栈内存中存放的是堆内存的地址，所以传递的就是堆内存的地址。这就是它们的区别。

补充一下，在Java中，String是一个引用类型，但是在作为参数传递的时候表现出来的却是基本类型的特性，即在方法中改变了String类型的变量的值后，不会影响方法外的String变量的值。关于这个问题，可以参考如下两个地址：

http://freej.blog.51cto.com/235241/168676

http://dryr.blog.163.com/blog/static/58211013200802393317600/

我觉得是这两篇文章中提到的两个原因导致的，一个是String实际上操作的是char[]，可以理解为String是char[]的包装类。二是给String变量重新赋值后，实际上没有改变这个变量的值，而是重新new了一个String对象，改变了新对象的值，所以原来的String变量的值并没有改变。

Java中throw和throws的区别是什么？

throws和throw
throws：用来声明一个方法可能产生的所有异常，不做任何处理而是将异常往上传，谁调用我我就抛给谁。
  用在方法声明后面，跟的是异常类名
  可以跟多个异常类名，用逗号隔开
  表示抛出异常，由该方法的调用者来处理
  throws表示出现异常的一种可能性，并不一定会发生这些异常
throw：则是用来抛出一个具体的异常类型。
  用在方法体内，跟的是异常对象名
  只能抛出一个异常对象名
  表示抛出异常，由方法体内的语句处理
  throw则是抛出了异常，执行throw则一定抛出了某种异常  
分别介绍
throws在方法后边声明异常，其实就是自己不想对异常做出任何的处理，告诉别人自己可能出现的异常，交给别人处理，然别人处理
package com.xinkaipu.Exception;
class Math{
    public int div(int i,int j) throws Exception{
        int t=i/j;
        return t;
    }
}

public class ThrowsDemo {
    public static void main(String args[]) throws Exception{
        Math m=new Math();
   }
}
throw:就是自己处理一个异常，有两种方式要么是自己捕获异常try...catch代码块，要么是抛出一个异常（throws 异常）
package com.xinkaipu.Exception;

public class TestThrow
{
    public static void main(String[] args)
    {
        try
        {
            //调用带throws声明的方法，必须显式捕获该异常
            //否则，必须在main方法中再次声明抛出
            throwChecked(-3);
        }
        catch (Exception e)
        {
            System.out.println(e.getMessage());
        }
        //调用抛出Runtime异常的方法既可以显式捕获该异常，
        //也可不理会该异常
        throwRuntime(3);
    }
    public static void throwChecked(int a)throws Exception
    {
        if (a > 0)
        {
            //自行抛出Exception异常
            //该代码必须处于try块里，或处于带throws声明的方法中
            throw new Exception("a的值大于0，不符合要求");
        }
    }
    public static void throwRuntime(int a)
    {
        if (a > 0)
        {
            //自行抛出RuntimeException异常，既可以显式捕获该异常
            //也可完全不理会该异常，把该异常交给该方法调用者处理
            throw new RuntimeException("a的值大于0，不符合要求");
        }
    }
}

重载和重写的区别？

方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的参数列表，有兼容的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。重载对返回类型没有特殊的要求，不能根据返回类型进行区分。

手写ArrayList的实现，在笔试中如何过关斩将?

https://blog.csdn.net/ligh_sqh/article/details/87346398

finally语句块你踩过哪些坑？

为什么重写equals方法需同时重写hashCode方法？

https://www.cnblogs.com/ouym/p/8963219.html

equals() 与 == 的区别？

StringBuffer和StringBuilder的区别，从源码角度分析?

你知道HashMap的数据结构吗？

为何HashMap的数组长度一定是2的次幂？

HashMap何时扩容以及它的扩容机制？

HashMap的key一般用字符串,能用其他对象吗？

HashMap的key和value都能为null么?如果key能为null,那么它是怎么样查找值的？

HashMap是线程安全的吗？如何实现线程安全？

从源码角度分析HashSet实现原理？

HashTable与HashMap的实现原理有什么不同？

String方法intern() 你真的会用吗？

什么是自动拆装箱？

https://www.cnblogs.com/h-c-g/p/11132729.html

String.valueOf和Integer.toString的区别？

java.lang.Object类里已有public方法.toString()，所以对任何严格意义上的java对象都可以调用此方法。但在使用时要注意，必须保证object不是null值，否则将抛出NullPointerException异常。

而valueOf(Object obj)对null值进行了处理，不会报任何异常。但当object为null 时，String.valueOf（object）的值是字符串”null”，而不是null。

二、Java多线程

线程的生命周期包括哪几个阶段？

多线程有几种实现方式？

请谈谈什么是进程，什么是线程？

启动线程是用start()方法还是run()方法？

说说线程安全问题，什么实现线程安全，如何实现线程安全？

sychronized和Lock的区别？

sleep()和wait()的区别？

深入分析ThreadLocal的实现原理？

你看过AbstractQueuedSynchronizer源码阅读吗，请说说实现原理？

谈谈对synchronized的偏向锁、轻量级锁、重量级锁的理解？

通过三种方式实现生产者消费者模式？

JVM层面分析sychronized如何保证线程安全的？

JDK层面分析sychronized如何保证线程安全的？

如何写一个线程安全的单例？

通过AQS实现一个自定义的Lock？

ThreadLocal什么时候会出现OOM的情况？为什么？

为什么wait, notify 和 notifyAll这些方法不在thread类里面？

你真的理解CountDownLatch与CyclicBarrier使用场景吗？

出现死锁，如何排查定位问题？

notify和notifyAll的区别？

线程池启动线程submit和execute有什么不同？

SimpleDateFormat是线程安全的吗？如何解决？

请谈谈ConcurrentHashmap底层实现原理？

使用synchronized修饰静态方法和非静态方法有什么区别？

当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其方法？

线程池的原理，为什么要创建线程池？创建线程池的方式？

创建线程池有哪几个核心参数？ 如何合理配置线程池的大小？

synchronized修饰的静态方法和非静态方法有什么区别？

三、Java Web

什么是Servlet，Servlet生命周期方法？

什么Session和Cookie，它们之间有什么联系？

JSP的八个隐含对象有哪些？

JSP的四个域对象的作用范围？

Post和Get请求的区别？

转发和重定向有什么区别？

JSP自定义标签，如何实现循环打印功能？

Http1.0和Http1.1的区别是什么？

拦截器与过滤器的区别？

四、JVM面试题

JVM内存区域如何划分？

JVM堆中对象是如何创建的?

JVM对象的结构？

JVM垃圾回收-如何判断对象是否是垃圾对象？

JVM垃圾回收算法有哪些？

JVM垃圾收集器有哪些？

JVM内存是如何分配的？

从一道面试题分析类的加载过程？

JVM双亲委派机制？

JVM可以作为GC Root的对象有哪些？

请写出几段可以导致内存溢出、内存泄漏、栈溢出的代码？

哪些情况会导致Full GC？

频繁GC问题或内存溢出问题，如何定位？

五、SQL性能优化

数据库三范式是什么？

数据库的事务、ACID及隔离级别？

不考虑事务的隔离性，容易产生哪三种情况？

数据库连接池原理？

什么是B-Tree？

什么是B+Tree？

MySQL数据库索引结构？

什么是索引？什么条件适合建立索引？什么条件不适合建立索引？

索引失效的原因有哪些？如何优化避免索引失效？

MySQL如何启动慢查询日志？

MySQL如何使用show Profile进行SQL分析？

一条执行慢的SQL如何进行优化，如何通过Explain+SQL分析性能？

什么是行锁、表锁、读锁、写锁，说说它们各自的特性？

什么情况下行锁变表锁？

什么情况下会出现间隙锁？

谈谈你对MySQL的in和exists用法的理解？

MySQL的数据库引擎有哪些，如何确定在项目中要是用的存储引擎？

count(*)、count(列名)和count(1)的区别？

union和union all的区别？

六、Spring框架

Spring的IOC和AOP机制？

Spring中Autowired和Resource关键字的区别？

依赖注入的方式有几种，各是什么?

Spring容器对Bean组件是如何管理的？

Spring容器如何创建？

Spring事务分类？

Spring事务的传播特性？

Spring事务的隔离级别？

Spring的通知类型有哪些？

七、SpringMVC框架

SpringMVC完整工作流程，熟读源码流程？

SpringMVC如何处理JSON数据？

SpringMVC拦截器原理，如何自定义拦截器？

SpringMVC如何将请求映射定位到方法上面？结合源码阐述？

SpringMVC常见注解有哪些？

SpringMVC容器和Spring容器的区别？

SpringMVC的控制器是不是单例模式,如果是,有什么问题,怎么解决？

八、MyBatis框架

MyBatis中#和$的区别？

MyBatis一级缓存原理以及失效情况？

MyBatis二级缓存的使用？

MyBatis拦截器原理？

看过MyBatis源码吗，请说说它的工作流程？

九、Java高级部分

Dubbo负载均衡策略？

Dubbo中Zookeeper做注册中心，如果注册中心集群都挂掉，发布者和订阅者之间还能通信么？

Dubbo完整的一次调用链路介绍？

请说说SpringBoot自动装配原理？

有用过SpringCloud吗，请说说SpringCloud和Dubbo有什么不一样？

什么是WebService，如何基于WebService开发接口？

谈谈项目中分布式事务应用场景？

使用Redis如何实现分布式锁？

请谈谈单点登录原理？

Tomcat如何优化？

后台系统怎么防止请求重复提交？

Linux常见命令有哪些？

请说说什么是Maven的依赖、继承以及聚合？

Git暂存区和工作区的区别？

Git如何创建、回退以及撤销版本？

常见的设计模式有哪些？