进阶04 4 Collection集合类+Iterator迭代器+增强for+泛型
2024-06-04 07:09:55
文章目录
- Collection集合
- 集合概述
- java.util.Collection接口
- Iterator迭代器
- Iterator接口
- Iterator接口的常用方法
- 说明
- 迭代器实现原理图：
- 增强for循环-专门用来遍历数组和集合
- 格式:
- 泛型
- 泛型概述
- 使用泛型和不使用的区别
- 定义和使用含有泛型的类
- 含有泛型的方法
- 含有泛型的接口
- 泛型通配符
- 通配符高级使用----受限泛型 （看源码能看懂即可，工作不太使用）
- 集合综合案例
Collection集合
集合概述
在前面基础班我们已经学习过并使用过集合ArrayList ,那么集合到底是什么呢?
- 集合：集合是java中提供的一种容器，可以用来存储多个数据。
集合和数组既然都是容器，它们有啥区别呢？ - 数组的长度是固定的。集合的长度是可变的。
数组中存储的是同一类型的元素，可以存储基本数据类型值。 - 集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。
也就是说，数组可以存储基本类型和对象，集合只能存储集合。
上下是继承关系，ArrayList重点，LinkedList次之
HashList重点，LinkedHashSet次之
java.util.Collection接口
所有单列集合的最顶层的接口,里边定义了所有单列集合共性的方法
任意的单列集合都可以使用Collection接口中的方法
共性的方法:上述所有类型的集合都能用。
public boolean add(E e)： 把给定的对象添加到当前集合中 。public void clear() :清空集合中所有的元素。public boolean remove(E e): 把给定的对象在当前集合中删除。public boolean contains(E e): 判断当前集合中是否包含给定的对象。public boolean isEmpty(): 判断当前集合是否为空。public int size(): 返回集合中元素的个数。public Object[] toArray(): 把集合中的元素，存储到数组中。
public static void main(String[] args) {//创建集合对象,可以使用多态Collection<String> coll = new ArrayList<>();System.out.println(coll);// Collection<String> coll = new HashSet<>();
// System.out.println(coll);//重写了toString方法 []/*public boolean add(E e)： 把给定的对象添加到当前集合中 。返回值是一个boolean值,一般都返回true,所以可以不用接收*/boolean b1 = coll.add("张三");System.out.println("b1:"+b1);//b1:trueSystem.out.println(coll);//[张三]coll.add("李四");coll.add("李四");coll.add("赵六");coll.add("田七");System.out.println(coll);//[张三, 李四, 赵六, 田七]/*public boolean remove(E e): 把给定的对象在当前集合中删除。返回值是一个boolean值,集合中存在元素,删除元素,返回true集合中不存在元素,删除失败,返回false*/boolean b2 = coll.remove("赵六");System.out.println("b2:"+b2);//b2:trueboolean b3 = coll.remove("赵四");System.out.println("b3:"+b3);//b3:falseSystem.out.println(coll);//[张三, 李四, 田七]/*public boolean contains(E e): 判断当前集合中是否包含给定的对象。包含返回true不包含返回false*/boolean b4 = coll.contains("李四");System.out.println("b4:"+b4);//b4:trueboolean b5 = coll.contains("赵四");System.out.println("b5:"+b5);//b5:false//public boolean isEmpty(): 判断当前集合是否为空。 集合为空返回true,集合不为空返回falseboolean b6 = coll.isEmpty();System.out.println("b6:"+b6);//b6:false//public int size(): 返回集合中元素的个数。int size = coll.size();System.out.println("size:"+size);//size:3//public Object[] toArray(): 把集合中的元素，存储到数组中。Object[] arr = coll.toArray();for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);//public void clear() :清空集合中所有的元素。但是不删除集合,集合还存在coll.clear();System.out.println(coll);//[]System.out.println(coll.isEmpty());//true}
Iterator迭代器
Iterator接口
迭代：即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。(对集合进行遍历)
Iterator接口的常用方法
public E next() :返回迭代的下一个元素。取出集合中的下一个元素
public boolean hasNext()`:如果仍有元素可以迭代，则返回 true。判断集合中还有没有下一个元素,有就返回true,没有就返回false
说明
Iterator迭代器,是一个接口,我们无法直接使用,需要使用Iterator接口的实现类对象,获取实现类的方式比较特殊
Collection接口中有一个方法,叫iterator(),这个方法返回的就是迭代器的实现类对象Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。迭代器的使用步骤(重点):1.使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)2.使用Iterator接口中的方法hasNext判断还有没有下一个元素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();boolean a = it.hasNext();//判断it中是否为空System.out.println(a);//true/*发现使用迭代器取出集合中元素的代码,是一个重复的过程所以我们可以使用循环优化不知道集合中有多少元素,使用while循环循环结束的条件,hasNext方法返回false*/while(it.hasNext()){String e = it.next();System.out.println(e);}System.out.println("----------------------");//也可用for循环for(Iterator<String> it2 = coll.iterator();it2.hasNext();){String e = it2.next();System.out.println(e);}
迭代器实现原理图：
next方法做了两件事：去除下一元素，指针移动到下一位。
注意：期初位置在-1，进入while循环先取出0号，然后移动到0号。
增强for循环-专门用来遍历数组和集合
增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
增强for循环:底层使用的也是迭代器,使用for循环的格式,简化了迭代器的书写
是JDK1.5之后出现的新特性
Collection<E>extends Iterable<E>:所有的单列集合都可以使用增强for
public interface Iterable<T>实现这个接口允许对象成为 "foreach" 语句的目标。
格式:
for(集合/数组的数据类型 变量名: 集合名/数组名){sout(变量名);}//把数组中每个元素逐一拿出来，给定义的变量
public static void main(String[] args) {Collection<String> coll1 = new ArrayList<>();coll1.add("张小敬");coll1.add("李泌");coll1.add("林九郎");for(String b : coll1){System.out.println(b);}}//使用增强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);}
}
泛型
泛型概述
创建集合对象的时候就确定了泛型的数据类型。
使用泛型和不使用的区别
public static void main(String[] args) {show02();}/*创建集合对象,使用泛型好处:1.避免了类型转换的麻烦,存储的是什么类型,取出的就是什么类型2.把运行期异常(代码运行之后会抛出的异常),提升到了编译期(写代码的时候会报错)弊端:泛型是什么类型,只能存储什么类型的数据*/private static void show02() {ArrayList<String> list = new ArrayList<>();list.add("abc");
// list.add(1);//add(java.lang.String)in ArrayList cannot be applied to (int)//使用迭代器遍历list集合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 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 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(1);
}
含有泛型的接口
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 String next() {}
}
public class GenericInterfaceImpl1 implements GenericInterface<String>{@Overridepublic 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> {@Overridepublic void method(I i) {System.out.println(i);}
}
测试：
public static void main(String[] args) {//创建GenericInterfaceImpl1对象GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();gi1.method("字符串");//创建GenericInterfaceImpl2对象GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>();gi2.method(10);GenericInterfaceImpl2<Double> gi3 = new GenericInterfaceImpl2<>();gi3.method(8.8);
}
泛型通配符
当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。
?:代表任意的数据类型
使用方式:
不能创建对象使用
只能作为方法的参数使用
public static void main(String[] args) {ArrayList<Integer> list01 = new ArrayList<>();list01.add(1);list01.add(2);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);}
}
通配符高级使用----受限泛型 （看源码能看懂即可，工作不太使用）
之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。
泛型的上限限定: ? extends E 代表使用的泛型只能是E类型的子类或者本身
泛型的下限限定: ? super E 代表使用的泛型只能是E类型的父类或者本身
public static void main(String[] args) {Collection<Integer> list1 = new ArrayList<Integer>();Collection<String> list2 = new ArrayList<String>();Collection<Number> list3 = new ArrayList<Number>();Collection<Object> list4 = new ArrayList<Object>();getElement1(list1);//getElement1(list2);//报错getElement1(list3);//getElement1(list4);//报错//getElement2(list1);//报错//getElement2(list2);//报错getElement2(list3);getElement2(list4);/*类与类之间的继承关系Integer extends Number extends ObjectString extends Object*/}
// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}
集合综合案例
4.1 案例介绍
按照斗地主的规则，完成洗牌发牌的动作。 具体规则：
使用54张牌打乱顺序,三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
4.2 案例分析
- 准备牌：
牌可以设计为一个ArrayList,每个字符串为一张牌。 每张牌由花色数字两部分组成，我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。 牌由Collections类的shuffle方法进行随机排序。 - 发牌
将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。 - 看牌
直接打印每个集合。
进阶04 4 Collection集合类+Iterator迭代器+增强for+泛型相关推荐
- 2.Collection、Iterator迭代器、泛型、斗地主案例
Collection集合 1.1 集合概念及其与数组的区别 集合:集合是java中提供的一种容器,可以用来存储多个数据. 与数组的区别 数组的长度是固定的.集合的长度是可变的. 数组中存储的是同一类型 ...
- 【java笔记】Iterator迭代器 增强for
Iterator接口: 接口java.util.Iterator遍历集合中的所有元素.Iterator对象主要用于遍历Collection中的元素,因此Iterator对象也被称为迭代器 迭代: Co ...
- JavaSE Collections类 , Iterator迭代器 , 增强for循环
Collections 它是集合的工具类,为集合体系扩展了一些其他的方法.类中都是静态的方法,可以使用类名直接调用. 可变参数 在JDK1.5之后,如果我们定义一个方法需要接受多个参数,并且多个参数类 ...
- 【小白学Java】D20》》》Iterator迭代器 增强for循环
[友情链接]---–->Java中的各种集合大汇总,学习整理 [友情链接]----–> Collection集合 [友情链接]----–> ArrayList集合及其常用功能 [友情 ...
- 2021-06-19复习java Collection集合 Iterator接口_迭代器 增强for循环 泛型
2021-06-19复习java Collection集合 Iterator接口_迭代器 增强for循环 泛型 Collection集合 java.util.coLlection接口 所有单列集合的最 ...
- Java知识点04——集合（Set、List、Queue、Map、Collection和Iterator、Collections工具类）
Java知识点04--集合(Set.List.Queue.Map.Collection.Iterator.Collections工具类) 一.集合 1.1 集合概述 二.Collection 2.1 ...
- JAVA day15 Collection(集合)、Iterator迭代器、泛型＜E＞
1.Collection(集合) 集合:集合是java中提供的⼀种容器,可以⽤来存储多个数据. 集合与数组的区别: 数组的长度是固定的,集合的长度是可变的. 数组中存储的是同⼀类型的元素,可以存储基本 ...
- Java基础知识（二）（Object类的常用方法、日期时间类、System类、StringBuilder类、包装类、Collection集合、Iterator迭代器、泛型、list集Set接口...）
文章目录 Java基础知识(二) 1.Object类的常用方法 1.1 toString方法 1.2 equals方法 1.3 Objects类 2.日期时间类 2.1 Date类 2.2 DateF ...
- Java基础加强重温_05：Iterator迭代器、增强for循环、集合综合案例-斗地主、数据结构（栈、队列、数组、链表、红黑树）、List接口、Set接口
摘要: Java基础加强重温_05: Iterator迭代器(指针跟踪元素). 增强for循环(格式.底层). 集合综合案例-斗地主(代码规范抽取代码,集合元素打乱). 数据结构[栈(先进后出,子弹夹 ...
最新文章
- 架构师之路 — 软件架构 — 应用架构设计模式
- 家里网线的接法和顺序
- Phinecos(洞庭散人) 专注于开源技术的研究与应用 TinyXML：一个优秀的C++ XML解析器
- java中--《_Java中的IO流（五）
- WinLicense下载购买地址
- 拉普拉斯时域卷积定理_拉普拉斯变换卷积积分状态方程.ppt
- 准双向口和KELL C头文件已经处理
- hadoop+hbase安装
- 史上最新最全的Android培训机构大揭秘
- STL-造汽车的厂家不造轮子
- 自己做的SIP软电话
- ValueError X has 2 features, but LogisticRegression is expecting 5 features as input
- Python单利实现
- 怎么用计算机弹出行星,宇宙模拟器space engine教程2：创建自定义太阳系，包括创建恒星，行星等（上）...
- 人生必读的100本书隐私政策
- 微信小程序中实现一个金额摇奖效果
- surface pro触摸屏幕出现异常
- 【9k字+】第二篇：进阶：掌握 Redis 的一些进阶操作（Linux环境）
- 洛阳棋牌手游服务器架设快速稳定,棋牌手游服务器
- springboot1.x整合redis