JRE：Java Runtime Environment（ java 运行时环境）。即java程序的运行时环境，包含了 java 虚拟机，java基础类库。
JDK：Java Development Kit（ java 开发工具包）。即java语言编写的程序所需的开发工具包。JDK 包含了 JRE，同时还包括 java 源码的编译器 javac、监控工具 jconsole、分析工具 jvisualvm等。
== 是关系运算符，equals() 是方法，结果都返回布尔值
Object 的 == 和 equals() 比较的都是地址，作用相同
== 作用：
基本类型，比较值是否相等
引用类型，比较内存地址值是否相等
不能比较没有父子关系的两个对象
equals()方法的作用：
JDK 中的类一般已经重写了 equals()，比较的是内容
自定义类如果没有重写 equals()，将调用父类（默认 Object 类）的 equals() 方法，Object 的 equals() 比较使用了 this == obj
可以按照需求逻辑，重写对象的 equals() 方法（重写 equals 方法，一般须重写 hashCode 方法）
值不同，使用 ＝＝ 和 equals() 比较都返回 false
值相同
Integer 使用 ＝＝ 比较：
基本类型 － 基本类型、基本类型 － 包装对象返回 true
包装对象 － 包装对象返回 false
缓存中取的包装对象比较返回 true（原因是 JVM 缓存部分基本类型常用的包装类对象，如 Integer -128 ~ 127 是被缓存的）
Integer i1 = 100;
Integer i2 = 100;
Integer i3 = 200;
Integer i4 = 200;
System.out.println(i1i2); //打印true
System.out.println(i3i4); //打印false
== 与 equals 比较
byte b1 = 127;
Byte b2 = new Byte(“127”);
Byte b3 = new Byte(“127”);
System.out.println("Byte 基本类型和包装对象使用 == 比较 : " + (b1 == b2));
System.out.println("Byte 基本类型和包装对象使用 equals 比较 : " + b2.equals(b1));
System.out.println("Byte 包装对象和包装对象使用 == 比较 : " + (b2 == b3));
System.out.println("Byte 包装对象和包装对象使用 equals 比较 : " + b2.equals(b3));
System.out.println();
Byte 基本类型和包装对象使用 == 比较 : true
Byte 基本类型和包装对象使用 equals 比较 : true
Byte 包装对象和包装对象使用 == 比较 : false
Byte 包装对象和包装对象使用 equals 比较 : true
其他，Short Character Integer Long Float double boolean
4 什么是装箱？什么是拆箱？装箱和拆箱的执行过程？常见问题？什么是装箱？什么是拆箱？
装箱：基本类型转变为包装器类型的过程。
拆箱：包装器类型转变为基本类型的过程。
//JDK1.5之前是不支持自动装箱和自动拆箱的，定义Integer对象，必须
Integer i = new Integer(8);
//JDK1.5开始，提供了自动装箱的功能，定义Integer对象可以这样
Integer i = 8;
int n = i;//自动拆箱
装箱和拆箱的执行过程？
装箱是通过调用包装器类的 valueOf 方法实现的
拆箱是通过调用包装器类的 xxxValue 方法实现的，xxx代表对应的基本数据类型。
如int装箱的时候自动调用Integer的valueOf(int)方法；Integer拆箱的时候自动调用Integer的intValue方法。
常见问题？
整型的包装类 valueOf 方法返回对象时，在常用的取值范围内，会返回缓存对象。
浮点型的包装类 valueOf 方法返回新的对象。
布尔型的包装类 valueOf 方法 Boolean类的静态常量 TRUE | FALSE， == 和 equals 相等,跟Integer 类似
包含算术运算会触发自动拆箱。
存在大量自动装箱的过程，如果装箱返回的包装对象不是从缓存中获取，会创建很多新的对象，比较消耗内存。
首先，答案肯定是不一定。同时反过来 equals() 为true，hashCode() 也不一定相同。
类的 hashCode() 方法和 equals() 方法都可以重写，返回的值完全在于自己定义。
hashCode() 返回该对象的哈希码值；equals() 返回两个对象是否相等。
关于 hashCode() 和 equals() 是方法是有一些 常规协定：
两个对象用 equals() 比较返回true，那么两个对象的hashCode()方法必须返回相同的结果。
两个对象用 equals() 比较返回false，不要求hashCode()方法也一定返回不同的值，但是最好返回不同值，以提搞哈希表性能。
重写 equals() 方法，必须重写 hashCode() 方法，以保证 equals() 方法相等时两个对象 hashcode() 返回相同的值。
final 语义是不可改变的。
被 final 修饰的类，不能够被继承。
被 final 修饰的成员变量必须要初始化，赋初值后不能再重新赋值(可以调用对象方法修改属性值)。对基本类型来说是其值不可变；对引用变量来说其引用不可变，即不能再指向其他的对象。
被 final 修饰的方法代表不能重写。
final 表示最终的、不可改变的。用于修饰类、方法和变量。final 变量必须在声明时给定初值，只能读取，不可修改。final 方法也同样只能使用，不能重写，但能够重载。final 修饰的对象，对象的引用地址不能变，但对象的属性值可以改变
finally 异常处理的一部分，它只能用在 try/catch 语句中，表示希望 finally 语句块中的代码最后一定被执行（存在一些情况导致 finally 语句块不会被执行，如 jvm 结束）
finalize() 是在 java.lang.Object 里定义的，Object 的 finalize() 方法什么都不做，对象被回收时 finalize() 方法会被调用。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要清理工作，在垃圾收集器删除对象之前被调用的。一般情况下，此方法由JVM调用。特殊情况下，可重写 finalize() 方法，当对象被回收的时候释放一些资源，须调用 super.finalize() 。
答案是不一定。存在很多特殊情况导致 finally 语句块不执行。如：
直接返回未执行到 finally 语句块
抛出异常未执行到 finally 语句块
系统退出未执行到 finally 语句块
public static String test() {
String str = null;
int i = 0;
if (i == 0) {
return str;//直接返回未执行到finally语句块
}
try {
System.out.println("try...");
return str;
} finally {
System.out.println("finally...");
}
}
public static String test2() {
String str = null;
int i = 0;
i = i / 0;
//抛出异常未执行到finally语句块
try {
System.out.println("try...");
return str;
} finally {
System.out.println("finally...");
}
}
public static String test3() {
String str = null;
try {
System.out.println("try...");
System.exit(0);//系统退出未执行到finally语句块
return str;
} finally {
System.out.println("finally...");
}
}
9 final与static的区别
都可以修饰类、方法、成员变量。
static 可以修饰类的代码块，final 不可以。
static 不可以修饰方法内的局部变量，final 可以。
static 修饰表示静态或全局，被修饰的属性和方法属于类，可以用类名.静态属性 / 方法名 访问
static 修饰的代码块表示静态代码块，当 Java 虚拟机（JVM）加载类时，就会执行该代码块,只会被执行一次
static 修饰的属性，也就是类变量，是在类加载时被创建并进行初始化，只会被创建一次
static 修饰的变量可以重新赋值
static 方法中不能用 this 和 super 关键字
static 方法必须被实现，而不能是抽象的abstract
static 方法只能被 static 方法覆盖
final 修饰表示常量、一旦创建不可改变
final 标记的成员变量必须在声明的同时赋值，或在该类的构造方法中赋值，不可以重新赋值
final 方法不能被子类重写
final 类不能被继承，没有子类，final 类中的方法默认是 final 的
final 不能用于修饰构造方法
private 类型的方法默认是final类型的
final 和 static 修饰成员变量加载过程例子
import java.util.Random;
public class TestStaticFinal {
public static void main(String[] args) {
StaticFinal sf1 = new StaticFinal();
StaticFinal sf2 = new StaticFinal();
System.out.println(sf1.fValue == sf2.fValue);//打印false
System.out.println(sf1.sValue == sf2.sValue);//打印true
}
}
class StaticFinal {
final int fValue = new Random().nextInt();
static int sValue = new Random().nextInt();
}
10 return与finally的执行顺序对返回值的影响
对于 try 和 finally 至少一个语句块包含 return 语句的情况：
finally 语句块会执行
finally 没有 return，finally 对 return 变量的重新赋值修改无效
try 和 finally 都包含return，return 值会以 finally 语句块 return 值为准
如下面的例子
public static void main(String[] args) {
System.out.println(getString());
}
public static String getString() {
String str = "A";
try {
str = "B";
return str;
} finally {
System.out.println("finally change return string to C");
str = "C";
}
}
finally change return string to C B
finally 语句块中新增 return 语句
public static void main(String[] args) {
System.out.println(getString());
}
public static String getString() {
String str = "A";
try {
str = "B";
return str;
} finally {
System.out.println("finally change return string to C");
str = "C";
return str;
}
}
打印结果
finally change return string to C
C
replace方法：支持字符和字符串的替换。
public String replace(char oldChar, char newChar)
public String replace(CharSequence target, CharSequence replacement)
replaceAll方法：基于正则表达式的字符串替换。
public String replaceAll(String regex, String replacement)
测试代码：
String str = “Hello Java. Java is a language.”;
System.out.println(str.replace(“Java.”, “c++”));//打印 Hello c++ Java is a language.
System.out.println(str.replaceAll(“Java.”, “c++”));//打印 Hello c++ c++is a language.
打印结果：
Hello c++ Java is a language.
Hello c++ c++is a language.
round() ：返回四舍五入，负 .5 小数返回较大整数，如 -1.5 返回 -1。
ceil() ：返回小数所在两整数间的较大值，如 -1.5 返回 -1。
floor() ：返回小数所在两整数间的较小值，如 -1.5 返回 -2。
System.out.println(“Math.round(1.4)=” + Math.round(1.4));
System.out.println(“Math.round(-1.4)=” + Math.round(-1.4));
System.out.println(“Math.round(1.5)=” + Math.round(1.5));
System.out.println(“Math.round(-1.5)=” + Math.round(-1.5));
System.out.println(“Math.round(1.6)=” + Math.round(1.6));
System.out.println(“Math.round(-1.6)=” + Math.round(-1.6));
System.out.println();
System.out.println(“Math.ceil(1.4)=” + Math.ceil(1.4));
System.out.println(“Math.ceil(-1.4)=” + Math.ceil(-1.4));
System.out.println(“Math.ceil(1.5)=” + Math.ceil(1.5));
System.out.println(“Math.ceil(-1.5)=” + Math.ceil(-1.5));
System.out.println(“Math.ceil(1.6)=” + Math.ceil(1.6));
System.out.println(“Math.ceil(-1.6)=” + Math.ceil(-1.6));
System.out.println();
System.out.println(“Math.floor(1.4)=” + Math.floor(1.4));
System.out.println(“Math.floor(-1.4)=” + Math.floor(-1.4));
System.out.println(“Math.floor(1.5)=” + Math.floor(1.5));
System.out.println(“Math.floor(-1.5)=” + Math.floor(-1.5));
System.out.println(“Math.floor(1.6)=” + Math.floor(1.6));
System.out.println(“Math.floor(-1.6)=” + Math.floor(-1.6));
打印结果：
Math.round(1.4)=1
Math.round(-1.4)=-1
Math.round(1.5)=2
Math.round(-1.5)=-1
Math.round(1.6)=2
Math.round(-1.6)=-2
Math.ceil(1.4)=2.0
Math.ceil(-1.4)=-1.0
Math.ceil(1.5)=2.0
Math.ceil(-1.5)=-1.0
Math.ceil(1.6)=2.0
Math.ceil(-1.6)=-1.0
Math.floor(1.4)=1.0
Math.floor(-1.4)=-2.0
Math.floor(1.5)=1.0
Math.floor(-1.5)=-2.0
Math.floor(1.6)=1.0
Math.floor(-1.6)=-2.0
不属于。
Java 中 8 种基础的数据类型：byte、short、char、int、long、float、double、boolean
但是 String 类型却是最常用到的引用类型。
Java 中，常用的对字符串操作的类有 String、StringBuffer、StringBuilder
String : final 修饰，String 类的方法都是返回 new String。即对 String 对象的任何改变都不影响到原对象，对字符串的修改操作都会生成新的对象。
StringBuffer : 对字符串的操作的方法都加了synchronized，保证线程安全。
StringBuilder : 不保证线程安全，在方法体内需要进行字符串的修改操作，可以 new StringBuilder 对象，调用 StringBuilder 对象的 append()、replace()、delete() 等方法修改字符串。
