Java面试八股文详解

一、数据类型

1、Java的八种基本数据类型及其占用的字节数。

public class DataType {
    public static void main(String[] args) {
        System.out.println("byte占用字节数：" + Byte.BYTES);
        System.out.println("short占用字节数：" + Short.BYTES);
        System.out.println("int占用字节数：" + Integer.BYTES);
        System.out.println("long占用字节数：" + Long.BYTES);
        System.out.println("float占用字节数：" + Float.BYTES);
        System.out.println("double占用字节数：" + Double.BYTES);
        System.out.println("char占用字节数：" + Character.BYTES);
        System.out.println("boolean占用字节数：不固定");
    }
}

2、Java中的自动装箱、拆箱。

public class AutoBoxing {
    public static void main(String[] args) {
        Integer a = 1; // 自动装箱
        int b = a; // 自动拆箱
        System.out.println(a + b);
    }
}

3、字符串的不可变性以及String、StringBuilder、StringBuffer的区别。

public class StringDemo {
    public static void main(String[] args) {
        String a = "str";
        // String不可变性示例
        a = a + "ing";
        System.out.println(a);
        // StringBuilder、StringBuffer示例
        StringBuilder sb = new StringBuilder("str");
        sb.append("ing");
        System.out.println(sb.toString());
    }
}

二、集合

1、ArrayList、LinkedList、Vector的区别。

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Vector;

public class ListDemo {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList<>();
        LinkedList
    linkedList = new LinkedList<>();
        Vector
     vector = new Vector<>();
        for (int i = 0; i < 1000000; i++) {
            arrayList.add(i);
            linkedList.add(i);
            vector.add(i);
        }
        long start = System.nanoTime();
        for (int i = 0; i < arrayList.size(); i++) {
            arrayList.get(i);
        }
        System.out.println("ArrayList遍历时间：" + (System.nanoTime() - start) + "ns");
        start = System.nanoTime();
        for (int i = 0; i < linkedList.size(); i++) {
            linkedList.get(i);
        }
        System.out.println("LinkedList遍历时间：" + (System.nanoTime() - start) + "ns");
        start = System.nanoTime();
        for (int i = 0; i < vector.size(); i++) {
            vector.get(i);
        }
        System.out.println("Vector遍历时间：" + (System.nanoTime() - start) + "ns");
    }
}

    
   
  

2、HashMap、ConcurrentHashMap的区别。

import java.util.HashMap;
import java.util.concurrent.ConcurrentHashMap;

public class MapDemo {
    public static void main(String[] args) {
        HashMap hashMap = new HashMap<>();
        ConcurrentHashMap
    concurrentHashMap = new ConcurrentHashMap<>();
        for (int i = 0; i < 1000000; i++) {
            hashMap.put(i, i);
            concurrentHashMap.put(i, i);
        }
        long start = System.nanoTime();
        for (int i = 0; i < 1000000; i++) {
            hashMap.get(i);
        }
        System.out.println("HashMap遍历时间：" + (System.nanoTime() - start) + "ns");
        start = System.nanoTime();
        for (int i = 0; i < 1000000; i++) {
            concurrentHashMap.get(i);
        }
        System.out.println("ConcurrentHashMap遍历时间：" + (System.nanoTime() - start) + "ns");
    }
}

   
  

3、集合的容器底层原理。

由于不同容器底层实现方式不同，这里就不一一列举了。

三、并发与多线程

1、Thread和Runnable的区别。

public class ThreadDemo extends Thread {
    @Override
    public void run() {
        System.out.println("继承Thread类创建线程");
    }
}
public class RunnableDemo implements Runnable {
    @Override
    public void run() {
        System.out.println("实现Runnable接口创建线程");
    }
}
public class Main {
    public static void main(String[] args) {
        ThreadDemo thread = new ThreadDemo();
        thread.start();
        RunnableDemo runnable = new RunnableDemo();
        new Thread(runnable).start();
    }
}

2、wait和sleep的区别。

public class WaitSleepDemo {
    private static final Object lock = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (lock) {
                System.out.println(Thread.currentThread().getName() + "获取到锁");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "获取到了锁，执行结束");
            }
        }, "wait").start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            synchronized (lock) {
                System.out.println(Thread.currentThread().getName() + "获取到锁");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                lock.notifyAll();
                System.out.println(Thread.currentThread().getName() + "执行notify操作");
            }
        }, "sleep").start();
    }
}

3、线程死锁及解决方案。

关于线程死锁的问题，一般可以采用如下策略进行解决：
1、避免一个线程同时获得多个锁。
2、避免一个线程在等待另外一个线程持有的锁时，自身抱持有的锁不释放。
3、使用定时锁，使用Lock.tryLock(timeout)来替代使用内部锁机制。
4、对于数据库锁，加锁和解锁要在同一个连接中完成。

四、JVM

1、JVM的内存结构及垃圾回收算法。

由于JVM内存结构较为复杂，这里只列举常见的垃圾回收算法：标记-清除算法、复制算法、标记-整理算法、分代收集算法。

2、Java内存模型及synchronized的实现原理。

public class SynchronizedDemo {
    public synchronized void method() {
        System.out.println("synchronized方法");
    }

    public void block() {
        synchronized (this) {
            System.out.println("synchronized代码块");
        }
    }
}

3、性能调优相关选项和工具，比如jconsole、jstack等。

在开发中，经常会遇到一些性能问题，这时可以使用jconsole、jstack等工具进行诊断。其中，jconsole主要用于监控和管理JVM，jstack主要用于查看Java虚拟机进程中的线程堆栈信息。

五、设计模式

1、常见的23种设计模式及应用场景。

这里不一一展开，可以参考《Head First设计模式》和《GOF设计模式》。

2、单例模式的实现。

public class Singleton {
    private static Singleton instance = null;

    private Singleton() {
    }

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

3、工厂模式、抽象工厂模式的区别及应用场景。

工厂模式是最常用的设计模式之一，它提供了一种创建对象的方式，并且可以灵活地根据需要来选择实现类，同时也可以解决依赖关系。抽象工厂模式则是在工厂模式的基础上增加了一层抽象，通过接口的方式来解决实现类的迭代问题。