@wxf 2018-05-14T10:28:44.000000Z 字数 8152 阅读 743

Java基础相关问题整理

面试系列

概念相关（浏览）

Java是如何实现跨平台的

Java的跨平台是通过Java虚拟机JVM来实现的。不同的平台有不同版本JVM。
JDK、JRE、JVM和配置环境变量
JDK：Java开发环境和Java运行环境
JRE：Java运行环境，包括Java运行需要的类库+JVM
配置环境变量：
- 环境变量的配置：
  1）：永久配置方式：JAVA_HOME={安装路径}\Java\jdk
  path=%JAVA_HOME%\bin
  2）：临时配置方式：set path=%path%;{安装路径}\Java\jdk\bin
- classpath的配置：
  classpath的作用是指定类搜索路径，要使用已经编写好的类，前提当然是能够找到它们了，JVM就是通过CLASSPATH来寻找类的。我们需要把jdk安装目录下的lib子目录中的dt.jar和tools.jar设置到CLASSPATH中，当然，当前目录“.”也必须加入到该变量中。这里CLASSPATH为：
  .;{安装路径}/Java/jdk1.6.0_21/lib/dt.jar;{安装路径}/Java/jdk1.6.0_21/lib/tools.jar

运算符号

& 和 && 的区别
& ：与运算，两个都为true才是true，只要有一个是false就是false。
&&：短路与，即根据前半部分就可以判断结果的时，它会或略后面的运算。
| 和 || 的区别
|：或运算，只要有一个为true就是true，都是false才是false。
||：短路或，即根据前半部分就可以判断结果的时，它会或略后面的运算。

重载和重写

重载(Overload)是指一个类中允许存在多个同名函数，参数不同；
重写(Override)是指子类重写定义父类方法。
注意：构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload。

访问控制符

private：同类可见
default：同包可见
protected：同包可见、子类可见
public：全局可见

抽象类和接口

相同点：不能实例化，都包含抽象方法。
不同点：抽象类中允许有非抽象方法，接口只包含抽象方法(JDK1.8之前)；类只能继承一个父类，可以实现多个接口。

接口：1.8新特性默认方法(default修饰)；1.9新特性私有方法。

Java中常见关键字

static关键字有哪些作用

可以修饰变量、修饰方法
静态代码块
静态内部类
静态导包

final关键字

transient关键字

volatile关键字

保证变量在线程之间的可见性
禁止了JVM的指令重排

hashCode和equals方法的关系

hashCode()方法根据对象的地址或字符串的值来计算一个整型的哈希码；equals用于对比两个对象或字符串是否相同。
如果两个对象根据equals()方法比较是相等的，那么两个对象调用hashCode()方法返回的结构必须相等；
如果两个对象根据equals()方法比较是不相等的，那么两个对象调用hashCode()方法返回的结果不一定不相等。

什么是泛型、为什么要使用以及泛型擦除

泛型的本质是参数化类型。

使用泛型可以避免不同数据类型存储到同一对象中，使用时导致数据强转异常。

泛型擦除是指在编译期间，Java会将所有的泛型信息擦除掉，编译后再变成原始类型。

==和equals的区别

概念说明

基本数据类型(原始数据类型)，即：byte,short,char,int,long,float,double,boolean
这些数据类型之间的比较，应用双等号（==）,比较的是它们的值。
复合数据类型(类)
当复合数据类型用“==”进行比较的时候，比较的是它们的内存地址。在JAVA中所有的类都是继承于Object这个基类的，在Object基类中定义了一个equals方法，该方法的初始行为也是比较对象的内存地址，但在一些类库中equals方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。
对于复合数据类型之间进行equals比较时，在没有覆写equals方法的情况下，它们之间的比较还是基于它们的内存地址。

代码说明

片段一

public void compare(){
    String s1 = "Java";
    String s2 = "Java";
    System.out.println(s1 == s2);
}
# 输出：true。说明s1与s2引用同一个String对象 -- "Java"

片段二
```
public void compare(){
    String s1 = "Java";
    String s2 = new String("Java");
    System.out.println(s1 == s2);
    System.out.println(s1.equals(s2));
}
# 输出：false和true。s1与s2分别引用了两个String对象 -- "Java"
```
字符串缓冲池
程序在运行的时候会创建一个字符串缓冲池，当使用 s2 = "Java" 表达创建字符串的时候，程序首先会在String缓冲池中寻找相同值的对象。
在片段一中，s1先被放到了字符串缓冲池中，所以在s2被创建的时候，程序找到了具有相同值的s1，s2将引用s1所引用的字符串对象"Java"。
在片段二中，使用了new操作符，它的告诉程序："我要一个新的！不要旧的！"。于是一个新的"Java"字符串对象被创建在内存中。它们的值相同，但是位置不同。
片段三
```
public void compare(){
    String s1 = "Java";
    String s2 = new String("Java");
    s2 = s2.intern();
    System.out.println(s1 == s2);
    System.out.println(s1.equals(s2));
}
# 输出：true和true。s1与s2分别引用了两个String对象 -- "Java"
```
String的intern()方法
"Java".intern()方法的返回值还是字符串"Java"，表面上看起来好像这个方法没什么用处。但实际上，它做了个小动作：检查字符串池里是否存在"Java"这么一个字符串，如果存在，就返回池里的字符串；如果不存在，该方法会把"Java"添加到字符串池中，然后再返回它的引用。

