Java学习_Day13

一、集合(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.csdn.net/LJN951118/article/details/89166196