Java基础面试题总结（一）

一、JDK和JRE有什么区别

JDK：Java Development Kit 的简称，Java开发工具包，提供了Java的开发环境和运行环境
JRE：Java Runtime Environment 的简称，Java运行环境，为Java的运行提供了运行环境
具体来说JDK其实包含了JRE，同时还包含了编译Java源码的编译器Javac，还包含了很多Java程序调试和分析的工具。简单来说：如果你需要运行Java程序，只需安装JRE就可以了，如果你需要编写Java程序，需要安装JDK

二、 java 中八种基本数据类型，String 属于基本数据类型么

基础类型有 8 种：byte、boolean、char、short、int、float、long、double
String 不属于基础类型，属于引用数据类型

三、int 和 Integer 的区别

为了能够将这些基本数据类型当成对象操作，Java 为每一个基本数据类型都引入了对应的包装类型（wrapperclass），int 的包装类就是 Integer，从 Java 5 开始引入了自动装箱/拆箱机制，使得二者可以相互转换。
Java 为每个原始类型提供了包装类型：
原始类型: boolean，char，byte，short，int，long，float，double
包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double
自动装箱：基本数据类型自动转换为包装类型

Integer.valueOf

自动拆箱：包装类型自动转换为基本数据类型

Integer.intValue

1、Integer 是int 的包装类，int 则是 java 的一种基本数据类型
2、Integer 变量必须实例化后才能使用，而 int 变量不需要
3、Integer 实际是对象的引用，当 new 一个 Integer 时，实际上是生成一个指针指向此对象；而 int 则是直接存储数据值
4、Integer 的默认值是 null，int 的默认值是 0

四、int a=2*8 怎样运算效率最快

用移位运算 int a=2<<3;
a 就是 2 乘以 8 最后结果是 16 这是最省内存 最有效率的方法
解释：
这个方法确实高效率的。我来解释一下：
2 的二进制是 10 在 32 位存储器里面是 0000 0000 0000 0010
左移三位后变成 0000 0000 0001 0000 也就是 16
同理：
2 << 3（左移 3 位相当于乘以 2 的 3 次方，右移 3 位相当于除以 2 的 3 次方）

五、float f=3.4 是否正确

不正确
3.4 是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，因此需要强制类型转换 float f =(float)3.4; 或者写成 float f =3.4F。

六、short s1 = 1; s1 = s1 + 1;有错吗 short s1 = 1; s1 += 1;有错吗

对于 short s1 = 1; s1 = s1 + 1；由于 1 是 int 类型，因此 s1+1 运算结果也是 int 型，需要强制转换类型才能赋值给 short 型。
而 short s1 = 1; s1 += 1；+=操作符会进行隐式自动类型转换，是 Java 语言规定的运算符；Java 编译器会对它进行特殊处理，因此可以正确编译。因为 s1+= 1;相当于 s1 = (short)(s1 + 1)

七、Math.round(11.5) 等于多少Math.round(-11.5)等于多少

Math.round(11.5)的返回值是 12，Math.round(-11.5)的返回值是-11。四舍五入的原理是在参数上加 0.5 然后进行下取整

八、switch 是否能作用在 byte 上，是否能作用在 long 上，是否能作用

在 Java 5 以前，switch(expr)中，expr 只能是 byte、short、char、int
从 Java 5 开始，Java 中引入了枚举类型，expr 也可以是 enum 类型
从 Java 7 开始，expr 还可以是字符串（String），但是长整型（long）在目前所
有的版本中都是不可以的

九、在 Java 中，如何跳出当前的多重嵌套循环

在最外层循环前加一个标记如 A，然后用 break A;可以跳出多重循环
（Java 中支持带标签的 break 和continue语句，作用有点类似于 C 和C++中的 goto 语句，但是就像要避免使用 goto 一样，应该避免使用带标签的 break 和continue，因为它不会让你的程序变得更优雅，很多时候甚至有相反的作用）

十、实现两个整数变量的交换

方式一：开发中常用的，使用中间变量

int x = 10;
int y = 20;
int temp;

temp = x;
x = y;
y = temp;

方式二：不使用中间变量的，“和”实现

int i = 10;
int j = 20;
i = i + j; //i = 30; j = 20;
j = i - j; //i = 30; j = 10;
i = i - j; //i = 20; j = 10;

方式三：面试中使用的，按位亦或 “^”

int i = 10;
int j = 20;
i = i ^ j;
j = i ^ j;
i = i ^ j;

方式四：一句话实现交换

int i = 10;
int j = 20;
j = ( i + j ) - ( i = j );

十一、==和 equals 的区别

== 号在比较基本数据类型时比较的是值，而用 == 号比较两个对象时比较的是两个对象的地址值；
equals()方法存在于 Object 类中，默认效果和==号的效果一样，也是比较的地址值，然而，Java 提供的所有类中，
绝大多数类都重写了 equals()方法，比如 string，integer 等，重写后的 equals()方法一般都是比较两个对象的值 。

十二、hashCode()和 equals()的区别

1、首先equals()和hashcode()这两个方法都是从object类中继承过来的。equals()是对两个对象的地址值进行的比较（即比较引用是否相同）。
hashCode()是一个本地方法，它的实现是根据本地机器相关的。
2、equals()相等的两个对象，hashcode()一定相等；反过来：hashcode()不等，一定能推出equals()也不等；hashcode()相等，equals()可能相等，也可能不等。

十三、两个对象的 hashCode() 相同，则 equals() 也一定为 true

不对，两个对象的 hashCode() 相同，equals() 不一定 true
hashCode()只是计算对象属性的哈希值，有可能属性不一致，但是刚好哈希值一样，发生哈希碰撞，比如 5+2=7，4+3=7，但是这两个 7 并不是同一个 7
例子：

        Integer a = 97;
        String b ="a";
        System.out.println(a.hashCode() == b.hashCode());    //true
        System.out.println(a.equals(b));                     //false

十四、以下代码运行结果为

Integer i = 100;
Integer j = 100;
System.out.print(i == j); //true
Integer i = 128;
Integer j = 128;
System.out.print(i == j); //false

Integer 类型维护了一个整数常量池，取值范围-128-127
创建 Integer 对象时，如果数值在范围内，直接从常量池中获取，否则需要开辟空间创建新的对象

十五、char 型变量中能不能存贮一个中文汉字，为什么

在C语言中，char类型占1一个字节，而汉字占2个字节，所以不能存储

在Java中，char类型占2个字节，而且Java默认采用Unicode编码，一个Unicode码是16位，所以一个Unicode码占两个字节，Java中无论汉字还是英文字母都是用Unicode编码来表示的。所以，在Java中，char类型变量可以存储一个中文汉字

十六、final 修饰的作用

1、final修饰的类为最终类，不能被继承
2、final修饰的方法不能被重写
3、final修饰的变量叫做常量，常量必须被初始化，初始化之后值就不能被改变

十七、java 泛型

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数

十八、泛型的好处

1，类型安全。 泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。没有泛型，这些假设就只存在于程序员的头脑中（或者如果幸运的话， 还存在于代码注释中）。
2，消除强制类型转换。 泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。
3，潜在的性能收益。 泛型为较大的优化带来可能。在泛型的初始实现中，编译器将强制类型转换（没有泛型的话，程序员会指定这些强制类型转换）插入生成的字节码中。但是更多类型信息可用于编译器这一事实，为未来版本的 JVM的优化带来可能。由于泛型的实现方式，支持泛型（几乎）不需要 JVM 或类文件更改。所有工作都在编译器中完成，编译器生成类似于没有泛型（和强制类型转换）时所写的代码，只是更能确保类型安全而已。