【java基础 13】两种方法判断hashmap中是否形成环形链表

本文介绍了两种检测链表中是否存在环的方法:丢手绢法(指针追赶法)和迷路法(查表法)。通过生动的例子解释了两种方法的基本思想,并提供了具体的Java实现代码。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

导读:额,我介绍的这两种方法,有点蠢啊,小打小闹的那种,后来我查了查资料,别人都起了好高大上的名字,不过,本篇博客,我还是用何下下的风格来写。两种方法,一种是丢手绢法,另外一种,是迷路法。

 

这两种方法的基本思想:假设有环(顿时想到了三个数中找最大的,假设一个最大值有木有,更有木有想到一个排序算法呢?)

 

一、丢手绢法(指针追赶法)

其实,这种方法时有个很高大上的名称的,叫做指针追赶法。不过,我刚开始想了半天没想明白,后来等我想明白了之后,哇塞,其实思想就是我小时候玩得丢手绢的游戏。

趣说指针追赶法:想象一下小时候玩丢手绢,自己是怎么死的?你妹的,就一个圈,往一个方向跑,自己跑的比别人慢,还没跑几步,然后就被追上了。反例:要是这不是一个圈,咱俩从一个地方往一个方向跑,你老人家跑的比我快,能追上不?(PS:想不明白的,就往死了想玩丢手绢是怎么死的。短跑健将抓小偷,是怎么跑到小偷前面被小偷嘲笑的)

好了,思想说完了,看看代码:

 

public class stringTest {

	/**
	 * 内部类,模拟链表
	 * @author AngelHHX
	 *
	 */
	public static class Node{  
        int value;  
        Node next;  
        public Node(int n){  
            this.value=n;  
            this.next=null;  
        }  
    } 
	
	public static boolean hasLoop(Node n){
		
		//定义两个指针,一个每次走一步,一个每次走两步
		Node Point1=n;
		Node Point2=n.next;
		
		while(Point2!=null){
			Point1=Point1.next;//每次走一步
			Point2=Point2.next.next;//每次走两步
			if(Point2==null) return false;//不存在环
			
			int value1=Point1.value;
			int value2=Point2.value;
			if(value1==value2) return true;//存在环
		}
		
		return false;//当Point2为null,证明这个链表中只有一个元素
	}
	
	public static void main(String[] agrs) {
		
		Node n1 = new Node(1);
		Node n2 = new Node(2);
		Node n3 = new Node(3);

		n1.next = n2;
		n2.next = n3;
		n3.next = n1;//构造一个带环的链表,去除此句表示不带环

		System.out.println(hasLoop(n1));
	}
}

 

 

二、迷路法(查表法)

这个方法的基本思想,真的跟我这个人有关,想明白这个方法的内涵,只需要我自己出门走一圈就OK了! 题外话啊,有小时候看过《少年包青天》的不?里面有一集,就是展昭中毒的那一集,然后公孙策和香香走进了一个树林里,她俩迷路了,然后香香扯那个裙子绑树上打标记,结果走着走着就又回到了原地!

额,想想自己迷路的时候,如果你发现你走了好久,结果又回到了某一个地方,内心崩溃:我他妈的走了半天,竟然还在原地打圈圈!(反正我是这样的)然后再想想数据结构中图的简单回路那一节内容,好好体会吧。

简单说来,就是将指针每走的一个节点记录下来,然后每次走一个节点,就去记录里面查,如果发现重复了,那么恭喜你,迷路了。(链表有环)

代码如下:

 

import java.util.HashMap;


public class stringTest {

	/**
	 * 内部类,模拟链表
	 * @author AngelHHX
	 *
	 */
	public static class Node{  
        int value;  
        Node next;  
        public Node(int n){  
            this.value=n;  
            this.next=null;  
        }  
    } 
	
	public static boolean hasLoop(Node n){
		
		Node Point1=n;
		HashMap<Node,Node> HM=new HashMap<Node,Node>();
		
		while(n!=null){
			if(HM.get(Point1)!=null) return true;
			else HM.put(Point1, Point1);
			Point1=Point1.next;
			if(Point1==null) return false;
		}
		
		return false;
	}
	
	public static void main(String[] agrs) {
		
		Node n1 = new Node(1);
		Node n2 = new Node(2);
		Node n3 = new Node(3);

		n1.next = n2;
		n2.next = n3;
		n3.next = n1;//构造一个带环的链表,去除此句表示不带环

		System.out.println(hasLoop(n1));
	}
}

 

 

 

 

 

三、总结

 

以上就是关于是否有环的判断,突然有一种感觉,生活远远比写代码复杂的多!写代码真的跟生活经历有关,好好去体验生活,去经历,真的会很好!接下来的工作,就是把我草稿箱的那些要写的博客都写完,然后看看书!

