Java八股文纯享版——篇①:Java基础

注:
1.笔记为个人归纳整理,尽力保证准确性,如有错误,恳请指正
2.写文不易,转载请注明出处
3.本文首发地址 https://blog.leapmie.com/archives/b8fe0da9/
4.本系列文章目录详见《Java八股文纯享版——目录》
5.文末可关注公众号,内容更精彩

JDK8对比JDK7的差别

1.HashMap的实现差别

2.支持Lambda表达式语法(如创建线程,对于接口只有一个方法需要重写的类可以用lambda方式简洁创建对象)

3.支持Stream流操作。Stream提供一种对 Java 集合的流式操作,比如filter, map, reduce, find, match, sorted等。创建Stream有两种方式:stream() 创建串行流、parallelStream() 创建可以并行计算的并行流。

1
2
3
4
5
6
7
List<String> stringList = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl"); 
List<String> filtered = stringList .parallelStream()
.filter(string > !string.isEmpty()) //过滤
.map(i -> i*i) // 映射
.sorted() // 排序
.limit(10) // 分页
.collect(Collectors.toList()); // 返回结果集

4.接口支持默认方法(如果实现多个接口同时都定义了相同的默认方法,则实现类必须重写该方法)

1
2
3
4
5
6
7
8
9
10
11
12
public interface Interface1{
default void helloWorld() {
System.out.println("hi i'm from Interface1");
}
}

public class MyImplement implements Interface1{
public static void main(String[] args) {
MyImplement myImplement = new MyImplement();
myImplement.helloWorld();
}
}

HashMap结构

Jdk7的实现

数组+链表组成,数组是HashMap的主体,链表用于解决Hash冲突。

Jdk8的实现

数组+红黑树。JDK8中当HashMap链表长度大于8的时候,改为红黑树结构,解决链表过长的问题,当小于6时会转换回链表。

转换阈值为什么是8

Java源码的贡献者在进行大量实验分析,hashcode碰撞次数符合泊松分布,在负载因子0.75(HashMap默认值)的情况下,单个hash槽内元素个数为8的概率为0.00000006,概率小于百万分之一,所以发生红黑树转换的情况其实并不多,设置为8可以大幅减少转换的代价。

从红黑树转换为链表的阈值为6,是为了避免元素数量在临界点来回变化导致的结构频繁转换。

以下为源码注释中的概率说明:

0: 0.60653066
1: 0.30326533
2: 0.07581633
3: 0.01263606
4: 0.00157952
5: 0.00015795
6: 0.00001316
7: 0.00000094
8: 0.00000006

为什么是红黑树而不是其他树?

普通二叉树可能会出现单边长度过长的问题,红黑树属于平衡二叉树,保证树的合理高度,而相比AVL平衡二叉树具备更好的插入、删除效率。(红黑树允许局部少量的不完全平衡,这样对于效率影响不大,但省去了很多没有必要的调平衡操作,avl树调平衡有时候代价较大,所以效率不如红黑树)。

HashMap的扩容机制

当HashMap中的元素越来越多的时候,碰撞的几率也就越来越高,为了提高查询的效率,就要对HashMap的数组进行扩容(resize)。
当hashmap中的元素个数超过数组大小*loadFactor时,就会进行数组扩容,loadFactor的默认值为0.75。
扩容的大小为原数组长度的一倍。

ConcurrentHashmap实现原理

Jdk7的实现

HashTable是一个线程安全的类,它使用synchronized来锁住整张Hash表来实现线程安全,性能低下。
ConcurrentHashMap内部分为很多个Segment,每一个Segment拥有一把锁,每个段相当于一个小的Hashtable。当一个线程占用锁访问其中一个数据段时不影响其他段的访问,提高并发效率。

Jdk8的实现

table数组+单向链表+红黑树的结构

jdk8中取消segments字段,直接采用transient volatile HashEntry<K,V>[] table 保存数据,采用 table 数组元素作为锁,从而实现了对每一行数据进行加锁,进一步减少并发冲突的概率,代替原来的每一段加锁。
因为段的隔离级别不太容易确定,默认是16,但是很多情况下并不合适,如果太大很多空间就浪费了,如果太小每个段中可能元素过于多,所以取消segments,改成了CAS算法

ArrayList与LinkedArrayList的区别

  • Array(动态数组)的数据结构,一个是Link(链表)的数据结构
  • 当随机访问List时(get和set操作),ArrayList比LinkedList的效率更高
  • 当对数据进行增加和删除的操作时(add和remove操作),LinkedList比ArrayList的效率更高

