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