Java面试高频知识点总结 part3

最新推荐文章于 2022-08-18 15:49:56 发布

从流域到海域

最新推荐文章于 2022-08-18 15:49:56 发布

阅读量241

点赞数

分类专栏：面试文章标签： Java

本文链接：https://blog.csdn.net/Solo95/article/details/108845242

版权

面试专栏收录该内容

9 篇文章 3 订阅

订阅专栏

Java基础数据类型

在这里插入图片描述

Java Object类包含的方法

package java.lang;

public class Object {
	...
	private static native void registerNatives();
	public final native Class<?> getClass();
	public native int hashCode() {};
	public boolean equals() {}
	protected native Object clone() throws CloneNotSupportedException {};
	public String toString() {};
	public final native void notify() {};
	public final native void notifyAll() {};
	public final native void wait(long timeout) throws InterruptedException {} // 有多个重载
	protected void finalize() throws Throwable {}
	...
}

native关键字：一个方法被native关键字修饰，就成为了Native Method。简单地讲，一个Native Method就是一个java调用非java代码的接口。Native Method的实现并非是java语言，其实现方法体在java语言外面。

native可以与除了abstract之外的关键字连用，因为它暗示方法存在可调用的实现体，只是不是由java编写的。

Java异常类继承树

在这里插入图片描述

更详细：
在这里插入图片描述
检查异常(CheckedException): Exception类下除了RuntimeException类及其子类的异常，这些异常都应当被try-catch捕获并处理。

注：除了IOException之外，还有其他类型的检查异常，比如SQLException。

非检查异常(UncheckedException):RuntimeExcpetion类及其子类，运行时异常。Error类及其子类也是UncheckedException，无法预先处理。

wait()和sleep()的区别

wait()是Object类的方法，用于线程间交互/通信；sleep()是Thread类的静态方法，通常被用于暂停执行，是线程用来控制自身流程的；
wait()方法在同步控制方法和同步代码块中使用，sleep()方法则可以在任何地方使用。
sleep()方法不会释放锁；wait()方法则会释放锁；
wait()方法调用后，线程不会自动苏醒，需要别的线程调用同一对象的notify()或者notifyAll()方法。sleep()方法执行完成后，线程会自动苏醒，或者可以使用wait(long timeout)超时后线程会⾃动苏醒。
sleep()方法需要捕获异常，wait()方法不需要。

实现一个ReentrantLock

下面是使用AQS实现的ReetrantLock

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class MyReentrantLock implements Lock {
    private Synchronizer synchronizer = new Synchronizer();

    private class Synchronizer extends AbstractQueuedSynchronizer {
        protected boolean tryAcquire() {
            int state = this.getState();
            if(state == 0) {
                if(this.compareAndSetState(0, 1)) {
                    this.setExclusiveOwnerThread(Thread.currentThread());
                }
                return true;
            } else {
                Thread currentThread = Thread.currentThread();
                Thread ownerThread = this.getExclusiveOwnerThread();
                if(currentThread == ownerThread) {
                    this.setState(state+1);
                    // this.compareAndSetState(state, state+1)
                    return true;
                }
            }
            return false;
        }
        protected boolean tryRelease() {
            if(Thread.currentThread() != this.getExclusiveOwnerThread()) {
                // throw new RuntimeException();
                return false;
            } else {
                int state = this.getState();
                this.setState(--state);
                if(state == 0) {
                    this.setExclusiveOwnerThread(null);
                    return true;
                }
            }
            return false;
        }
        protected Condition newCondition() {
            return new ConditionObject();
        }
    }

    @Override
    public void lock() {
        synchronizer.acquire(1);
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        synchronizer.acquireInterruptibly(1);
    }

    @Override
    public boolean tryLock() {
        return synchronizer.tryAcquire();
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return synchronizer.tryAcquireNanos(1, unit.toNanos(time));
    }

    @Override
    public void unlock() {
        synchronizer.release(1);
        // synchronizer.tryRelease()
    }

    @Override
    public Condition newCondition() {
        return synchronizer.newCondition();
    }
}

Java中有序的集合包括哪些？

实现了List接口的集合类全部有序：比如ArrayList、LinkedList、Vector。

LinkedHashMap：使用双向链表来维持有序。

Sorted Map：接口，有ConcurrentSkipListMap和TreeMap两种实现。继承自Map接口，有CurrentNavigableMap和NavigableMap两个子接口。

ConcurrentSkipListMap：基于跳表实现。

TreeMap：基于红黑树。

TreeSet：基于TreeMap实现。

JAVA中排序算法实现的具体原理是什么？

在JDK7以前的版本中，基本类型使用优化后的快排，双枢轴随机快排，其他类型使用优化后的归并排序。

JDK7及以后如果JVM参数设置了Djava.util.Arrays.useLegacyMergeSort=true那么就会执行上面的排序策略，否则将会执行TimSort排序。TimSort排序也是一种优化后的归并排序算法，它对已经反向排好序的输入做了特别优化，对已经正向排好序的输入减少回溯。对两种情况混合存在(一会升序，一会降序，实际情况常见)的输入处理比较好。

TimSort算法, 大致思路是这样的：