• java集合类遍历删除方法测试以及使用场景记录


    package test0;
    
    import java.util.List;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.Set;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.LinkedList;
    
    
    /**
     * 测试集合类遍历删除方法
     * 目前是基本的遍历方式,没有包含java8里面的遍历方式
     */
    public class Test2 {
    
    	public static void main(String[] args) {
    		forEach();
    		operateList();
    		operateSet();
    		operateMap();
    
    	}
    
    	
    	/**
    	 * JDK1.5中,应用新特性For-Each循环,通用遍历读取所有集合类的方法,但是不能删除,
    	 * For-Each语法最终被编译器转为了对Iterator.next()的调用,所以应该和Iterator性能差不多
    	 * 现在测试到数据量很大的时候,比如上千万数据时,性能差距才会出来
    	 * 如果在遍历是修改集合类,将会抛出java.util.ConcurrentModificationException异常
    	 * 例如:
    	 * Exception in thread "main" java.util.ConcurrentModificationException
         * at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
         *at java.util.ArrayList$Itr.next(Unknown Source)
         *at Test.main(Test.java:12)
    	 */
    	public static void forEach() {
    		// list
    		ArrayList<Integer> arr = new ArrayList<Integer>();
    		arr.add(1);
    		arr.add(2);
    		for (Integer i : arr) {
    			System.out.println("for each list: " + i);
    		}
    
    		// set
    		HashSet<Integer> hs = new HashSet<Integer>();
    		hs.add(3);
    		hs.add(4);
    		for (Integer i : hs) {
    			System.out.println("for each set: " + i);
    		}
    
    		// map
    		HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
    		hm.put(5, 5);
    		hm.put(6, 6);
    		for (Entry<Integer, Integer> entry : hm.entrySet()) {
    			System.out.println("for each map:  <" + entry.getKey() + "," + entry.getValue() + ">");
    		}
    
    	}
    	
    	/*
    	 list接口复杂度
    	                          | Arraylist | LinkedList
    	------------------------------------------
    	get(index)           |    O(1)   |   O(n)
    	add(E)                 |    O(n)   |   O(1)
    	add(E, index)       |    O(n)   |   O(n)
    	remove(index)     |    O(n)   |   O(n)
    	Iterator.remove() |    O(n)   |   O(1)
    	Iterator.add(E)     |    O(n)   |   O(1)
    	
    	 */
    	
    	/**
    	 * 操作list
    	 * LinkedList 是链表形式,使用于 遍历list并删除元素方法2 效率更高
    	 * ArrayList 是数组形式,两种方法差不了多少
    	 * 
    	 */
    	public static void operateList() {
    		final int size = 10;
    		List<Integer> list = new ArrayList<Integer>();
    		for (int i = 0; i < size; i++) {
    			list.add(3);
    		}
    
    		// 遍历list并删除元素方法1
    		for (int i = list.size() - 1; i >= 0; i--) {
    			if (list.get(i) == 3) {
    				list.remove(i);
    			}
    		}
    
    		for (int i = 0; i < size; i++) {
    			list.add(3);
    		}
    
    		// 遍历list并删除元素方法2
    		for (Iterator<Integer> it = list.iterator(); it.hasNext();) {
    			Integer e = it.next();
    			if (e.equals(3)) {
    				it.remove();
    			}
    		}
    	}
    
    	/**
    	 * 操作集合
    	 */
    	public static void operateSet() {
    		final int size = 10;
    		Set<Integer> set = new HashSet<Integer>();
    		for (int i = 0; i < size; i++) {
    			set.add(i);
    		}
    
    		// 遍历set并删除元素方法
    		for (Iterator<Integer> it = set.iterator(); it.hasNext();) {
    			Integer e = it.next();
    			if (e.equals(3) || e.equals(4)) {
    				it.remove();
    			}
    		}
    	}
    
    	
    	/**
    	 * 操作map,根据需求选择遍历方法,少量数据时不好对比性能出差距,需要上百万数据才容易比较出效果 
    	 * 1.entrySet遍历法:key value都需要时:key value都一直需要取出来时使用性能更高 
    	 * 2. keySet遍历法:key value都需要时:主要使用key,少量使用value时使用性能更高
    	 * 3.values遍历value,这个没有得到key,但是也是可以删除的:主要使用value时使用
    	 * 
    	 * 注意:
    	 * 由于HashMap使用hash算法存储,所以时间复杂度为O(1),
    	 * 而TreeMap使用红黑树存储,时间复杂度为O(logN),
    	 * 所以假如一直需要key value的话,TreeMap使用entrySet遍历法效率将更高,而HashMap性能区别没有那么明显
    	 */
    	public static void operateMap() {
    		final int size = 10;
    		Map<Integer, Integer> map = new HashMap<Integer, Integer>();
    		for (int i = 0; i < size; i++) {
    			map.put(i, i);
    		}
    
    		// 1.entrySet遍历法
    		for (Iterator<Entry<Integer, Integer>> it = map.entrySet().iterator(); it.hasNext();) {
    			Entry<Integer, Integer> e = it.next();
    			Integer key = e.getKey();
    			Integer value = e.getValue();
    			if (key.equals(3) || key.equals(4)) {
    				it.remove();
    			}
    		}
    
    		// 2. keySet遍历法
    		for (Iterator<Integer> it = map.keySet().iterator(); it.hasNext();) {
    			Integer key = it.next();
    			if (key.equals(5) || key.equals(6)) {
    				// Integer value = map.get(key);
    				it.remove();
    			}
    		}
    
    		// 3.values遍历value,这个没有得到key,但是也是可以删除的
    		for (Iterator<Integer> it = map.values().iterator(); it.hasNext();) {
    			Integer value = it.next();
    			if (value.equals(7) || value.equals(8)) {
    				// Integer value = map.get(key);
    				it.remove();
    			}
    		}
    		System.out.println("operateMap: " + map);
    	}
    
    }
    

      

  • 相关阅读:
    Nginx--sub_filter模块
    Scala学习5 objext
    Scala学习4 Class
    Scala学习3 Map
    Scala学习2 Array、ArrayBuffer
    Scala学习1 基本数据类型,条件,循环
    flink1.9新特性:维表Join解读
    Blink源码编译
    Flink Maven项目兼容多版本Kafka
    Ant build.xml程序简单说明
  • 原文地址:https://www.cnblogs.com/dongguol/p/5855571.html
Copyright © 2020-2023  润新知