对于java基础的东西,尤其是数据结构和算法方面的,自己真心比较弱,还请大家多多指教!PS:我这么一直看书,一直总结,在做项目的时候,再思考思考,有没有感觉到,我这是下次考数据结构,必过的节奏啊。。。。。。。。。。

<think>我们之前已经讨论过Java HashMap在并发编程中的问题以及解决方案。现在,我将根据你的要求,再次详细回答“java hashmap并发编程”的问题,并按照指定的格式进行回答。 ### Java HashMap 并发编程问题详解 HashMap 不是线程安全的,因此在多线程境下使用可能会导致数据不一致、死循(在JDK 1.7中)以及ConcurrentModificationException等问题。 #### 解决方案 以下是几种常见的线程安全替代方案: ##### 1. 使用 `ConcurrentHashMap`(推荐) `ConcurrentHashMap` 是Java提供的线程安全的哈希表实现,它通过分段锁(JDK 1.7)或CAS+synchronized(JDK 1.8)来实现高并发。 ```java import java.util.concurrent.ConcurrentHashMap; public class ConcurrentHashMapDemo { public static void main(String[] args) { ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>(); // 多个线程并发写操作 Thread writer1 = new Thread(() -> { for (int i = 0; i < 100; i++) { map.put("A" + i, i); } }); Thread writer2 = new Thread(() -> { for (int i = 0; i < 100; i++) { map.put("B" + i, i); } }); writer1.start(); writer2.start(); try { writer1.join(); writer2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Map size: " + map.size()); } } ``` **解释**: - `ConcurrentHashMap` 的put操作是线程安全的,多个线程可以同时写入而不会导致数据不一致。 - 在JDK 1.8中,它使用Node数组+链表+红黑树,并且使用CAS和synchronized来保证线程安全,锁的粒度是每个数组元素(桶)。 - 上述代码中,两个线程分别向map中写入100个元素,最后输出map的大小应该是200(如果无冲突)。 ##### 2. 使用 `Collections.synchronizedMap` 该方法将普通的HashMap包装成一个同步的Map,所有方法都使用同一个互斥锁进行同步。 ```java import java.util.Collections; import java.util.HashMap; import java.util.Map; public class SynchronizedMapDemo { public static void main(String[] args) { Map<String, Integer> syncMap = Collections.synchronizedMap(new HashMap<>()); Thread writer1 = new Thread(() -> { for (int i = 0; i < 100; i++) { syncMap.put("A" + i, i); } }); Thread writer2 = new Thread(() -> { for (int i = 0; i < 100; i++) { syncMap.put("B" + i, i); } }); writer1.start(); writer2.start(); try { writer1.join(); writer2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Map size: " + syncMap.size()); } } ``` **解释**: - 通过`Collections.synchronizedMap`返回的Map,其每个方法都是同步的,因此多个线程同时调用这些方法时,会互斥执行。 - 但是,这种方式在高并发境下性能较差,因为所有操作都需要竞争同一把锁。 - 注意:复合操作(如检查再插入)仍然需要额外的同步。 ##### 3. 使用显式锁(例如 `ReentrantReadWriteLock`) 当需要更细粒度的控制时,可以使用读写锁。 ```java import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; public class ReadWriteLockDemo { private final Map<String, Integer> map = new HashMap<>(); private final ReadWriteLock rwLock = new ReentrantReadWriteLock(); public void put(String key, Integer value) { rwLock.writeLock().lock(); try { map.put(key, value); } finally { rwLock.writeLock().unlock(); } } public Integer get(String key) { rwLock.readLock().lock(); try { return map.get(key); } finally { rwLock.readLock().unlock(); } } public static void main(String[] args) { ReadWriteLockDemo demo = new ReadWriteLockDemo(); Thread writer1 = new Thread(() -> { for (int i = 0; i < 100; i++) { demo.put("A" + i, i); } }); Thread writer2 = new Thread(() -> { for (int i = 0; i < 100; i++) { demo.put("B" + i, i); } }); writer1.start(); writer2.start(); try { writer1.join(); writer2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Map size: " + demo.map.size()); } } ``` **解释**: - 使用`ReadWriteLock`,读操作可以共享锁,写操作独占锁,适合读多写少的场景。 - 写操作使用写锁,保证同时只有一个线程写;读操作使用读锁,允许多个线程同时读。 - 这种方式需要手动管理锁,增加了代码复杂度,但提供了更高的灵活性。 ### 总结 - 在并发境中,避免直接使用非线程安全的`HashMap`。 - 优先考虑`ConcurrentHashMap`,因为它提供了更好的并发性能。 - 如果不需要高并发,可以使用`Collections.synchronizedMap`。 - 对于特殊需求,如读写分离,可以使用显式锁。 §§相关问题§§: 1. ConcurrentHashMap在JDK1.7和JDK1.8中的实现有什么不同? 2. 为什么ConcurrentHashMap不能完全替代Hashtable? 3. 在ConcurrentHashMap中,如何实现原子操作(如putIfAbsent)? 4. 解释ConcurrentHashMap的弱一致性迭代器是什么意思?</think>### Java HashMap 并发编程详解 HashMap 在并发境下存在严重安全问题,主要问题包括: 1. **数据竞争**:多线程同时修改导致数据丢失或不一致 2. **死循**:JDK 1.7 扩容时链表可能形成形结构 3. **ConcurrentModificationException**:迭代时修改触发快速失败机制 以下是完整的解决方案和代码实现: #### 1. 使用 ConcurrentHashMap(最佳实践) ```java import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ConcurrentHashMapDemo { public static void main(String[] args) { ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>(); ExecutorService executor = Executors.newFixedThreadPool(10); // 并发写入 for (int i = 0; i < 1000; i++) { final int taskId = i; executor.submit(() -> { String key = "key-" + taskId % 100; // 原子更新 concurrentMap.merge(key, 1, Integer::sum); }); } executor.shutdown(); while (!executor.isTerminated()); // 等待所有任务完成 System.out.println("Final map size: " + concurrentMap.size()); System.out.println("Total count: " + concurrentMap.values().stream().mapToInt(Integer::intValue).sum()); } } ``` **代码解释**: - 使用 `ConcurrentHashMap` 替代 HashMap - `merge()` 方法实现原子更新(避免检查后更新问题) - 线程池模拟高并发写入场景 - 输出验证数据完整性(所有写入操作都被正确处理) #### 2. 使用 Collections.synchronizedMap(传统方案) ```java import java.util.*; public class SynchronizedMapDemo { public static void main(String[] args) { Map<String, Integer> syncMap = Collections.synchronizedMap(new HashMap<>()); List<Thread> threads = new ArrayList<>(); for (int i = 0; i < 100; i++) { final int threadId = i; Thread t = new Thread(() -> { synchronized (syncMap) { // 必须手动同步复合操作 if (!syncMap.containsKey("counter")) { syncMap.put("counter", 0); } syncMap.put("counter", syncMap.get("counter") + 1); } }); threads.add(t); t.start(); } // 等待所有线程完成 for (Thread t : threads) { try { t.join(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("Final counter: " + syncMap.get("counter")); } } ``` **代码解释**: - `Collections.synchronizedMap` 包装普通 HashMap - 必须使用 `synchronized` 块保护复合操作(检查→更新) - 性能低于 ConcurrentHashMap(全表锁) - 适合低并发简单场景 #### 3. 使用 ReadWriteLock(自定义并发控制) ```java import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.*; public class ReadWriteLockMap<K, V> { private final Map<K, V> map = new HashMap<>(); private final ReadWriteLock rwLock = new ReentrantReadWriteLock(); private final Lock readLock = rwLock.readLock(); private final Lock writeLock = rwLock.writeLock(); // 写操作 public V put(K key, V value) { writeLock.lock(); try { return map.put(key, value); } finally { writeLock.unlock(); } } // 读操作 public V get(K key) { readLock.lock(); try { return map.get(key); } finally { readLock.unlock(); } } // 原子更新 public V compute(K key, java.util.function.BiFunction<? super K, ? super V, ? extends V> remap) { writeLock.lock(); try { return map.compute(key, remap); } finally { writeLock.unlock(); } } } ``` **代码解释**: - 读写锁分离:允许多个读线程同时访问 - 写操作需要独占锁 - 实现 `compute()` 方法支持原子更新 - 适合读多写少且需要自定义逻辑的场景 ### 关键问题分析 1. **JDK 1.7 死循问题**: - 原因:扩容时链表反转导致形引用 - 解决:升级到 JDK 1.8+(使用尾插法替代头插法) 2. **ConcurrentHashMap 优势**: - JDK 1.8 使用 CAS + synchronized 桶级锁 - 并发度 = 桶数量(默认16) - 提供原子方法:`computeIfAbsent`, `merge`, `search` 等 3. **性能对比**: ```mermaid graph LR A[并发需求] -->|高并发写| B(ConcurrentHashMap) A -->|读多写少| C(ReadWriteLock) A -->|简单低并发| D(SynchronizedMap) ``` ### 最佳实践建议 1. JDK 1.8+ 境下首选 `ConcurrentHashMap` 2. 使用原子方法避免显式同步: ```java // 安全替代方案 concurrentMap.computeIfAbsent(key, k -> new AtomicInteger()).incrementAndGet(); ``` 3. 避免在迭代中修改集合(使用 `ConcurrentHashMap` 的弱一致性迭代器) 4. 高并发场景考虑分片:`Map<String, ConcurrentHashMap> shards = new ConcurrentHashMap<>();`
评论 11
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值