面试准备——Java理论高级【笔试，面试的核心重点】

集合框架

Java集合框架是面试中的重中之重，尤其是对List、Set、Map的实现类及其底层原理的考察。

1. List

ArrayList：
- 底层是动态数组，支持随机访问（通过索引），时间复杂度为O(1)。
- 插入和删除元素时，如果是在中间位置，需要移动后续元素，时间复杂度为O(n)。
- 扩容机制：默认初始容量为10，扩容时增加为原来的1.5倍。
- 线程不安全。
面试问题：
- ArrayList的扩容机制是什么？
- ArrayList和LinkedList的区别？
案例：
```
List<Integer> list = new ArrayList<>();
list.add(1); // 添加元素
list.get(0); // 获取元素
list.remove(0); // 删除元素
```
LinkedList：
- 底层是双向链表，适合频繁的插入和删除操作，时间复杂度为O(1)。
- 随机访问效率低，时间复杂度为O(n)。
- 线程不安全。
面试问题：
- LinkedList的实现原理是什么？
- 如何实现一个LRU缓存？（可以用LinkedList实现）
案例：
```
List<Integer> linkedList = new LinkedList<>();
linkedList.add(1);
linkedList.add(2);
linkedList.remove(1); // 删除元素
```

2. Set

HashSet：
- 基于HashMap实现，元素无序且不允许重复。
- 添加元素时，先计算哈希值，再通过equals方法判断是否重复。
- 线程不安全。
面试问题：
- HashSet如何保证元素唯一性？
- HashSet和TreeSet的区别？
案例：
```
Set<String> set = new HashSet<>();
set.add("A");
set.add("B");
set.add("A"); // 不会重复添加
```
TreeSet：
- 基于TreeMap实现，元素按自然顺序或自定义顺序排序。
- 内部使用红黑树实现，插入、删除、查找的时间复杂度为O(log n)。
- 线程不安全。
案例：
```
Set<Integer> treeSet = new TreeSet<>();
treeSet.add(3);
treeSet.add(1);
treeSet.add(2);
System.out.println(treeSet); // 输出 [1, 2, 3]
```

3. Map

HashMap：
- 基于哈希表实现，允许null键和null值。
- 扩容机制：默认初始容量为16，负载因子为0.75，扩容时容量变为原来的2倍。
- 线程不安全。
面试问题：
- HashMap的底层实现原理？
- HashMap如何解决哈希冲突？（链地址法）
- JDK 1.8中HashMap的优化？（引入红黑树）
案例：
```
Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
map.get("A"); // 获取值
```
ConcurrentHashMap：
- 线程安全的HashMap，JDK 1.8之前使用分段锁，JDK 1.8之后使用CAS + synchronized。
- 面试问题：
  - ConcurrentHashMap如何保证线程安全？
  - ConcurrentHashMap的锁粒度是什么？
案例：
```
Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put("A", 1);
concurrentMap.put("B", 2);
```

File API

File API用于操作文件和目录，常见操作包括创建、删除、重命名、遍历等。

常见面试问题：

如何递归遍历目录下的所有文件？

使用递归或Files.walk()方法。

案例：