List的安全实现

ArrayList不是线程安全的,有以下几种方案实List的现线程安全:

1. Vector类

Vector实现方式比较笨重,add等每个方法使用Synchronized修饰

1
2
3
4
5
6
7
8
Vector v = new Vector(3, 2);
v.addElement(new Integer(1));
v.addElement(new Integer(2));
Enumeration en=v.elements();
while(en.hasMoreElements()){
Object object=en.nextElement();
System.out.println(object);
}

2. Collections.synchronizedList

Collections.synchronizedList(List() list),内部使用同步代码块的方式实现同步,用SynchronizedCollection这个静态内部类作为锁。

1
List<String> list = Collections.synchronizedList(new ArrayList<>());

3.CopyOnWriteArrayList

1
2
3
4
5
6
7
8
List<String> list =new CopyOnWriteArrayList<String>();
list.add("1");
list.add("2");
Iterator<String> iter = list.iterator();
while(iter.hasNext()){
String o = iter.next();
    System.out.println(o);
}

内部在add等方法通过ReentrantLock加锁实现。

缺点:
1.因为CopyOnWrite的写是复制机制,所以在进行写操作的时候,内存里会同时驻扎两个对象的内存,旧的对象和新写入的对象。
2.CopyOnWrite容器只能保证数据的最终一致性,不能保证数据的实时一致性。所以如果你希望写入的的数据,马上能读到,请不要使用CopyOnWrite容器。

Java的异常类别

异常分为Error和exception,其中exception分为CheckedException和RuntimeException

Error

error表示系统级的错误,是java运行环境内部错误或硬件问题,由Java虚拟机抛出,除了退出运行别无选择,如OOM(OutOfMemoryError)。

CheckedException(检查异常)

检查异常主要是指IO异常、SQL异常等。对于这种异常,JVM要求我们必须对其进行catch处理,如FileNotFoundException。

RuntimeException(运行时异常)

运行时异常一般不处理,比如NullPointerException,对于运行时异常,程序会将异常一直向上抛,一直抛到处理代码,如果没有catch块进行处理,到了最上层,如果是多线程就有Thread.run()抛出,如果不是多线程就由main.run抛出,抛出异常后线程终止。

Iterator

如有ArrayList a,内容为[“a”,”b”,”c”,”d”]

在for 循环里遍历List,删除元素会怎样?

1
2
3
4
5
6
7
for (int i = 0; i < a.size(); i++) {
if (i == 1) {
a.remove(i);
} else {
System.out.println(i + a.get(i));
}
}

最终输出0a,2d,因为元素b被删除,然后c往前移位对应i=1,所以c也被跳过输出。

在iterator 循环里遍历List,删除元素会怎样?

1
2
3
4
5
6
7
8
9
Iterator<String> iterator = a.iterator();
while (iterator.hasNext()) {
String s = iterator.next();
if ("b".equals(s)) {
a.remove(1);
} else {
System.out.println(s);
}
}

抛出异常ConcurrentModificationException,要避免抛异常应该使用iterator.remove()进行删除。

Iterator实现原理

Iterator的实现中主要有几个变量cursor,lastRest, expectedModCount三个变量,其中cursor将记录下一个位置,lastRet记录当前位置,expectedModCount记录没有修改的List的版本号。

ArrayList作了添加或删除操作都会增加modCount版本号,这样的意思是在迭代期间,会不断检查modCount和迭代器持有的expectedModCount两者是不是相等,如果不想等就抛出异常了

Java的继承有什么缺点

  1. 父类向子类暴露了实现细节
  2. 父类更改之后子类也要同时更改
  3. 子类覆盖了一些方法,可能会导致其他调用了该方法的方法错误

包装类

《阿里巴巴Java手册》规定如下

【强制】所有整型包装类对象之间值的比较,全部使用 equals 方法比较。
说明:对于 Integer var = ? 在-128 至 127 范围内的赋值,Integer 对象是在 IntegerCache.cache 产 生,会复用已有对象,这个区间内的 Integer 值可以直接使用==进行判断,但是这个区间之外的所有数 据,都会在堆上产生,并不会复用已有对象,这是一个大坑,推荐使用 equals 方法进行判断。

对于以下语句:

1
2
3
4
Integer i01 = 59;
int i02 = 59;
Integer i03 =Integer.valueOf(59);
Integer i04 = new Integer(59);

