1.权限修饰符 public ,protected ,默认, private 的区别是?
当前类 相同包下 子类 项目中其他包下
public √ √ √ √
protected √ √ √ ×
默认 √ √ × ×
private √ × × ×
2.java中的基本数据类型有哪些? String 属于基本类型吗?
答:java中基本类型有8种 , byte short,int ,long ,float , double ,char ,boolean ,String 属于引用类型,不属于基本类型
整数类型: byte, short ,int ,log
byte (1字节,8位 取值范围:-128 ~ 127) ,short(2字节,16 位，很少用) ,int(4字节,32位最常用) ,long(8字节,64位)
数值类型
小数类型: float(4字节 32位) , double (8字节,64位)
字符类型 : char 占2个字节,16位 ; 单引号引起的字符,可以为中文
布尔类型 : boolean 值为true 或者 false
java中默认的整数类型是 int , 默认的小数类型是double
类型的自动提升:
例如:
double d = 1L;//类型小转大,可以自动提升 long l = 1.0; //类型大转小,只能强转
3. int 与 Integer 的区别是什么?
答:1、Integer是int的包装类，int则是java的一种基本数据类型
2、Integer变量必须实例化后才能使用,而int变量不需要
3、Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值
4、Integer的默认值是null，int的默认值是0
拓展: int 与 Integer 的比较 , Integer 与 Integer 的比较
//情形1 Integer 与 int类型比较 Integer i = 1; int j = 1; System.out.println(i == j); //情形2 Integer 与 Integer 比较(不通过new 的形式) Integer i1 = 100; Integer i2 = 100; System.out.println(i1 == i2); //情形3 Integer 与 Integer 比较(不通过new 的形式) Integer i3 = 128; Integer i4 = 128; System.out.println(i3 == i4); //情形4 Integer 与 Integer 通过new Integer i5 = new Integer(110); Integer i6 = 110; System.out.println(i5 == i6); //情形5 Integer 与 Integer 通过new Integer i7 = new Integer(120); Integer i8 = new Integer(120); System.out.println(i7 == i8);
最终执行结果:
true true false false false
分析:
//写在前面 ,对于 == ,int 类型之间的比较,比较的是值, Integer对象之间比较的是内存地址 /* 情形一: Integer 与 int 的比较 , 会将Integer 拆箱成 int 类型的值再做比较,所以最终是两个int类型的比较. 而两个int类型比较的是字面值,所以结果为true */ /* 情形二: Integer i1 = 100;这句最终执行的代码是 Integer i1 = Integer.valueOf(100); 此时查看Integer.valueOf(int)的源码: */ public static Integer valueOf(int i) { if (i >= IntegerCache.low && i <= IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i); } //继续查看IntegerCache的源码: private static class IntegerCache { static final int low = -128; static final int high; static final Integer cache[]; static { // high value may be configured by property 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); // Maximum array size is Integer.MAX_VALUE h = Math.min(i, Integer.MAX_VALUE - (-low) -1); } catch( NumberFormatException nfe) { // If the property cannot be parsed into an int, ignore it. } } high = h; //即相当于 new Integer[256]; cache = new Integer[(high - low) + 1]; int j = low; //最终cache[0] ~ cache[255] 等价于 -128 ~ 127 for(int k = 0; k < cache.length; k++) cache[k] = new Integer(j++); // range [-128, 127] must be interned (JLS7 5.1.7) assert IntegerCache.high >= 127; } private IntegerCache() {} } /* 也就是说, i1 与 i2 都是从IntegerCache 数据中取出,且内存地址一致.所以结果为true; */ /* 情形三: 同上,仍然会调用Integer.valueOf()方法,由于不满足判断条件: */ if (i >= IntegerCache.low && i <= IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i); } /* 所以 两次i3 ,i4 相当于分别执行了 new Integer(128); 而Integer 对象之间的比较,比较的是内存地址; 由于new 了两次,所以内存地址不同,故结果为false; */ /* 情形四: 参考情形二, i5,i6 相当于重新new了两次,内存地址不一致,故比较结果为false 情形五: 同上,每次new 都会新开辟内存空间,故结果为false; */
4.String s = "Hello", s = "World" 此时s的值已经改变了, 为什么还说String 是不可变的?
答: 第一次 s = ''Hello'',相当于创建了 1个 String对象 ''Hello'' , 同时将该对象在内存中的引用地址赋给了变量s
而当执行 s = ''Hello''时,同样也会创建一个String对象 "World", 将此对线的地址赋给 变量s ,并打破原来的引用关系
也就是说,每次更改 s 的值都会新开辟一块内存空间,而不是修改原有内存空间中的值 ,所以说 String 是不可变的;
如何验证?
可以通过System.identityHashCode(obj)验证,该方法可以根据变量的内存地址计算出相应的hashCode值(官方API,并没有这么说):
String s = "Hello"; System.out.println(System.identityHashCode(s)); //s = "World"; System.out.println(System.identityHashCode(s));
此时执行的结果为:
1068824137 1068824137
不难发现,两次执行的结果是一致的,因此 s 引用的内存地址没有改变, 将上面的注释打开再执行,结果为:
1068824137 864237698
可以发现,两次的值不一致,可以直观的说明.s的内存地址已经发生了改变
除此之外,查看String 代码可以发现 String 是有 char[] 组成;
private final char value[];//等价于 private final char[] value; 只是写法不同而已
而char[] value 使用了private 与 final修饰 所以一旦初始化就不可以更改;
通过 内存地址 与 String中的成员变量 足以说明String是不可变的;
4. String ,StringBuilder,StringBuffer 之间的区别是什么?
从拼接速度上来说:StringBuilder > StringBuffer > String
测试案例:
@Test public void testAppend() { long start_time = 0; long end_time = 0; start_time = System.currentTimeMillis(); StringBuffer sf = new StringBuffer("str"); for (int j = 0; j < 100000; j++) { sf = sf.append("str"); } end_time = System.currentTimeMillis(); System.out.println("StringBuffer 拼接总耗时:"+(end_time - start_time)+"ms"); /*start_time = System.currentTimeMillis(); StringBuilder sb = new StringBuilder("str"); for (int j = 0; j < 100000; j++) { sb = sb.append("str"); } end_time = System.currentTimeMillis(); System.out.println("StringBuilder 拼接总耗时:"+(end_time - start_time)+"ms");*/ /*start_time = System.currentTimeMillis(); String s = "str"; for (int j = 0; j < 100000; j++) { s += "str"; } end_time = System.currentTimeMillis(); System.out.println("String 拼接总耗时:"+(end_time - start_time)+"ms");*/ }
同样执行10W次拼接str字符串,5次执行取平均耗时结果:
StringBuffer :4.4ms
StringBuilder:3.4ms
String:16.4ms
从结果来看 StringBuffer 与 StringBuilder的拼接速度远远大于String的拼接, 这是因为 StringBuffer与StringBuilder 的拼接是对同一对象进行操作,而String的拼接则是不停的开辟新的内存
StringBuilder 与 StringBuffer 的差异会随着拼接次数的增大而增大,有兴趣的伙伴可以动手试一下
从线程安全上来看:StringBuffer > StringBuilder
原因:StringBuffer 的 append方法 都加上了 synchronized关键字,实现了方法的同步,多线程下是安全的,而StringBuilder中在多线程中可能出现数据不一致的情况
5. java中重写是什么意思? 重写的原则是什么?
答:重写是指复写父类中的方法
原则: 1同 , 2小, 1大
1同:方法签名相同,即方法名称,参数类型,参数个数完全相同
2小:子类抛出的异常类型小于等于父类 , 子类的返回值类型小于等于父类
1大:子类方法的访问权限大于等于父类
6.什么是overload ,即方法的重载?
类中存在多个,方法名称相同,但是参数列表不同(参数个数, 参数类型)的方法 .这些方法为重载关系
重载的注意事项:
- 在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int,float)，但是不能为fun(int,int)）；
- 不能通过访问权限、返回类型、抛出的异常进行重载；
- 方法的异常类型和数目不会对重载造成影响；
- 对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。
7.Error 与 Exception 有什么区别? 运行时异常与受检异常有什么区别?
答:
Error 与 Exception 都是Throwable的子类:
1.Error 表示是JVM无法处理的重大错误,例如:OutOfMemoryError ;Error是我们无法处理的错误 ;
2.Exception 可以分为两大类: Check(受检)异常,Runtime(运行时)异常:
一般运行时异常指的是RuntimeException下的子类,除了RuntimeException外.其他的Exception都称之为受检异常
2.1 受检异常:我们必须要在程序中去处理他,否则代码编译不通过;
处理的方式有两种:①在方法声明时通过throws直接抛出 ②使用try ... catch ...代码块捕获处理
常见的受检异常有:IOException
2.2 运行时异常:程序不要求代码中一定要处理他,不会影响编译通过,只有在运行时的时候出现才会抛出;
一般RuntimeException的出现,都是代码编写的逻辑不够严谨导致的;
常见的RuntimeException有:
Java.lang.ArithmeticException (算数异常)
Java.lang.NumberFormatException (数字格式化异常:;例如:Integer.parseInt("a");)
Java.lang.ClassCastException(类型转换异常)
Java.lang.IndexOutOfBoundsException(索引越界)
Java.lang.NullPointerException(常见的空指针异常)
以下列会触发上述异常的代码:
//System.out.println(1 / 0);//java.lang.ArithmeticException: / by zero
//int a = Integer.parseInt("a");//java.lang.NumberFormatException: For input string: "a"
//new ArrayList<>().get(0);//java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
String s = null; s.toString();//java.lang.NullPointerException
8. ArrayList,Vector, LinkedList 的存储性能和特性的区别:
对于查找,更改而言:
ArrayList 与 Vector 基于Object数组,可以直接根据下标获取到元素,LinkedList 是基于链表的结构,获取某个元素,需要通过首尾一级级才可以找到
对于增删而言:
而Object数组 在指定索引位置插入 或 删除一个数据则需要将索引后面的所有元素索引进行加一,链表结构则比较擅长插入与删除
结论: ArrayList,Vector 查找和更改速度优于 LinkedList , 增删速度则慢于LinkedList;
ArrayList 与Vector的区别:
安全性方面:
Vector中的大部分方法都是synchronized的,所以Vector是线程安全的,ArrayList则不是
速度方面:
synchronized会增加性能的消耗,因此ArrayList处理速度是要快于Vector的
如何选择:
如果是多线程场景建议选择Vector,保证数据的安全;
如果是单线程,没有线程安全的问题;则选择ArrayList更好
9.HashMap ,Hashtable的区别?
从两方面解答:
1.安全性方面:Hashtable中的许多方法是synchronized的,而HashMap不是;
2.速度方面:安全意味着性能的降低;
3.key,value方面:HashMap的key,value 都可以为null ; 而 Hashtable中不允许为null,否则会抛出NullPointerException异常
10. final, finally, finalize 的区别?
虽然长得挺像,但是功能却差别很大,此题只需回答出各自的功能就行;
final:
修饰类:表示该类不可以被继承
修饰方法:表示方法不可以被重写
修饰变量:如果修饰的是基本类型的变量,则表示该变量初始化后 值不可以再被更改;修饰引用类型的变量则初始化后,不能再指向别的对象
finally:
一般搭配 try - catch - finally 或 try - finally 使用;表示不管try-catch语句中发生了什么 ,执行完try - cathch后都会执行finally中的代码;
finalize:
是object中的一个protected方法,在GC(垃圾收集器)清理对象之前,会调用该对象的finalize方法
11.java中 try - catch - finally 语句中如果都还有return,那么执行哪个return?
12.在try-catch代码块中如果有return,那么在执行return之前会判断是否存在finally代码块?
如果不存在:很好理解,程序未出异常则执行try中的return ,如果出了异常则执行catch中的return
如果存在:再判断finally中是否有return语句
如果没有return:等待finally执行完毕之后再执行 try 或 catch中的return
如果有return:则不再使用try 或 catch中的return,直接使用finally中的return作为返回值;
额外的,如果try-catch-finally中不管执行了谁的return, 程序都不再往后执行
13.关于 new String("HelloWorld");总共创建了几个对象?
对于String而言,通过new 关键字创建对象,是一定会在堆中创建1个对象;
但java对String做了优化,除了堆中之外,还有一个String的常量池;
每当创建String类型的对象时(不管是通过new的形式 还是 字面量的形式) ,都会首先在常量池中寻找是否已经有了"HelloWorld"这个对象
如果有的话则不会在额外创建,如果没有的话,则会在常量池中创建1个新的对象
所以答案是:最少创建1个新对象,可能创建1个或2个新对象;
而String s = "HelloWorld" 则是 最少0个,可能创建1个新对象;
更详细的可以参考这篇博客:new String()究竟创建几个对象?
14.String中的实例方法,intern()作用是什么?
答:intern方法的作用时,检查常量池中是否存在某个字符串,如果存在则该方法返回该字符串在常量池中的引用,否则将字符串添加到常量池中同时返回在常量池中的引用;
String s = new String("hello") + new String("World"); System.out.println(s == "helloWorld");//false 此时比较的是s在堆中的地址 System.out.println(s.intern() == "helloWorld");//true 此时比较的是"helloWorld"在常量池中的地址
更详细的intern()介绍,请参考该博客(提示:文章有一定长度,请耐心看):Java技术——你真的了解String类的intern()方法吗
15.关于String类型的拼接
如果是字面量值之间的拼接则会在编译阶段进行优化,例如:
String s = "Hello" + "World"
编译优化后:
String s = "HelloWorld"
如果不是字面量值的拼接,则会转为StringBuilder的append拼接,例如:
String s = new String("Hello") + new String("World")
这种情况,不会再进行编译优化;通过反编译可以看到:
String s = (new StringBuilder("Hello")).append(new String("World")).toString();
详情参考本文:关于字符串拼接的问题