Java的Iterator迭代器补充，增强for循环，泛型，List接口，set接口
1、Iterator迭代器：
（1）类型转换异常：ClassCastException；集合中存放的是多个对象时，在强转时会出现；
package com.oracle.demo01; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class demo01 { public static void main(String[] args) { method03(); }public static void method03(){ Collection col = new ArrayList(); col.add("123"); col.add(123); Iterator it = col.iterator(); while(it.hasNext()){ if(it.next() instanceof String){ //这里的两个it.next()不是一个 String s = (String)it.next(); System.out.println(s); } } } }
会出现以下异常：
（2）添加泛型避免异常；在编译时期出现编译失败；
与上面对比：
package com.oracle.demo01; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class demo01 { public static void main(String[] args) { Collection<String> col = new ArrayList<String>(); col.add("abc"); col.add("def"); Iterator<String> it = col.iterator(); while(it.hasNext()){ System.out.println(it.next()); } method03(); } public static void method03(){ Collection col = new ArrayList(); col.add("123"); col.add(123); Iterator it = col.iterator(); while(it.hasNext()){ if(it.next() instanceof String){ String s = (String)it.next(); System.out.println(s); } } } }
效果如下：
当添加元素时：The method add(String) in the type Collection<String> is not applicable for the arguments (int)
（3）并发修改异常：ConcurrentModificationException；对集合进行增删操作；
迭代器不知道集合中的变化,容易发生调用的不确定性，[ListIterator了解即可]
public class ListIteratorDemo { public static void main(String[] args) { List list = new ArrayList(); list.add("one"); list.add("two"); list.add("three"); list.add("five"); /*for(Iterator it = list.iterator(); it.hasNext();){ Object obj = it.next(); if(obj.equals("five")){ 在迭代过程中,如果使用了集合的方法进行增删改查操作,那么迭代器会抛出异常. 原因是,迭代器不知道集合中的变化,容易发生调用的不确定性. 解决办法: 在迭代时,不要使用集合的方法进行操作元素. 可以使用迭代器的子接口ListIterator<E>中的方法就可以. 里面有很多操作元素的方法.而且可以正向迭代,反向迭代. * //list.add("four"); // 异常 ConcurrentModificationException } System.out.println(obj); }*/ //用ListIterator重新解决问题 for(ListIterator it = list.listIterator(); it.hasNext();){ Object obj = it.next(); if("three".equals(obj)){ it.add("four"); //[one, two, three, four, five] // it.set("3"); //[one, two, 3, five] //对比输出结果 } } System.out.println(list); } }
2、增强for循环：
（1）for(元素的数据类型 变量:Collection集合or数组){ }；
package com.oracle.demo01; import java.util.ArrayList; import java.util.Collection; public class demo03 { public static void main(String[] args) { Collection<demo02> col = new ArrayList<demo02>(); col.add(new demo02("熊大",12)); col.add(new demo02("熊二",13)); //普通for ArrayList<demo02> list = (ArrayList<demo02>)col; for(int i = 0;i < list.size();i++){ System.out.println(list.get(i)); } //增强for遍历集合 for(demo02 p:col){ System.out.println(p); } } }
效果都是一样的：
（2）无法进行1-100求和等操作；因为目标只能是数组和集合
（3）相当于一个迭代器：不要进行增删操作；
3、泛型：
（1）修饰符 class 类名<代表泛型的变量E> { }
举个例子：
package com.oracle.demo02; public class demo04 <E>{ public static void main(String[] args) { demo04<String> s = new demo04<String>(); } }
（2）将运行时期的ClassCastException，转移到了编译时期变成了编译失败。
避免了类型强转的麻烦；
（3）泛型和注释不进class文件；
4、List接口[有序、可重复]：
（1）并发修改异常解决办法：在迭代时，不要使用集合的方法操作元素；
package com.oracle.demo02; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class demo01 { public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("abc"); list.add("def"); //Iterator 迭代器遍历 Iterator<String> it = list.iterator(); //找到“def”这个元素时，在“def”这个位置添加一个元素叫做ghi while(it.hasNext()){ if(it.next().equals("def")){ list.add("ghi"); } } } }
效果如下：
（2）List集合存储数据的结构：
堆栈：先进后出；压栈；栈的入口、出口都是栈的顶端位置；弹栈；
队列：先进先出；队列的入口、出口各占一侧；
数组：查找元素快；增删元素慢；
链表：多个节点之间，通过地址链接；查找元素慢；增删元素快；
（3）ArrayList集合数据存储的结构是数组结构：查找元素快；增删元素慢
LinkedList集合数据存储的结构是链表结构：查找元素慢；增删元素快；
（4）Vector集合[认识即可]：已被ArrayList替代；
5、set接口[无序、不重复]：
（1）HashSet集合：采用哈希表结构存储数据，保证元素唯一性的方式依赖于：hashCode()与equals()方法
在给哈希表中存放对象时，会调用对象的hashCode方法，算出对象在表中的存放位置，这里需要注意，
如果两个对象hashCode方法算出结果一样，这样现象称为哈希冲突，这时会调用对象的equals方法，
比较这两个对象是不是同一个对象，如果equals方法返回的是true，那么就不会把第二个对象存放在哈希表中，
如果返回的是false，就会把这个值存放在哈希表中；
（2）HashSet集合存储API类时：已经重写了hashCode方法和equals方法，如String类、Integer类等；
HashSet集合存储自定义类时：需要重写hashCode方法和equals方法，来确保HashSet集合中的对象唯一；
举个例子：
建立一个 demo02类：
package com.oracle.demo01; public class demo02 { private String name; private Integer age; public demo02() { super(); } public demo02(String name, Integer age) { super(); this.name = name; this.age = age; } public String toString() { return "demo01 [name=" + name + ", age=" + age + "]"; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((age == null) ? 0 : age.hashCode()); result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; demo02 other = (demo02) obj; if (age == null) { if (other.age != null) return false; } else if (!age.equals(other.age)) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } }
此时再进行存数据时：
package com.oracle.demo01; import java.util.HashSet; public class hash { public static void main(String[] args) { HashSet<demo02> set = new HashSet<demo02>(); set.add(new demo02("a",18)); set.add(new demo02("b",19)); set.add(new demo02("c",20)); set.add(new demo02("a",18)); for(demo02 p:set){ System.out.println(p); } } }
效果如下：