public void listFiles(File dir) {if (dir.isDirectory()) {File[] files = dir.listFiles();for (File file : files) {if (file.isDirectory()) {listFiles(file); // 递归} else {System.out.println(file.getName());}}}
}

如何读取大文件？

使用BufferedReader逐行读取。

案例：

try (BufferedReader br = new BufferedReader(new FileReader("largeFile.txt"))) {String line;while ((line = br.readLine()) != null) {System.out.println(line);}
}

IO

Java IO分为字节流和字符流，常见类包括InputStream、OutputStream、Reader、Writer。

常见面试问题：

字节流 vs 字符流的区别？

字节流以字节为单位操作数据，适合处理二进制文件（如图片、视频）。
字符流以字符为单位操作数据，适合处理文本文件。

案例：

// 字节流
try (FileInputStream fis = new FileInputStream("input.txt");FileOutputStream fos = new FileOutputStream("output.txt")) {int data;while ((data = fis.read()) != -1) {fos.write(data);}
}// 字符流
try (FileReader fr = new FileReader("input.txt");FileWriter fw = new FileWriter("output.txt")) {int data;while ((data = fr.read()) != -1) {fw.write(data);}
}

NIO是什么？

NIO（Non-blocking IO）是Java提供的高性能IO API，基于通道（Channel）和缓冲区（Buffer）操作。
核心组件：Channel、Buffer、Selector。

案例：

try (FileChannel channel = FileChannel.open(Paths.get("input.txt"), StandardOpenOption.READ)) {ByteBuffer buffer = ByteBuffer.allocate(1024);while (channel.read(buffer) > 0) {buffer.flip();while (buffer.hasRemaining()) {System.out.print((char) buffer.get());}buffer.clear();}
}

线程

线程是Java并发编程的核心，面试中常考线程的创建、生命周期、同步机制等。

常见面试问题：

如何实现线程同步？

使用synchronized关键字或ReentrantLock。

案例：

class Counter {private int count = 0;public synchronized void increment() {count++;}public int getCount() {return count;}
}

wait()、notify()、notifyAll()的作用？

用于线程间的通信，wait()使线程等待，notify()唤醒一个等待线程，notifyAll()唤醒所有等待线程。

案例：

class SharedResource {private boolean flag = false;public synchronized void produce() {while (flag) {try {wait();} catch (InterruptedException e) {e.printStackTrace();}}flag = true;notify();}public synchronized void consume() {while (!flag) {try {wait();} catch (InterruptedException e) {e.printStackTrace();}}flag = false;notify();}
}

线程池

线程池是面试中的高频考点，尤其是对ThreadPoolExecutor的参数和原理的考察。

常见面试问题：

线程池的核心参数有哪些？
- corePoolSize：核心线程数。
- maximumPoolSize：最大线程数。
- keepAliveTime：空闲线程存活时间。
- workQueue：任务队列。
- threadFactory：线程工厂。
- handler：拒绝策略。

线程池的拒绝策略有哪些？

AbortPolicy：直接抛出异常。
CallerRunsPolicy：由调用线程处理任务。
DiscardOldestPolicy：丢弃队列中最老的任务。
DiscardPolicy：直接丢弃任务。

案例：

ThreadPoolExecutor executor = new ThreadPoolExecutor(2, // corePoolSize5, // maximumPoolSize60, // keepAliveTimeTimeUnit.SECONDS,new LinkedBlockingQueue<>(10),Executors.defaultThreadFactory(),new ThreadPoolExecutor.CallerRunsPolicy()
);

问题答案

ArrayList的扩容机制是什么？

答案：
- ArrayList的底层是一个动态数组，初始容量为10。
- 当元素数量超过当前容量时，ArrayList会自动扩容。
- 扩容时，新容量通常是旧容量的1.5倍（即oldCapacity + (oldCapacity >> 1)）。
- 扩容过程会创建一个新的数组，并将旧数组中的元素复制到新数组中。
示例：
```
ArrayList<Integer> list = new ArrayList<>();
for (int i = 0; i < 20; i++) {list.add(i); // 当元素数量超过10时，ArrayList会自动扩容
}
```

ArrayList和LinkedList的区别？

答案：
- 底层实现：
  - ArrayList基于动态数组，支持随机访问，时间复杂度为O(1)。
  - LinkedList基于双向链表，插入和删除操作效率高，时间复杂度为O(1)，但随机访问效率低，时间复杂度为O(n)。
- 内存占用：
  - ArrayList占用连续内存空间。
  - LinkedList占用非连续内存空间，每个节点需要额外存储前后节点的引用。
- 适用场景：
  - ArrayList适合频繁查询的场景。
  - LinkedList适合频繁插入和删除的场景。
示例：
```
List<Integer> arrayList = new ArrayList<>();
arrayList.add(1); // 适合查询
arrayList.get(0); // O(1)List<Integer> linkedList = new LinkedList<>();
linkedList.add(1); // 适合插入和删除
linkedList.remove(0); // O(1)
```

HashSet如何保证元素唯一性？

答案：
- HashSet基于HashMap实现，元素存储在HashMap的键中。
- 添加元素时，先计算元素的哈希值（通过hashCode()方法），然后通过equals()方法判断是否重复。
- 如果哈希值相同且equals()返回true，则认为元素重复，不会添加。
示例：
```
Set<String> set = new HashSet<>();
set.add("A");
set.add("B");
set.add("A"); // 不会重复添加
```

HashMap的底层实现原理？

答案：
- HashMap基于哈希表实现，底层是数组 + 链表（JDK 1.8之前）或数组 + 链表 + 红黑树（JDK 1.8之后）。
- 添加元素时，先计算键的哈希值，然后通过哈希值找到数组中的位置（桶）。
- 如果发生哈希冲突（即多个键映射到同一个桶），则使用链表或红黑树存储冲突的元素。
- 当链表长度超过8时，链表会转换为红黑树，以提高查找效率。
示例：
```
Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
map.get("A"); // 获取值
```

LinkedList的实现原理是什么？

答案：
- LinkedList是基于双向链表实现的。
- 每个节点（Node）包含三个部分：
  - 数据域（存储元素值）。
  - 前驱指针（指向前一个节点）。
  - 后继指针（指向后一个节点）。
- 链表的头节点（first）和尾节点（last）分别指向链表的第一个和最后一个节点。
- 插入和删除操作只需要修改节点的指针，时间复杂度为O(1)。
- 随机访问需要从头节点或尾节点遍历，时间复杂度为O(n)。
示例：
```
LinkedList<Integer> list = new LinkedList<>();
list.add(1); // 添加到链表尾部
list.add(2);
list.remove(1); // 删除元素
```

如何实现一个LRU缓存？（可以用LinkedList实现）

答案：

LRU（Least Recently Used）缓存是一种淘汰最近最少使用数据的缓存策略。
可以使用LinkedList + HashMap实现：
- LinkedList用于维护数据的访问顺序，最近访问的数据放在链表头部。
- HashMap用于快速查找数据。

实现步骤：

当访问一个数据时，如果数据在缓存中，则将其移动到链表头部。
如果数据不在缓存中，则将其添加到链表头部。
如果缓存已满，则移除链表尾部的数据。

示例：

class LRUCache<K, V> {private final int capacity;private final Map<K, V> map;private final LinkedList<K> list;public LRUCache(int capacity) {this.capacity = capacity;this.map = new HashMap<>();this.list = new LinkedList<>();}public V get(K key) {if (map.containsKey(key)) {list.remove(key); // 移除旧位置list.addFirst(key); // 放到链表头部return map.get(key);}return null;}public void put(K key, V value) {if (map.containsKey(key)) {list.remove(key); // 移除旧位置} else if (map.size() >= capacity) {K lastKey = list.removeLast(); // 移除链表尾部数据map.remove(lastKey);}list.addFirst(key); // 放到链表头部map.put(key, value);}
}

HashSet和TreeSet的区别？

答案：
- 底层实现：
  - HashSet基于HashMap实现，元素无序。
  - TreeSet基于TreeMap实现，元素按自然顺序或自定义顺序排序。
- 性能：
  - HashSet的插入、删除、查找操作的时间复杂度为O(1)。
  - TreeSet的插入、删除、查找操作的时间复杂度为O(log n)。
- 适用场景：
  - HashSet适合需要快速查找且不关心顺序的场景。
  - TreeSet适合需要有序数据的场景。
示例：
```
Set<Integer> hashSet = new HashSet<>();
hashSet.add(3);
hashSet.add(1);
hashSet.add(2);
System.out.println(hashSet); // 输出顺序不确定Set<Integer> treeSet = new TreeSet<>();
treeSet.add(3);
treeSet.add(1);
treeSet.add(2);
System.out.println(treeSet); // 输出 [1, 2, 3]
```

HashMap如何解决哈希冲突？（链地址法）

答案：
- HashMap使用链地址法解决哈希冲突。
- 当多个键映射到同一个桶（数组位置）时，HashMap会将这些键值对存储在同一个链表中。
- 在JDK 1.8中，当链表长度超过8时，链表会转换为红黑树，以提高查找效率。
示例：
```
Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);
// 假设 "A" 和 "B" 的哈希值相同，它们会被存储在同一个链表中
```

JDK 1.8中HashMap的优化？（引入红黑树）

答案：
- 在JDK 1.8中，HashMap引入了红黑树来优化性能。
- 当链表长度超过8时，链表会转换为红黑树，查找时间复杂度从O(n)降低到O(log n)。
- 当红黑树的节点数少于6时，红黑树会退化为链表。
优化点：
- 提高了哈希冲突严重时的查找效率。
- 减少了链表过长时的性能问题。
示例：
```
Map<String, Integer> map = new HashMap<>();
for (int i = 0; i < 100; i++) {map.put("Key" + i, i);
}
// 当链表长度超过8时，会自动转换为红黑树
```

ConcurrentHashMap的锁粒度是什么？

答案：
- 在JDK 1.7中，ConcurrentHashMap使用分段锁（Segment），每个段独立加锁，锁粒度是段级别。
- 在JDK 1.8中，ConcurrentHashMap使用CAS + synchronized，锁粒度是桶级别（数组中的每个位置）。
  - 对每个桶（数组中的每个位置）使用synchronized锁。
  - 使用CAS操作保证原子性。
示例：
```
Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put("A", 1);
concurrentMap.put("B", 2);
```

ConcurrentHashMap如何保证线程安全？

答案：
- 在JDK 1.7中，ConcurrentHashMap使用分段锁（Segment），每个段独立加锁。
- 在JDK 1.8中，ConcurrentHashMap使用CAS（Compare-And-Swap） + synchronized实现线程安全。
  - 对每个桶（数组中的每个位置）使用synchronized锁。
  - 使用CAS操作保证原子性。
示例：
```
Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put("A", 1);
concurrentMap.put("B", 2);
```

如何递归遍历目录下的所有文件？

答案：

使用递归方法遍历目录及其子目录。
对于每个文件，如果是目录，则递归调用；如果是文件，则输出文件名。

示例：

public void listFiles(File dir) {if (dir.isDirectory()) {File[] files = dir.listFiles();for (File file : files) {if (file.isDirectory()) {listFiles(file); // 递归} else {System.out.println(file.getName());}}}
}

字节流 vs 字符流的区别？

答案：

字节流：以字节为单位操作数据，适合处理二进制文件（如图片、视频）。
- 核心类：InputStream、OutputStream。
字符流：以字符为单位操作数据，适合处理文本文件。
- 核心类：Reader、Writer。

示例：

// 字节流
try (FileInputStream fis = new FileInputStream("input.txt");FileOutputStream fos = new FileOutputStream("output.txt")) {int data;while ((data = fis.read()) != -1) {fos.write(data);}
}// 字符流
try (FileReader fr = new FileReader("input.txt");FileWriter fw = new FileWriter("output.txt")) {int data;while ((data = fr.read()) != -1) {fw.write(data);}
}

如何实现线程同步？

答案：
- 使用synchronized关键字或ReentrantLock实现线程同步。
- synchronized可以修饰方法或代码块，确保同一时刻只有一个线程访问共享资源。
示例：
```
class Counter {private int count = 0;public synchronized void increment() {count++;}public int getCount() {return count;}
}
```

线程池的核心参数有哪些？

答案：

corePoolSize：核心线程数。
maximumPoolSize：最大线程数。
keepAliveTime：空闲线程存活时间。
workQueue：任务队列。
threadFactory：线程工厂。
handler：拒绝策略。

示例：

ThreadPoolExecutor executor = new ThreadPoolExecutor(2, // corePoolSize5, // maximumPoolSize60, // keepAliveTimeTimeUnit.SECONDS,new LinkedBlockingQueue<>(10),Executors.defaultThreadFactory(),new ThreadPoolExecutor.CallerRunsPolicy()
);

线程池的拒绝策略有哪些？

答案：

AbortPolicy：直接抛出异常。
CallerRunsPolicy：由调用线程处理任务。
DiscardOldestPolicy：丢弃队列中最老的任务。
DiscardPolicy：直接丢弃任务。

示例：

ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 5, 60, TimeUnit.SECONDS,new LinkedBlockingQueue<>(10),Executors.defaultThreadFactory(),new ThreadPoolExecutor.CallerRunsPolicy()
);