Integer

包装类型和基本数据类型的区别

Integer的缓存策略

Integer缓存是在java5中引入的一个有助于节省内存、提高性能的特性。下面我们用一段代码来展示一下Integer的缓存行为。

public void testInteger(){
    Integer integer1 = 10;
    Integer integer2 = 10;
    if(integer1 == integer2)
        System.out.println("Equals!");
    else
        System.out.println("Not Equals!");
    //=======分割线=======  
    Integer integer3 = 256;
    Integer integer4 = 256;
    if(integer3 == integer4)
        System.out.println("Equals!");
    else
        System.out.println("Not Equals!");
}

在Java中，==比较的是对象的引用，而equals比较的是值。所以你有可能认为上面的两个判断结果都是false。但是奇怪的是，上面的两个判断结果却返回不同的布尔值。其结果如下：

Equals!
Not Equals!

Java中Integer缓存实现
在Java5中，整数对象在内部实现中通过使用相同的对象引用实现了缓存和重用。其缓存的整数区间为-128到127。
这种Integer缓存策略仅在自动封箱的时候有用，使用构造函数创建的Integer对象不能被缓存。

自动装箱和拆箱的原理
Java编译器把原始类型自动转换为包装类的过程称为自动装箱。自动装箱时编译器调用valueOf方法将原始类型值转换成对象，同样自动拆箱时，编译器通过调用类似于intValue()，doubleValue()这类的方法将对象转成原始类型值。明白了自动装箱和拆箱的原理后，我们来分析一下Integer的自动装箱的代码实现：

public static Integer valueOf(int i) {
    //判断i是否在-128和127之间，存在则从IntegerCache中获取包装类的实例，否则new一个新的实例。
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}
//使用享元模式，来减少对象的创建
private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];   //cache属于静态常量，存放在jvm的方法区中
    //使用静态代码块为常量赋值（类加载的时候对cache[]进行初始化），静态常量cache[]存放在常量池中。
    static {
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
            }
        }
        high = h;
        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);
        assert IntegerCache.high >= 127;
    }
    private IntegerCache() {}
}

8中基本数据类型的自动装箱代码实现

//byte原生类型自动装箱成Byte
public static Byte valueOf(byte b) {
    final int offset = 128;
    return ByteCache.cache[(int)b + offset];
}
//short原生类型自动装箱成Short
public static Short valueOf(short s) {
    final int offset = 128;
    int sAsInt = s;
    if (sAsInt >= -128 && sAsInt <= 127) { // must cache
        return ShortCache.cache[sAsInt + offset];
    }
    return new Short(s);
}
//int原生类型自动装箱成Integer
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}
//long原生类型自动装箱成Long
public static Long valueOf(long l) {
    final int offset = 128;
    if (l >= -128 && l <= 127) { // will cache
        return LongCache.cache[(int)l + offset];
    }
    return new Long(l);
}
//boolean原生类型自动装箱成Boolean
public static Boolean valueOf(boolean b) {
    return (b ? TRUE : FALSE);
}
//char原生类型自动装箱成Character
public static Character valueOf(char c) {
    if (c <= 127) { // must cache
        return CharacterCache.cache[(int)c];
    }
    return new Character(c);
}
//float原生类型自动装箱成Float
public static Float valueOf(float f){
    return new Float(f);
}
//double原生类型自动装箱成Double
public static Double valueOf(double d){
    return new Double(d);
}

通过上面的源码分析发现，只有double和float的自动自动装箱没有使用缓存，每次都是new新的对象。其他的6种基本类型都使用了缓存策略。

String中的坑

第一坑、new String("ABC")究竟创建几个对象

new String("ABC")究竟创建几个对象

如果常量池中不存在"ABC"字符串，那么new String("ABC")这句代码会创建2个对象（一个在常量池，一个在堆上）。
如果常量池中已经创建了"ABC"字符串，那么new String("ABC")这句代码只会创建了1个对象

第二坑、equals()方法

在Stirng中equals()方法比较的是字符串的内容是否相同，其实现原理是根据char字符数组元素逐个进行比较的。

# 源码如下：
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()首先做的是比较引用，如果引用是同一个对象，结束比较并返回true。如果引用不是同一个地址，判断是不是String的一个实例。同样，不是的话直接结束比较并返回false。如果是，则拿字符串的长度做循环的控制变量，拿字符串的字符数组做比较内容，进行循环比较。

第三坑、String、StringBuffer和StringBuilder的区别

