Iterator接口:主要用于迭代访问(即遍历)collection中的元素。
迭代:即Collection集合元素的通用获取方式。在取元素之前先要判断集合当中有没有元素,如果有,就把这个元素取出来,继续再判断,如果还有就再取出来。一直把集合当中所有的元素取出来为止。这种取出方式专业术语称为迭代。
/*
* java.util.Iterator接口:迭代器(对集合进行遍历)
* 有两个常用的方法:
* boolean hasNext() :判断集合中还有没有下一个元素,有就返回true,没有返回false,如果迭代具有更多元素,则返回 true 。
E next() :返回迭代中的下一个元素。
Iterator迭代器是一个接口,我们无法直接使用,需要使用Iterator接口的实现类对象,获取实现类的方式比较特殊
Collection接口当中有一个方法,叫iterator(),这个方法返回的就是迭代器的实现对象。
Iterator<E> iterator():返回此集合中的元素的迭代器。
迭代器的使用步骤:
1.使用集合当中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)
2.使用Iterator接口当中的方法hashNext判断还有没有下一个元素
3.使用Iterator接口当中的方法next取出集合中的下一个元素
*/
public class Demo01Iterator {
public static void main(String[] args) {
//创建一个集合对象
Collection<String> coll=new ArrayList<>();
//往集合当中添加元素
coll.add("姚明");
coll.add("科比");
coll.add("麦迪");
coll.add("詹姆斯");
coll.add("艾弗森");
/*
* 1.使用集合当中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)
* 注意:
* Iterator<E>接口也是有泛型的,迭代器的泛型跟着集合走,集合是什么泛型,迭代器就是什么泛型。
* */
//多态 接口 实现类
Iterator<String> it = coll.iterator();
/*
* 发现使用迭代器取出集合中元素的代码,是一个重复的过程,所以我们可以使用循环优化
* 不知道集合中有多少元素,使用while循环
* 循环结束的条件,hashNext方法返回false
* */
while(it.hasNext()){ //while循环实现
String e = it.next();
System.out.println(e);
}
System.out.println("===========");
for(Iterator<String> it2=coll.iterator();it2.hasNext();){ //for循环实现
String e=it2.next();
System.out.println(e);
}
/* //2.使用Iterator接口当中的方法hashNext判断还有没有下一个元素
boolean b = it.hasNext();
System.out.println(b);
//3.使用Iterator接口当中的方法next取出集合中的下一个元素
String s = it.next();
System.out.println(s);
b=it.hasNext();
System.out.println(b);//当没有元素时,返回false
s=it.next();
System.out.println(s);//当没有元素,再取出元素时会抛出NoSuchElementException没有元素异常*/
}
}
迭代器的实现原理:
new ArrayList();
创建集合,往集合添加元素并分配索引。
Iterator<String> it = coll.iterator();
获取迭代器的实现类对象,并把指针(索引)指向集合的-1索引。
it.hashNext():判断集合中还有没有下一个元素。
it.next():做了两件事情:1.取出下一个元素,2.会把指针向后移动一位
增强for循环(也称for each循环),专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器,所以在遍历的过程中,不能对集合中的元素进行增删操作。
/* * 增强for循环,底层使用的也是迭代器,使用for循环的格式,简化了迭代器的书写。 * public interface Collection<E> extends Iterable<E>:所有的 单列集合都可以使用增强for * public interface Iterable<T>实现这个接口允许对象成为“for each”语句的目标 * 增强for循环:用来遍历集合和数组 * 格式: * for(集合/数组的数据类型 变量名:集合名/数组名){ * sout(变量名); * } * */ public class Demo02Foreach { public static void main(String[] args) { demo01(); demo02(); } //使用增强for循环遍历集合 private static void demo02() { ArrayList<String> list=new ArrayList<>(); list.add("aaa"); list.add("bbb"); list.add("ccc"); list.add("ddd"); for(String s:list){ System.out.println(s); } } //使用增强for循环遍历数组 private static void demo01() { int [] arr={1,2,3,4,5}; for(int i:arr){ System.out.println(i); } } }
泛型:是一种未知的数据类型,当我们不知道使用什么数据类型的时候,我们可以使用泛型
泛型也可以看作是一个变量,用来接收数据类型
E e:Element元素
T t:Type类型
ArrayList集合在定义的时候,不知道集合中都会存储什么类型的数据,所以类型使用泛型
E:未知的数据类型
public class ArrayList<E>{
public boolean add(E e){}
public E get(int index){}
}
创建集合对象的时候,就会确定泛型的数据类型
会把数据类型作为参数传递,把String赋值给泛型
ArrayList<String> list=new ArrayList<String>();
public class ArrayList<String>{
public boolean add(String e){}
public String get(int index){}
}
public class Demo03Generic { public static void main(String[] args) { //show01(); show02(); } /* * 创建集合对象,使用泛型 * 好处: * 1.避免类型转换的麻烦,存储的是什么类型,取出的就是什么类型 * 2.把运行期异常(代码运行之后会抛出的异常),提升到了编译期(写代码时就会报错) * 弊端: * 泛型是什么类型,就只能存储什么类型的数据 * */ private static void show02() { ArrayList<String> list=new ArrayList<>(); list.add("abc"); // list.add(1); 直接报错,不能存储此类型的数据 Iterator<String> it = list.iterator(); while (it.hasNext()){ String s = it.next(); System.out.println(s+"->"+s.length()); } } /* * 创建集合对象,不使用泛型 * 好处: * 集合不使用泛型,默认的类型就是Object类型,可以存储任意类型的数据 * 弊端: * 不安全,会引发异常*/ private static void show01() { ArrayList list=new ArrayList(); list.add("abc"); list.add(1); //迭代器遍历list集合 //获取迭代器 Iterator it=list.iterator(); //使用迭代器中的方法hasNext和next遍历集合 while(it.hasNext()){ //取出元素也是Object类型 Object obj = it.next(); System.out.println(obj); //想要使用String类特有的方法,length获取字符串的长度,不能使用 多态 Object obj="abc"; //需要向下转型 //会抛出ClassCastException类型转换异常,不能把Integer类型转换为String类型 String s=(String)obj; System.out.println(s.length()); } } }
/* * 定义一个含有泛型的类,模拟ArrayList集合 * 泛型是一个未知的数据类型,当我们不确定什么数据类型的时候,可以使用泛型 * 泛型可以接收任意的数据类型,可以使用Integer,String,Student... * 创建对象的时候确定泛型的数据类型*/ public class GenericClass<E> { private E name; public E getName() { return name; } public void setName(E name) { this.name = name; } }
public class Demo02GenericClass { public static void main(String[] args) { //不写泛型默认为Object类型 GenericClass gc=new GenericClass(); gc.setName("只能是字符串"); Object obj = gc.getName(); //创建GenericClass对象,泛型使用Integer类型 GenericClass<Integer> gc2=new GenericClass<>(); gc2.setName(1); Integer name = gc2.getName(); System.out.println(name); //创建GenericClass对象,泛型使用String类型 GenericClass<String> gc3=new GenericClass<>(); gc3.setName("小明"); String name1 = gc3.getName(); System.out.println(name1); } }
/* * 定义含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间 * 格式: * 修饰符<泛型> 返回值类型 方法名(参数列表(使用泛型)){ * 方法体; * } * 含有泛型的方法,在调用方法的时候确定泛型的数据类型 * 传递什么类型的参数,泛型就是什么类型*/ public class GenericMethod { //定义一个含有泛型的方法 public <M> void method01(M m){ System.out.println(m); } //定义一个含有泛型的静态方法 public static <S> void method02(S s){ System.out.println(s); } }
/* * 测试含有泛型的方法*/ public class Demo04GenericMethod { public static void main(String[] args) { //创建GenericMethod对象 GenericMethod gm=new GenericMethod(); /* * 调用含有泛型的方法method01 * 传递什么类型,泛型就是什么类型 * */ gm.method01(10); gm.method01("abc"); gm.method01(8.8); gm.method01(true); gm.method02("静态方法,不建议创建对象使用"); //静态方法,通过类名.方法名(参数),可以直接使用 GenericMethod.method02("静态方法"); GenericMethod.method02(12); } }
定义和使用含有泛型的接口:
/* * 定义含有泛型的接口*/ public interface GenericInterface<I> { public abstract void method(I i); }
/* * 含有泛型的接口,第一种使用方式;定义接口的实现类,实现接口,指定接口的泛型 * public interface Iterator<E>{ * E next(); * } * Scanner类实现了Iterator接口,并制定接口的泛型为String,所以重写的next方法泛型默认就是String * public final class Scanner implements Iterator<String>{ * * }*/ public class GenericInterfaceImpl implements GenericInterface<String> { @Override public void method(String s) { System.out.println(s); }
/* * 含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走 * 相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型 * public interface List<E>{ * boolean add(E e); * E get(int index); * } * public class ArrayList<E> implements List<E>{ * public boolean add(E e){} * public E get(int index){} * }*/ public class GenericInterfaceImpl2<I> implements GenericInterface<I>{ @Override public void method(Object o) { System.out.println(o); } }
/* * 测试含有泛型的接口 * */ public class Demo05GenericInterface { public static void main(String[] args) { //创建GenericInterfaceImpl对象 GenericInterfaceImpl gi1=new GenericInterfaceImpl(); gi1.method("字符串"); //创建GenericInterfaceImpl2对象 GenericInterfaceImpl2<Integer> gi2=new GenericInterfaceImpl2<>(); gi2.method(10); GenericInterfaceImpl2<Double> gi3=new GenericInterfaceImpl2<>(); gi3.method(8.8); } }
泛型通配符:
泛型的通配符:不知道使用什么类型来接收数据的时候,此时可以使用?,?表示未知通配符。
此时只能接受数据,不能玩该集合中存储数据。
/* * 泛型的通配符: * ?:代表任意的数据类型 * 使用方式,不能创建对象使用 * 只能作为方法的参数使用 * */ public class Demo06Generic { public static void main(String[] args) { ArrayList<Integer> list01=new ArrayList<>(); list01.add(1); list01.add(2); list01.add(3); list01.add(4); ArrayList<String> list02=new ArrayList<>(); list02.add("a"); list02.add("b"); printArray(list01); printArray(list02); //ArrayList<?> list03=new ArrayList<?>();//报错,不能在定义时直接使用 } //定义一个方法,能遍历所有的类型的ArrayList集合 //这时我们不知道ArrayList集合使用什么数据类型,可以使用泛型的通配符?来接收数据 //泛型是没有继承概念的 public static void printArray(ArrayList<?> list){ //使用迭代器遍历集合 Iterator<?> it = list.iterator(); while(it.hasNext()){ //it.next()方法取出的元素是Object,可以接受任意的数据类型 Object o=it.next(); System.out.println(o); } } }
/* * 泛型的上限限定:? extends E 代表使用的泛型只能是E类型的子类/本身 * 泛型的下限限定:? super E 代表使用的泛型只能是E类型的父类/本身 * */
//泛型的上限:此时的泛型?,必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
//泛型的下限:此时的泛型?,必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}