当前位置： 首页 > news >正文

一个主机可以放几个网站上海今天发生的重大新闻

news 2025/7/2 1:21:30
一个主机可以放几个网站,上海今天发生的重大新闻,资深的家居行业网站模板,WordPress小程序二次修改集合框架 Java集合框架是面试中的重中之重，尤其是对List、Set、Map的实现类及其底层原理的考察。 1. List ArrayList： 底层是动态数组，支持随机访问（通过索引），时间复杂度为O(1)。插入和删除元素时&#…

集合框架

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用于操作文件和目录，常见操作包括创建、删除、重命名、遍历等。

常见面试问题：

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

    • 使用递归或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());}}}
}

  2. 如何读取大文件？

    • 使用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。

常见面试问题：

  1. 字节流 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);}
}

  2. 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并发编程的核心，面试中常考线程的创建、生命周期、同步机制等。

常见面试问题：

  1. 如何实现线程同步？

    • 使用synchronized关键字或ReentrantLock。

    案例：

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

  2. 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的参数和原理的考察。

常见面试问题：

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

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

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

    • 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用于快速查找数据。

    实现步骤：

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

    示例：

    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()
);

哈希表核心原理

http://www.wooajung.com/news/30369.html

相关文章：

  • 网站架构设计师薪资水平人员优化方案怎么写
  • 全国专业做美术网站的公司如何创建属于自己的网站
  • 中央气象台卫星云图seo算法优化
  • 知乎网站怎么做推广沈阳沈河seo网站排名优化
  • WordPress moe acg深圳网站关键词优化公司
  • 网站建设 云计算免费网站安全软件下载
  • 著名的淘宝客网站360收录提交入口
  • 济南网站自然优化驻马店百度seo
  • 怎么做电商运营的基本步骤seo和sem
  • 长沙网站建站南宁seo外包服务
  • asp网站上传到服务器上之后一打开就是download网络营销公司全网推广公司
  • 网站制作公透明清晰百度关键词优化软件网站
  • 网站建设费用是多少怎么样建一个网站
  • 网站下拉菜单代码云南网站推广公司
  • 做投注网站多少钱最近一周的新闻
  • 建设银行网站维护百度搜索风云榜总榜
  • 贵阳做网站优化域名注册网站系统
  • 深圳网站建设吗成都网站建设系统
  • 南昌网站建设利润公司怎么做网络营销
  • 校园内部网站平台建设方案产品seo基础优化
  • 苏州做网站多少钱广州seo托管
  • 做网站怎么投放广告免费个人网站平台
  • 如何识别网页用什么网站做的外贸推广优化公司
  • 在线做h5 的网站安徽网站推广公司
  • 宿迁环保局网站建设局qq群排名优化软件购买
  • 上海 网站建设大连网站推广
  • 新疆建设云网站施工图审查上海百度推广开户
  • 淄博做网站公司网站推广技巧
  • 建设游戏运营网站开展工作内容自己搭建网站
  • 一般电商网站做集群深圳网站设计专业乐云seo