可变和不可变
- String类使用字符数组保存字符串，源码如下：
```
private final char value[]; 
# 因为使用final修饰，所以String对象是不可修改的。
```
- StringBuffer和StringBuilder都继承自AbstractStringBuilder类，在该抽象类中也是使用字符数组保存字符串的，源码如下：
```
char value[];
# 可知StringBuffer和StringBuilder是可变长度的。
```
是否多线程安全
- String中的对象是不可变的，也就可以理解为常量，显然线程安全。
- StringBuffer对其方法或调用的方法加了同步锁，所以是线程安全的。
- StringBuilder并没有对方法添加同步锁，所以是非线程安全的。
StringBuffer和StringBuilder的共同点
- StringBufer和StringBuilder都继承自抽象类AbstractStringBuilder，它们都会调用父类中的公共方法，只是StringBuffer在方法上添加了synchronized关键字，进行同步。
相关推荐：Java String StringBuilder 和 StringBuffer 用法详解

异常

Error和Exception的区别和联系

Error和Exception的联系
Error和Exception都是继承于Throwable。
Error和Exception的区别
- Error一般是指与虚拟机相关的问题，如系统崩溃、内存不足、方法调用栈溢出等。对于这类错误，Java编译器不会进行检查。遇到这类错误，建议让程序终止。
- Exception表示程序可以处理的异常，可以捕获且可以恢复。遇到这类异常应尽可能处理异常，使程序恢复运行。Exception分为运行时异常和编译时异常。

throw 和 throws两个关键字有什么不同

throw是用来抛出异常的，包括自定义异常。如：throw new CustomException();
throws是用来声明异常的。

try-catch-finally-return执行顺序

概念说明

不管是否有异常产生，finally语句块中代码都会执行；即使是try和catch中有return语句时，finally块仍然会执行；
finally是在return后面的表达式运算完以后执行的，所以函数返回值是在finally执行前确定的。无论finally中的代码怎么样，返回的值都不会改变，仍然是之前return语句中保存的值；
finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

代码说明

片段一

try{
} catch(Exception e){
} finally{
} 
return; 
# 按正常顺序执行。

片段二 *

try{ 
    return; 
} catch(Exception e){
} finally{
}
return; 
# 程序先执行try语句块中return之前（包括return语句中的表达式运算）的代码，再执行finally语句块，最后执行try中return;，finally语句块后面的return语句不再执行。

片段三

try{
} catch(Exception e){
    return;
} finally{
} 
return; 
# 有异常：则先执行catch中return之前（包括return语句中的表达式运算）的代码，再执行finally语句中全部代码，最后执行catch块中的return;，finally块后面的return语句不再执行。 
# 无异常：执行完try再finally再执行最后的return语句。

片段四

try{ 
    return; 
} catch(Exception e){
} finally{
    return;
} 
# 程序先执行try语句块中return之前（包括return语句中的表达式运算）的代码，再执行finally块，因为finally块中有return所以提前退出。

代码事例

public int test(){
    int x = 1;
    try {
        x++;
        return x;
    } finally {
        ++x;
    }
}
# 执行结果：2，即使finally中对变量x进行了改变，也不会影响返回结果。

参考资源：谈一谈Java中的Error和Exception

Java中的序列化和反序列化

深入学习 Java 序列化

Java中的NIO、BIO、AIO

BIO:即IO，同步阻塞IO
NIO:同步非阻塞IO
AIO:异步非阻塞IO

IO和NIO的区别

标准IO是基于字节流和字符流进行操作；而NIO是基于通道和缓冲区进行操作，数据从通道读取到缓冲区中或者从缓冲区写入到通道。
NIO引入了选择器概念，选择器用于监听多个通道的事件(比如：链接打开、可读。可写)，因此NIO可以通过一个线程监听多个数据通道。相比标准IO为每个连接创建一个线程，NIO大大降低了线程创建资源的开销。

序列化和反序列化

序列化是指将对象的状态信息转换为可以存储或传输形式的过程。通过序列化可以将对象的状态保存为字节数组，需要的时候再将字节数组反序列化为对象。

正则表达式

image_1c8d6bglhst11ebgrff1idl13ji13.png-251.3kB

Java基础相关问题整理

概念相关（浏览）

运算符号

重载和重写

访问控制符

抽象类和接口

Java中常见关键字

static关键字有哪些作用

final关键字

transient关键字

volatile关键字

hashCode和equals方法的关系

什么是泛型、为什么要使用以及泛型擦除

==和equals的区别

概念说明

代码说明

Integer

包装类型和基本数据类型的区别

Integer的缓存策略

String中的坑

第一坑、new String("ABC")究竟创建几个对象

第二坑、equals()方法

第三坑、String、StringBuffer和StringBuilder的区别

异常

Error和Exception的区别和联系

throw 和 throws两个关键字有什么不同

try-catch-finally-return执行顺序

概念说明

代码说明

Java中的序列化和反序列化

Java中的NIO、BIO、AIO

IO和NIO的区别

序列化和反序列化

正则表达式

内容目录