一、集合(Collection)
二、集合的遍历方式
三、泛型
四、斗地主发牌案例【重点】
一、集合(Collection)
理解：集合就是Java中的一个容器，存储多个数据。
- 数组的长度是固定的，集合的长度是可变的
- 数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当多对象的时候，使用进行存储。
1.集合的体系
Collection接口
–List接口(有序、有索引、元素可以重复)
ArrayList
LinkedList
Vector(线程安全)
–Set接口(无序、无索引、元素不能重复)
HashSet
LinkedHashSet(有序)
TreeSet
集合图解
2.Collection接口的共性方法
public boolean add(E e)
- 往集合里面添加元素
- 返回布尔类型的结果，添加成功返回true，添加失败返回false
public boolean remove(E e)
- 从集合中删除指定的元素
- 返回布尔类型的结果，添加成功返回true，添加失败返回false
public void clear()
- 清空集合中的元素
public boolean contains(E e)
- 判断集合中是否包含指定的元素
- 返回值：包含–>true;不为空–>false
public int size()
- 获取集合中元素的个数(长度，集合中的长度随元素的个数而定)
public Object[] toArray()
- 把集合转换为一个数组
3.Iterator迭代器
理解：迭代器是一种遍历集合的通用方式。
Iterator主要用于迭代访问(即遍历)Collection中的元素。
在程序开发中，经常需要遍历集合中的所有元素。针对这种需求JDK专门提供了一种接口java.util.Iterator。Iterator接口也是Java集合中的一员，但它与Collection、Map接口有所不同，Collection和Map接口主要用于存储元素，而Iterator主要用于迭代访问(即遍历)Collection中的元素，因此Iterator对象又被称之为迭代器。
迭代：
即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有就把这个元素取出来，继续判断，如果还有就再取出来。一直把集合中所有的元素全部取出。这种取出方式又叫迭代。
Iterator接口的常用方法如下：
- public E next():返回迭代的下一个元素。
- public boolean hashNext()：如果任有元素可以迭代，则返回true。
代码案例：
Collecton<String> coll = new ArrayList<>();
coll.add("串串星人");
coll.add("吐槽星人");
coll.add("汪星人");
//获取迭代器对象
Iterator<String> it = coll.iterator();//因为Iterator是接口，不能直接new对象，只能通过集合对象调用iterator()方法，获取对象并交给Iterator类型的变量it管理（it就是这个对象的对象名。然后通过对象名调用next()和hasNext()方法）
//调用hasNext()方法判断是否有元素可以迭代
while(it.hasNext()){
//调用next()获取元素
String str = it.next();
System.out.println(str);
}
常见问题
-
1)java.util.NoSuchElementException: 没有找到元素异常
原因：迭代器在遍历集合的时候，已经没有元素了，还继续调用next()方法。 -
2)java.util.ConcurrentModificationException：并发修改异常
原因：迭代器在遍历集合的同时，集合自己不能对元素进行删减等操作，否则就会出现并发修改异常。
迭代器的实现原理
当遍历集合时，首先通过调用coll集合的iterator()方法获取迭代器对象，然后通过hasNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素，否则说明已经达到了集合末尾，停止遍历元素。
Iterator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素，迭代器的工作原理
在调用Iterator的next方法之前，迭代器的索引位于第一个元素之前，不指向任何一个元素，当第一次调用迭代器的next()方法后，迭代器的索引会向后指向第二个元素并将该元素返回，依此类推，直到hasNaext()方法返回为false，即到达了集合的末尾，停止对该集合的遍历。
增强for循环
但是在实际开发中迭代器的遍历集合元素的方式还是比较复杂，因此又引入了增强for循环。
增强for循环又叫foreach/高级for循环【任何集合都能遍历/底层基于iterator迭代器】
(是迭代器的简化版，可读性更高)
//增强for遍历集合
for (String s : list) {
System.out.println(s);
}
弊端：常见问题(常见异常)
- 1)java.util.NoSuchElementException: 没有找到元素异常
原因：迭代器在遍历集合的时候，已经没有元素了，还继续调用next()方法。 - 2)java.util.ConcurrentModificationException：并发修改异常
原因：迭代器在遍历集合的同时，集合自己不能对元素进行删减等操作，否则就会出现并发修改异常。
普通for循环和Iterator迭代器，增强for循环的区别：
普通for循环只能遍历有索引(有序存放)的集合；
通过迭代器可以所有的集合(有序、无序)；
高级for循环是可以遍历所有的集合（其底层的实现还是基于iterator迭代器，但更加简化，提高程序的可读性）
idea中通过for循环遍历集合的快捷方式：
对象名.forr–>快速生成倒序遍历循环
对象名.fori–>快速生成正序遍历循环
对象名.for–>快速生成正序遍历增强for循环
如何选择使用哪种方式遍历集合(扬长避短)
1)如果需要对集合进行更改，选择普通for
2)仅仅只是为了获取元素，选择高级for/迭代器
三、泛型
理解：泛型是一种不确定的数据类型，用表示。
泛型是JDK1.5之后才有的
泛型方法就是启到简化方法的重载
泛型没有继承的概念
泛型的好处：
- 把允许时期可能出现的错误，提前的编译时期
- 避免了强制类型转换的麻烦
泛型的使用：
1.泛型在集合中的使用：
//<String>：指明了该集合中存储的元素都是String类型的
ArrayList<String> list = new ArrayList<>();
//<Integer>:指明了该集合中存储的元素类型都为Integer类型
ArrayList<Integer> list2 = new ArrayLisr<>();
2.自定义泛型
1)自定义泛型类
//<W>表示在类中不确定的数据类型
public class 类名<W>{
//方法中的参数类型为W类型
public static 方法名(W w){
...
}
}
//创建对象的时候，来确定<W>的数据类型为String
类名<String> 对象名=new 类名<>();
2)自定义泛型方法
//<E>表示在方法中不确定的数据类型
public <E> void method(E e){
System.out.prinltn(e);
}
//调用方法的时候，确定<E>的数据类型
method("hello");
method(3.14);
method(100);
3)自定义泛型接口
//<M>在接口中不确定的数据类型
public interface 接口名<M>{
//方法中的参数是M数据类型
public void method(M m)；
}
//a：在实现类中可以确定<M>的数据类型
public class 实现类 implements 接口名<Integer>{
//复写方法时,参数跟着<Integer>变化
public void method(Integer m){
....
}
}
//b：把泛型<M>延用到实现类
public class 实现类<M> implements 接口名<M>{
public void method(M m){
....
}
}
//类上泛型，在创建对象的时候确定
实现类<String> 对象名=new 实现类<>();
对象名.method("hello");
3.泛型通配符
<?> 任意类型
<? extends E> ?表示是E或者E的子类
<? super E> ?可以是E或者E的父类
一般泛型限定使用在方法的参数中，对API中的方法，能看懂能调用即可
四、斗地主发牌案例
步骤：
准备牌
每一张牌由花色+点数组成
洗牌
发牌
看牌
程序流程图：
代码实现：
package com.itheima.TestPokerGame;
import java.util.ArrayList;
import java.util.Collections;
//模拟斗地主洗牌发牌
public class Poker_Game_Demo {
public static void main(String[] args) {
//1.准备牌(每一张牌的组成花色+点数)
//4个花色(放入数组中)
String[] colors = {"♥","♠","♣","♦"};
//13个点数和大王、小王(放入数组中)
String[] nums = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
//再创建一个容器作为poker牌的存放处(牌盒)
ArrayList<String> box = new ArrayList<>();
//双重for循环实现所有花色和点数的组合-->构成一张牌
for (String color : colors) {//高级for循环遍历每个花色（高级for循环底层）
for (String num : nums) {//遍历每个点数
String poker = color+num;//点数和花色拼接构成一张牌poker
box.add(poker);//将牌存放在容器中(牌盒)
}
}
//大王和小王单独添加到牌盒容器中
box.add("大王");
box.add("小王");
//2.洗牌（将牌盒容器中的元素的顺序打乱）
Collections.shuffle(box);//Collections工具类的shuffle方法可以把传入的集合对象box内的元素顺序打乱(方法的底层是借助Random随机数实现)
//3.发牌(创建4个容器对象)
ArrayList<Object> player1 = new ArrayList<>();
ArrayList<Object> player2 = new ArrayList<>();
ArrayList<Object> player3 = new ArrayList<>();
ArrayList<Object> landlord = new ArrayList<>();
//遍历集合(分别给3个玩家发牌，剩下的3张作为地主牌)
for (int i = 0; i < box.size(); i++) {
//获取每张牌
String p = box.get(i);
if (i>=51){
landlord.add(p);
}else {
if(i%3==0){
player1.add(p);
}
if(i%3==1){
player2.add(p);
}
if (i%3==2){
player3.add(p);
}
}
}
//4.看牌
System.out.println("玩家1："+player1+"-->"+player1.size());
System.out.println("玩家2："+player2+"-->"+player2.size());
System.out.println("玩家3："+player3+"-->"+player3.size());
System.out.println("地主牌："+landlord);
player1.addAll(landlord);
System.out.println("player1："+player1);
}
}
运行结果：
玩家1：[♥3, ♠A, ♦10, ♦K, ♦7, ♣5, ♦4, ♣Q, ♠8, ♥5, ♥Q, 小王, ♦3, ♠5, ♥J, ♣8, ♦8]-->17
玩家2：[♣9, ♠K, ♣K, ♥4, ♣7, ♠9, ♥6, ♥9, ♣A, ♥8, 大王, ♣2, ♠2, ♣4, ♥K, ♦Q, ♥7]-->17
玩家3：[♦2, ♠10, ♥A, ♠J, ♣10, ♦A, ♦6, ♠4, ♠3, ♣3, ♠7, ♥2, ♠Q, ♣6, ♦5, ♣J, ♥10]-->17
地主牌：[♦J, ♦9, ♠6]
(地主)player1：[♥3, ♠A, ♦10, ♦K, ♦7, ♣5, ♦4, ♣Q, ♠8, ♥5, ♥Q, 小王, ♦3, ♠5, ♥J, ♣8, ♦8, ♦J, ♦9, ♠6]
Java学习第14天内容链接：
https://blog.youkuaiyun.com/LJN951118/article/details/89166196
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
