java set 循环删除_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 arr = new ArrayList();

arr.add(1);

arr.add(2);

for (Integer i : arr) {

System.out.println("for each list: " + i);

}

// set

HashSet hs = new HashSet();

hs.add(3);

hs.add(4);

for (Integer i : hs) {

System.out.println("for each set: " + i);

}

// map

HashMap hm = new HashMap();

hm.put(5, 5);

hm.put(6, 6);

for (Entry entry : hm.entrySet()) {

System.out.println("for each map: ");

}

}

/*

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 list = new ArrayList();

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 it = list.iterator(); it.hasNext();) {

Integer e = it.next();

if (e.equals(3)) {

it.remove();

}

}

}

/**

* 操作集合

*/

public static void operateSet() {

final int size = 10;

Set set = new HashSet();

for (int i = 0; i < size; i++) {

set.add(i);

}

// 遍历set并删除元素方法

for (Iterator 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 map = new HashMap();

for (int i = 0; i < size; i++) {

map.put(i, i);

}

// 1.entrySet遍历法

for (Iterator> it = map.entrySet().iterator(); it.hasNext();) {

Entry e = it.next();

Integer key = e.getKey();

Integer value = e.getValue();

if (key.equals(3) || key.equals(4)) {

it.remove();

}

}

// 2. keySet遍历法

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

}

}