以下输出结果为false的是:
A System.out.println(i01 == i02);
B System.out.println(i01 == i03);
C System.out.println(i03 == i04);
D System.out.println(i02 == i04);

答案为C

JVM中一个字节以下的整型数据会在JVM启动的时候加载进内存,除非用new Integer()显式的创建对象,否则都是同一个对象
所以只有i04是一个新对象,其他都是同一个对象。所有A,B选项为true
C选项i03和i04是两个不同的对象,返回false
D选项i02是基本数据类型,会触发i04自动拆箱,比较的时候比较的是数值,返回true

重写hashCode方法

为什么重写equals方法要重写hashCode方法?

当equals方法被重写时,通常有必要重写hashCode方法,以维护hashCode方法的常规约定:值相同的对象必须有相同的hashCode。

  • hashCode不同时,object1.equals(object2)为false;
  • hashCode相同时,object1.equals(object2)不一定为true

因为hashCode效率更高(仅为一个int值),比较起来更快,对于HashMap等很多结构是先通过对象的hashCode方法判断是否一致,然后再继续操作。

例如类Person中有属性name、idcard等字段,如果重写equals方法希望通过name、idcard字段值一致则代表该对象相等,必须同时重写hashCode方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
class Person { 
String name;
String idcard;
String sex;

@Override
public int hashCode() {
int result = 17;  //任意素数  
// 31 有个很好的性能,即用移位和减法来代替乘法,通常*31
result = 31*result +name.hashCode(); 
result = 31*result +idcard.hashCode();  
return result;
}

摘自《Effective Java》中关于重写hashCode方法的习惯步骤如下:

“之所以选择31,是因为它是一个奇素数。如果乘数是偶数,并且乘法溢出的话,信息就会丢失,因为与2相乘等价于位移运算。使用素数的好处并不很明显,但是习惯上都使用素数来计算三列结果。31有个很好的特性,即用移位和减法来代替乘法,可以得到更好的性能:31 * i 等于 (i << 5) - i”。

对象引用类型及回收时机

从JDK 1.2版本开始,把对象的引用分为4种级别,从而使程序能更加灵活地控制对象的生命周期。这4种级别由高到低依次为:强引用、软引用、弱引用和虚引用。

(1)强引用(StrongReference)
强引用是我们使用的最广泛,也是最普遍的一种引用类型。即

1
A a = new A();

只要某个对象有强引用与之关联,JVM必定不会回收这个对象,即使在内存不足的情况下,JVM宁愿抛出OutOfMemory错误也不会回收这种对象。

如果想中断强引用和某个对象之间的关联,可以显示地将引用赋值为null,这样一来的话,JVM在合适的时间就会回收该对象。

⑵软引用(SoftReference)

软引用是用来描述一些有用但并不是必需的对象,在Java中用java.lang.ref.SoftReference类来表示。

1
软引用是用来描述一些有用但并不是必需的对象,在Java中用java.lang.ref.SoftReference类来表示。

软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被JVM回收,这个软引用就会被加入到与之关联的引用队列中。

对于软引用关联着的对象,只有在内存不足的时候JVM才会回收该对象。因此,这一点可以很好地用来解决OOM的问题,并且这个特性很适合用来实现缓存:比如网页缓存、图片缓存等。

⑶弱引用(WeakReference)
弱引用也是用来描述非必需对象的,当JVM进行垃圾回收时,无论内存是否充足,都会回收被弱引用关联的对象。
在java中,用java.lang.ref.WeakReference类来表示。

1
WeakReference<String> sr = new WeakReference<String>(new String("aaa"));

不过要注意的是,这里所说的被弱引用关联的对象是指只有弱引用与之关联,如果存在强引用同时与之关联,则进行垃圾回收时也不会回收该对象(软引用也是如此)。弱引用也可以和一个引用队列(ReferenceQueue)联合使用。

⑷虚引用(PhantomReference)
如果一个对象与虚引用关联,则跟没有引用与之关联一样,在任何时候都可能被垃圾回收器回收。在java中用java.lang.ref.PhantomReference类表示。

1
2
ReferenceQueue<String> queue = new ReferenceQueue<String>();
PhantomReference<String> pr = new PhantomReference<String>(new String("aaa"), queue);

虚引用必须和引用队列关联使用,当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会把这个虚引用加入到与之关联的引用队列中。


[目录]《Java八股文纯享版——目录》


文章作者: leapMie
文章链接: https://blog.leapmie.com/archives/b8fe0da9/
版权声明: 本博客所有文章除特别声明外,均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 leapMie
关注公众号