/**

* iterator迭代器 Collection接口继承了Iterable接口 iterable可迭代的 在Iterable接口中定义了iterator()方法用于生成迭代器

* Collection接口的所有实现类都实现了iterator()方法，可以通过迭代器来对Collection容器进行遍历

*/

public class TestIterator1 {

public static void main(String[] args) {

LinkedList<String> ll1= new LinkedList<>();

ll1.addFirst("a");

ll1.addLast("b");

ll1.addLast("c");

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

System.out.print(ll1.get(i));

}

//利用index遍历

System.out.println();

for (String l :

ll1) {

System.out.print(l);

}

//利用for-each遍历

System.out.println();

Iterator<String> it1 = ll1.iterator();

//.iterator()方法生成一个新的迭代器对象并返回 迭代器类型为Iterator接口的实现类 迭代器使用游标来实现迭代的操作

//Iterator<E>泛型接口 将泛型设为元素的类型

while(it1.hasNext()){

//Iterator接口的方法.hasNext() 判断游标当前指向的位是否为有元素 有元素true null则false

// 在集合中最后一个元素的下一位为null 指向null即完成了集合的遍历

System.out.print(it1.next());

//Iterator接口的方法.next() 返回游标当前指向的元素并将游标指向下一位 相当于同时完成了.get(i)和i++两个操作

it1.remove();

//移除.next()返回的元素 .remove()方法在.next()方法后面只能使用一次

}

//结果为abc

System.out.println();

System.out.println(ll1);

//容器结果为[] 所有元素都被移除了

ll1.add("d");

ll1.add("e");

ll1.add("f");

for (Iterator<String> it = ll1.iterator();it.hasNext();){

//迭代器为一次性的 每次游标移至null无法再使用 可以通过.iterator()再生成一个新的迭代器

//将迭代器的声明放在for循环中，循环条件为.hasNext() 迭代因子空置因为.next()已经实现了

String e = it.next();

System.out.print(e);

}

//结果为def

System.out.println();

//所有实现了Iterable的集合使用iterator的方法都是一样的，Set实现类也通过如上操作使用迭代器

//Map接口没有继承Iterable，不能直接使用迭代器，但Map接口提供了.keySet()和.entrySet()方法，两种方法都返回set集合，可以通过set集合的迭代器对Map间接遍历

Map<String,Integer> hm = new HashMap<>();

hm.put("zhang",59);

hm.put("zhao",61);

hm.put("li",99);

Set<String> nameSet = hm.keySet();

Iterator<String> it2 = nameSet.iterator();

//通过map集合生成所有key的集合，用过key的集合生成集合的迭代器

while (it2.hasNext()){

String name = it2.next();

//拿到的name即map的key

System.out.print(name+"="+hm.get(name)+",");

//通过.get(key)返回value

}

//结果为zhao=61,zhang=59,li=99,

System.out.println();

Set<Map.Entry<String,Integer>> entries = hm.entrySet();

//.entrySet()返回的是Set集合，集合的泛型为<Map.Entry Entry是Map的内部接口，需要通过Map.调用 Map.Entry的泛型为<String,Integer> 所以需要套两层泛型

for (Iterator<Map.Entry<String,Integer>> it = entries.iterator();it.hasNext();){

//迭代器的类型为Iterator<>，是Set集合的迭代器，集合内装的元素为Map.Entry 所以迭代器的泛型同样为<Map.Entry<String,Integer>>

Map.Entry<String,Integer> entry = it.next();

System.out.print(entry.getKey()+"="+entry.getValue()+",");

//需要分别调用getKey和getValue，如果直接打印it.next().getKey()+it.next().getValue()会打印当前key和下一个value

}

//结果为zhao=61,zhang=59,li=99,

System.out.println();

}

}

class TestRemove{

//容器的删除操作

public static void main(String[] args) {

List<Integer> arr = new ArrayList<>();

arr.add(0);

arr.add(1);

arr.add(2);

arr.add(3);

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

arr.remove(2);

System.out.println(arr);

}

//结果为[0, 1, 3] [0, 1]

//迭代器以外的循环遍历中不可以删除元素，当i=0时删除index=2，后面的元素3前移，size-1，i=1时再次删除index=2，size变为2，如果原始容器为0,1,2的话在第二次循环时index=2=size索引越界会抛异常

//这里如果循环条件没有使用.size()而直接使用长度4的话当size变小时会出现i>size的情况同样会索引越界

arr.add(5);

arr.add(6);

arr.add(7);

arr.add(5);

arr.add(8);

arr.add(5);

System.out.println(arr+"[0, 1, 5, 6, 7, 5, 8, 5]");

while (arr.remove(Integer.valueOf(5))){

//利用.remove(Object o)方法删除元素返回boolean当做循环条件 当返回true即删除了一个5，当返回false即容器中已经没有元素5了

//注意List容器还有.remove(int index)方法返回E element 元素5不能直接写数字，需要转为包装类才能被当做元素

System.out.println(arr);

}

//结果为

//[0, 1, 6, 7, 5, 8, 5]

//[0, 1, 6, 7, 8, 5]

//[0, 1, 6, 7, 8]

//如果将遍历和删除操作放在一个循环语句内执行，会出现索引越界或者遍历跳过部分元素的情况

List<Integer> ind1 = new ArrayList<>();

//创建一个容器用于存储要删除的元素的索引

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

if (arr.get(i)==6){

ind1.add(i);

//当元素为6时将索引记录下来

}

}

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

arr.remove(ind1.get(i));

//ind1.get(i)返回存储的要删除的索引值，在arr容器遍历循环之外可以安全删除元素

}

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

// while (arr.get(i)==8){

// arr.remove(i);

// }

// System.out.println(arr.get(i));

// //报错 索引越界 元素8为容器中最后一位 删除8之后当前索引i已经越界，当调用get(i)时抛出异常

// }

//删除操作容易造成索引越界

System.out.println(arr+"[0, 1, 6, 7, 8]");

List<String> str = new ArrayList<>();

str.add("a");

str.add("b");

str.add("c");

str.add("d");

// for (String s :

// str) {

// if ("b".equals(s)) {

// str.remove(s);

// }

// }

/* 报异常

Exception in thread "main" java.util.ConcurrentModificationException

at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:911)

at java.util.ArrayList$Itr.next(ArrayList.java:861)

at TestRemove.main(TestIterator1.java:148)

//if (modCount != expectedModCount) {throw new ConcurrentModificationException();}

//modCount修改计数器 expected预期的 concurrent同时发生的/并发 modification修改

//for-each遍历中无法删除元素 也无法add添加元素 ArrayList$Itr是ArrayList类的$内部类Itr

//private class Itr implements Iterator<E> for-each是使用迭代器iterator实现遍历

*/

Iterator<String> iter1 = str.iterator();

while (iter1.hasNext()){

String e = iter1.next();

if ("d".equals(e)){

iter1.remove();

//.remove()方法删除next方法返回的元素，而非next方法调整游标后移之后游标指向的元素

}

}

System.out.println(str);

//结果为[a, b, c]

// for (Iterator<String> iter2 = str.iterator();iter2.hasNext();){

// if ("c".equals(iter2.next())){

// str.add("d");

// }

// }

//报异常ConcurrentModificationException 使用迭代器遍历时无法添加元素 for-each使用迭代器实现所以遍历时也无法添加元素

}

}