Collection集合

集合

1. Collection

1.1集合基础知识回顾

集合类的特点：提供一种存储空间可见的存储模型，存储的数据容量可以随时发生改变。

1.2 集合类体系结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RpNukL9K-1627886892871)(C:\Users\23389\AppData\Roaming\Typora\typora-user-images\image-20210617211801618.png)]

1.3 Collection集合概述和使用

Collection集合概述

• 是单例集合的顶层接口，它表示一组对象这写对象也称为Collection的元素
• JDK 不提供此接口的任何直接实现，它提供了更具体的子接口（如Set和List实现）

创建Collection集合的对象

• 多态的形式
• 具体的实现类 ArrayList

1.4 Collection集合常用方法

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合元素的个数

1.5 Collection 集合的遍历

Iterator :迭代器，集合的专业遍历方式

• Iterator iterator(): 返回此集合的iterator()方法得到
• 迭代器是通过集合的iterator方法得到的，所以我i们说它是依赖于集合而存在的

Iterator中的常用方法

• E next() :返回迭代器中的下一个元素
• boolean hasNext(): 如果迭代器具有更多元素，则返回true

1.6 集合的使用步骤

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7MHNTQdL-1627886892892)(C:\Users\23389\AppData\Roaming\Typora\typora-user-images\image-20210617224058848.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-clBzBJrS-1627886892894)(C:\Users\23389\AppData\Roaming\Typora\typora-user-images\image-20210617224221763.png)]

1.7 案例： Collection集合存储学生对象并遍历

需求：创建一个学生对象的集合，存储三个学生对象，使用程序是实现在控制台遍历该集合。

思路：

①定义学生类

②创建Collection集合对象

③创建学生对象

④把学生添加到集合

⑤遍历集合(迭代器方式)

1.8 Collection概述和使用

Collection类的概述

• 是针对集合操作的工具类

Collection类的常用方法

• public static <T extends Comparable<? super T> void sort(List list) :将指定的列表按升序排列
• public static void reverse(List<?> list): 反转指定列表中元素的顺序
• public static void shuffle(List<?> list) : 使用默认的随机源随机排列指定的列表

1.9模拟斗地主

需求：通过程序实现斗地主过程中洗牌、发牌和看牌过程

思路：

• 创建一个牌盒。也就是定义一个集合对象，用ArrayList集合实现
• 在牌盒里面装牌
• 洗牌，也就是把牌打散，通过Collections的shuffle()方法实现
• 发牌：通过i的值进行判断
• 看牌：也就是三位玩家分别遍历自己的牌

package com.fun04;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

/**
 * @author 23389.
 * @date 2021/6/29.
 */
public class CollectionDemo {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> pokerArr = new ArrayList<String>();

        //添加牌
        String[] colors = new String[] {"♦","♣","♥","♠"};
        String[] number = new String[] {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};

        for(String c : colors){
            for(String n : number){
                String poker = c + n;
                pokerArr.add(poker);
            }
        }
        pokerArr.add("小王");
        pokerArr.add("大王");

        Collections.shuffle(pokerArr);

        ArrayList<String> player1 = new ArrayList<String>();
        ArrayList<String> player2 = new ArrayList<String>();
        ArrayList<String> player3 = new ArrayList<String>();
        ArrayList<String> dppoker = new ArrayList<String>();

        for(int i = 0;i < pokerArr.size();i++){
            String poker = pokerArr.get(i);
            if(pokerArr.size() - i <= 3 ){
                dppoker.add(poker);
            }else if(i % 3 == 0){
                player1.add(poker);
            }else if(i % 3 == 1){
                player2.add(poker);
            }else if(i % 3 == 2){
                player3.add(poker);
            }
        }

        showPoker("player1",player1);
        showPoker("player2",player2);
        showPoker("player3",player3);
        showPoker("dipai",dppoker);


//        System.out.println(pokerArr);
    }


    //看牌的方法
    public static void showPoker(String name,ArrayList<String> arr){
        System.out.print(name + "的牌是：");
        for(String s : arr){
            System.out.print(s);
        }
        System.out.println();
    }
}

1.10 模拟斗地主升级版

需求：通过程序实现斗地主过程中洗牌、发牌和看牌过程 对牌进行排序

思路：

• 创建HashMap对象，键是编号，值是牌
• 创建ArrayList集合对象，存储编号
• 创建花色数组和点数数组
• 从0开始往HashMap集合里面存储编号，并存储对应的牌，同时往ArrayList里面存储编号
• 洗牌（洗的是编号）也就是把牌打散，通过Collections的shuffle()方法实现
• 发牌（发的也是编号，为了保证编号是排序的，创建TreeSet集合接收）
• 看牌：定义方法看牌（遍历TreeSet集合，获取编号，到HashMap集合找到对应的牌)
• 调用看牌方法‘

package com.fun04;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

/**
 * @author 23389.
 * @date 2021/6/29.
 */
public class CollectionDemo02 {
    public static void main(String[] args) {
        //创建HashMap集合对象
        HashMap<Integer,String> hm = new HashMap<Integer,String>();

        //创建ArrayList对象，存储编号
        ArrayList<Integer> arrNum = new ArrayList<Integer>();

//        for(int i = 0; i <= 52;i++){
//            arrNum.add(i);
//        }


        //创建花色和点数数组
        String[] colors = new String[] {"♦","♣","♥","♠"};
        String[] num = new String[] {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};

        //从开始往HashMap里面存储编号，并存储对应的值，同时在ArrayList里面存储编号
        int index = 0;

        for(String c : colors){
            for(String n : num){
                hm.put(index,c + n);
                arrNum.add(index);
                index++;
            }
        }

        hm.put(index,"小王");
        arrNum.add(index);
        index++;

        hm.put(index,"大王");
        arrNum.add(index);

//        洗牌
        Collections.shuffle(arrNum);

//        发牌（发的是编号，为保证编号排序，创建TreeSet集合接收）
        TreeSet<Integer> player1 = new TreeSet<Integer>();
        TreeSet<Integer> player2 = new TreeSet<Integer>();
        TreeSet<Integer> player3 = new TreeSet<Integer>();
        TreeSet<Integer> dp = new TreeSet<Integer>();

        for(int i = 0;i < arrNum.size();i++){
            int x = arrNum.get(i);
            if(i >= arrNum.size() - 3){
                dp.add(x);
            }else if(i % 3 == 0){
                player1.add(x);
            }else if(i % 3 == 1){
                player2.add(x);
            }else if(i % 3 == 2){
                player3.add(x);
            }
        }

        //调用方法看牌
        showPoker("player1",player1,hm);
        showPoker("player2",player2,hm);
        showPoker("player3",player3,hm);
        showPoker("dp",dp,hm);
//        System.out.println(arrNum);

    }
    //定义方法看牌（遍历TreeSet集合，获取编号，到HashMap集合找到对应的牌)
    public static void showPoker(String name,TreeSet<Integer> ts,HashMap<Integer,String> hm){
        System.out.print(name + "的牌是：");
        for(Integer key: ts){
            String poker = hm.get(key);
            System.out.print(poker + " ");
        }
        System.out.println();

    }

}

2. List

2.1 List集合的概述和特点

List集合概述

• 有序集合(也称为序列)，用户可以精确的控制列表中每个元素的插入位置，用户可以通过整数索引访问元素，并搜索列表中的元素。
• 与Set集合不同，列表通常允许重复的元素

List集合特点

• 有序：存储和取出的元素顺序一致
• 可重复:存储的元素可以重复

2.2 List集合的特有方法

方法名	说明
void add(int index,E element)	在此集合的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回索引处的元素

2.3 List集合存储学生对象并遍历

需求：创建一个学生对象的集合，存储三个学生对象，使用程序是实现在控制台遍历该集合。

思路：

①定义学生类

②创建List集合对象

③创建学生对象

④把学生添加到集合

⑤遍历集合(迭代器方式，for循环方式)

2.4 并发修改异常

并发修改异常

• ConcurrentModificationException

产生原因

• 迭代器遍历的过程，通过集合对象修改集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致。

解决方案

• 同for循环遍历，然后用集合对象做对应的操作即可

2.5 ListIterator

Listiterator:列表迭代器

• 通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器
• 通过允许程序员沿任一方向遍历列表的列表迭代器，在迭代器可修改列表，并获取列表迭代器的当前位置

ListIerator中的常用方法

• E next() :返回迭代中的下一个元素
• boolean hasNext() :如果迭代具有更多的元素，则返回true
• E previous() :返回列表中的上一个元素
• boolean hasPrevious() ： 如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
• void add(E e):将指定元素插入列表

2.6 增强for循环

增强for：能强化数组和Collection集合的遍历

• 实现Iterator接口的类允许其对象成为增强for语句目标
• 它是JDK5之后出现的，其内部原理是一个Iterator迭代器

增强for的格式

• 格式：

for(元素数据类型 变量名 : 数组或者Collection集合){

//在此处使用变量访问，该变量就是元素

}

• 范例：

int[] arr = {1,2,3,4,5};
for(int i : arr){
  System.out.println(i);
}

2.7 案例：List集合存储学生对象用三种方式遍历

需求：创建一个学生对象的集合，存储三个学生对象，使用程序是实现在控制台遍历该集合。

思路：

①定义学生类

②创建List集合对象

③创建学生对象

④把学生添加到集合

⑤遍历集合

​ 迭代器：集合特有的遍历方式

​ 普通for循环：带有索引的遍历方式

​ 增强for循环：最方便的方式

2.8 数据结构

数据结构是计算机存储、组织数据的方式，是指相互之间存在一种或多中国特定关系的数据元素的集合

通常情况下，精心选择的数据结构都可以带来更高的运行或存储效率

2.9 常见数据之栈

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6GoDGrjf-1627886892897)(C:\Users\23389\AppData\Roaming\Typora\typora-user-images\image-20210620111513957.png)]

​ 数据进入栈模型的过程称为：压/进栈

​ 数据离开栈模型的过程称为：弹/出栈

栈是一种数据先进后出的模型

2.10常见数据结构之队列

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4kFW727k-1627886892903)(C:\Users\23389\AppData\Roaming\Typora\typora-user-images\image-20210620111554023.png)]

数据从后端进入队列模型的过程称为：入队列

数据从前端离开队列模型的过程称为：出队列

队列是一种先进先出，后进后出的模型

2.11 常见数据结构之数组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SAraJm8B-1627886892904)(C:\Users\23389\AppData\Roaming\Typora\typora-user-images\image-20210620112059328.png)]

数组是一种查询快，增删慢的模型

2.12 常见数据结构之链表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eyJ9WRIe-1627886892905)(C:\Users\23389\AppData\Roaming\Typora\typora-user-images\image-20210620112433288.png)]

链表连接过程：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KV6hQe9B-1627886892906)(C:\Users\23389\AppData\Roaming\Typora\typora-user-images\image-20210620112615518.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Iso9xjjN-1627886892907)(C:\Users\23389\AppData\Roaming\Typora\typora-user-images\image-20210620112736031.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AwJ39OBv-1627886892908)(C:\Users\23389\AppData\Roaming\Typora\typora-user-images\image-20210620112947783.png)]

链表是一种增删块的模型(对比数组)

链表是一种查询慢的模型(对比数组)

查询数据是否存在，必须从头(head)开始查询

2.13 ：List集合子类特点

list集合的常用子类：ArrayList，LinkedList

• ArrayList：底层数据结构是数组，查询快，增删慢
• LinkedList：底层数据结构是链表，查询慢，增删快

练习：分别使用ArrayList和LinkedList完成存储字符串并遍历

package com.fun07;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/**
 * @author 23389.
 * @date 2021/6/20.
 */

/*
list集合的常用子类：ArrayList，LinkedList

- ArrayList：底层数据结构是数组，查询快，增删慢
- LinkedList：底层数据结构是链表，查询慢，增删快

练习：分别使用ArrayList和LinkedList完成存储字符串并遍历


 */

public class ListDemo {
    public static void main(String[] args){
        //创建集合对象
        ArrayList<String> array = new ArrayList<String>();
        array.add("hello");
        array.add("world");
        array.add("java");
        //遍历
        Iterator<String> it = array.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("-------");
        for(int i = 0;i < array.size();i++){
            String s = array.get(i);
            System.out.println(s);
        }
        System.out.println("--------");
        for(String s : array){
            System.out.println(s);
        }
        System.out.println("-------");

        LinkedList<String> linkedList = new LinkedList<String>();
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");
        //遍历
        for(String s : linkedList){
            System.out.println(s);
        }
        System.out.println("-------");
        for(int i = 0;i < linkedList.size();i++){
            String s = linkedList.get(i);
            System.out.println(s);
        }
        System.out.println("----------");

        Iterator<String> it2 = linkedList.iterator();
        while(it2.hasNext()){
            String s = it2.next();
            System.out.println(s);
        }
    }


}

2.14 案例：ArrayList 集合存储学生对象 用三种方式遍历

需求：创建一个学生对象的集合，存储三个学生对象，使用程序是实现在控制台遍历该集合。

思路：

①定义学生类

②创建ArrayList集合对象

③创建学生对象

④把学生添加到集合

⑤遍历集合

​ 迭代器：集合特有的遍历方式

​ 普通for循环：带有索引的遍历方式

​ 增强for循环：最方便的方式

package com.fun08;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * @author 23389.
 * @date 2021/6/20.
 */
public class ArrayListDemo {
    public static void main(String[] args){
        ArrayList<Student> arr = new ArrayList<Student>();
        Student s1 = new Student("张三",18);
        Student s2 = new Student("李四",20);
        Student s3 = new Student("王五",19);
        arr.add(s1);
        arr.add(s2);
        arr.add(s3);
        //遍历
        Iterator<Student> it = arr.iterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("-------");
        for(int i = 0;i < arr.size();i++){
            Student s = arr.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("----------");
        for(Student s : arr){
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

2.15 LinkedList集合的特有功能

方法名	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

案例：

package com.fun09;

import java.util.LinkedList;

/**
 * @author 23389.
 * @date 2021/6/20.
 */

/*
| 方法名                    | 说明                             |
| ------------------------- | -------------------------------- |
| public void addFirst(E e) | 在该列表开头插入指定的元素       |
| public void addLast(E e)  | 将指定的元素追加到此列表的末尾   |
| public E getFirst()       | 返回此列表中的第一个元素         |
| public E getLast()        | 返回此列表的最后一个元素         |
| public E removeFirst()    | 从此列表中删除并返回第一个元素   |
| public E removeLast()     | 从此列表中删除并返回最后一个元素 |


 */

public class LinkedListDemo {
    public static void main(String[] args){
        //创建集合对象
        LinkedList<String> linkedList = new LinkedList<String>();

        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");
//        | public void addFirst(E e) | 在该列表开头插入指定的元素       |
//        | public void addLast(E e)  | 将指定的元素追加到此列表的末尾    |
//        linkedList.addFirst("javase");
//        linkedList.addLast("javaee");

//        public E getFirst()       | 返回此列表中的第一个元素         |
//        public E getLast()        | 返回此列表的最后一个元素         |
//        System.out.println(linkedList.getFirst());
//        System.out.println(linkedList.getLast());

//        | public E removeFirst()    | 从此列表中删除并返回第一个元素   |
//        | public E removeLast()     | 从此列表中删除并返回最后一个元素 |
        linkedList.removeFirst();
        linkedList.removeLast();
        System.out.println(linkedList);
    }
}

集合

1. Collection

1.1集合基础知识回顾

集合类的特点：提供一种存储空间可见的存储模型，存储的数据容量可以随时发生改变。

1.2 集合类体系结构

1.3 Collection集合概述和使用

Collection集合概述

• 是单例集合的顶层接口，它表示一组对象这写对象也称为Collection的元素
• JDK 不提供此接口的任何直接实现，它提供了更具体的子接口（如Set和List实现）

创建Collection集合的对象

• 多态的形式
• 具体的实现类 ArrayList

1.4 Collection集合常用方法

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合元素的个数

1.5 Collection 集合的遍历

Iterator :迭代器，集合的专业遍历方式

• Iterator iterator(): 返回此集合的iterator()方法得到
• 迭代器是通过集合的iterator方法得到的，所以我i们说它是依赖于集合而存在的

Iterator中的常用方法

• E next() :返回迭代器中的下一个元素
• boolean hasNext(): 如果迭代器具有更多元素，则返回true

1.6 集合的使用步骤

1.7 案例： Collection集合存储学生对象并遍历

需求：创建一个学生对象的集合，存储三个学生对象，使用程序是实现在控制台遍历该集合。

思路：

①定义学生类

②创建Collection集合对象

③创建学生对象

④把学生添加到集合

⑤遍历集合(迭代器方式)

1.8 Collection概述和使用

Collection类的概述

• 是针对集合操作的工具类

Collection类的常用方法

• public static <T extends Comparable<? super T> void sort(List list) :将指定的列表按升序排列
• public static void reverse(List<?> list): 反转指定列表中元素的顺序
• public static void shuffle(List<?> list) : 使用默认的随机源随机排列指定的列表

1.9模拟斗地主

需求：通过程序实现斗地主过程中洗牌、发牌和看牌过程

思路：

• 创建一个牌盒。也就是定义一个集合对象，用ArrayList集合实现
• 在牌盒里面装牌
• 洗牌，也就是把牌打散，通过Collections的shuffle()方法实现
• 发牌：通过i的值进行判断
• 看牌：也就是三位玩家分别遍历自己的牌

package com.fun04;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

/**
 * @author 23389.
 * @date 2021/6/29.
 */
public class CollectionDemo {
    public static void main(String[] args) {
        //创建集合对象
        ArrayList<String> pokerArr = new ArrayList<String>();

        //添加牌
        String[] colors = new String[] {"♦","♣","♥","♠"};
        String[] number = new String[] {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};

        for(String c : colors){
            for(String n : number){
                String poker = c + n;
                pokerArr.add(poker);
            }
        }
        pokerArr.add("小王");
        pokerArr.add("大王");

        Collections.shuffle(pokerArr);

        ArrayList<String> player1 = new ArrayList<String>();
        ArrayList<String> player2 = new ArrayList<String>();
        ArrayList<String> player3 = new ArrayList<String>();
        ArrayList<String> dppoker = new ArrayList<String>();

        for(int i = 0;i < pokerArr.size();i++){
            String poker = pokerArr.get(i);
            if(pokerArr.size() - i <= 3 ){
                dppoker.add(poker);
            }else if(i % 3 == 0){
                player1.add(poker);
            }else if(i % 3 == 1){
                player2.add(poker);
            }else if(i % 3 == 2){
                player3.add(poker);
            }
        }

        showPoker("player1",player1);
        showPoker("player2",player2);
        showPoker("player3",player3);
        showPoker("dipai",dppoker);


//        System.out.println(pokerArr);
    }


    //看牌的方法
    public static void showPoker(String name,ArrayList<String> arr){
        System.out.print(name + "的牌是：");
        for(String s : arr){
            System.out.print(s);
        }
        System.out.println();
    }
}

1.10 模拟斗地主升级版

需求：通过程序实现斗地主过程中洗牌、发牌和看牌过程 对牌进行排序

思路：

• 创建HashMap对象，键是编号，值是牌
• 创建ArrayList集合对象，存储编号
• 创建花色数组和点数数组
• 从0开始往HashMap集合里面存储编号，并存储对应的牌，同时往ArrayList里面存储编号
• 洗牌（洗的是编号）也就是把牌打散，通过Collections的shuffle()方法实现
• 发牌（发的也是编号，为了保证编号是排序的，创建TreeSet集合接收）
• 看牌：定义方法看牌（遍历TreeSet集合，获取编号，到HashMap集合找到对应的牌)
• 调用看牌方法‘

package com.fun04;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.TreeSet;

/**
 * @author 23389.
 * @date 2021/6/29.
 */
public class CollectionDemo02 {
    public static void main(String[] args) {
        //创建HashMap集合对象
        HashMap<Integer,String> hm = new HashMap<Integer,String>();

        //创建ArrayList对象，存储编号
        ArrayList<Integer> arrNum = new ArrayList<Integer>();

//        for(int i = 0; i <= 52;i++){
//            arrNum.add(i);
//        }


        //创建花色和点数数组
        String[] colors = new String[] {"♦","♣","♥","♠"};
        String[] num = new String[] {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};

        //从开始往HashMap里面存储编号，并存储对应的值，同时在ArrayList里面存储编号
        int index = 0;

        for(String c : colors){
            for(String n : num){
                hm.put(index,c + n);
                arrNum.add(index);
                index++;
            }
        }

        hm.put(index,"小王");
        arrNum.add(index);
        index++;

        hm.put(index,"大王");
        arrNum.add(index);

//        洗牌
        Collections.shuffle(arrNum);

//        发牌（发的是编号，为保证编号排序，创建TreeSet集合接收）
        TreeSet<Integer> player1 = new TreeSet<Integer>();
        TreeSet<Integer> player2 = new TreeSet<Integer>();
        TreeSet<Integer> player3 = new TreeSet<Integer>();
        TreeSet<Integer> dp = new TreeSet<Integer>();

        for(int i = 0;i < arrNum.size();i++){
            int x = arrNum.get(i);
            if(i >= arrNum.size() - 3){
                dp.add(x);
            }else if(i % 3 == 0){
                player1.add(x);
            }else if(i % 3 == 1){
                player2.add(x);
            }else if(i % 3 == 2){
                player3.add(x);
            }
        }

        //调用方法看牌
        showPoker("player1",player1,hm);
        showPoker("player2",player2,hm);
        showPoker("player3",player3,hm);
        showPoker("dp",dp,hm);
//        System.out.println(arrNum);

    }
    //定义方法看牌（遍历TreeSet集合，获取编号，到HashMap集合找到对应的牌)
    public static void showPoker(String name,TreeSet<Integer> ts,HashMap<Integer,String> hm){
        System.out.print(name + "的牌是：");
        for(Integer key: ts){
            String poker = hm.get(key);
            System.out.print(poker + " ");
        }
        System.out.println();

    }

}

2. List

2.1 List集合的概述和特点

List集合概述

• 有序集合(也称为序列)，用户可以精确的控制列表中每个元素的插入位置，用户可以通过整数索引访问元素，并搜索列表中的元素。
• 与Set集合不同，列表通常允许重复的元素

List集合特点

• 有序：存储和取出的元素顺序一致
• 可重复:存储的元素可以重复

2.2 List集合的特有方法

方法名	说明
void add(int index,E element)	在此集合的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回索引处的元素

2.3 List集合存储学生对象并遍历

需求：创建一个学生对象的集合，存储三个学生对象，使用程序是实现在控制台遍历该集合。

思路：

①定义学生类

②创建List集合对象

③创建学生对象

④把学生添加到集合

⑤遍历集合(迭代器方式，for循环方式)

2.4 并发修改异常

并发修改异常

• ConcurrentModificationException

产生原因

• 迭代器遍历的过程，通过集合对象修改集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致。

解决方案

• 同for循环遍历，然后用集合对象做对应的操作即可

2.5 ListIterator

Listiterator:列表迭代器

• 通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器
• 通过允许程序员沿任一方向遍历列表的列表迭代器，在迭代器可修改列表，并获取列表迭代器的当前位置

ListIerator中的常用方法

• E next() :返回迭代中的下一个元素
• boolean hasNext() :如果迭代具有更多的元素，则返回true
• E previous() :返回列表中的上一个元素
• boolean hasPrevious() ： 如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
• void add(E e):将指定元素插入列表

2.6 增强for循环

增强for：能强化数组和Collection集合的遍历

• 实现Iterator接口的类允许其对象成为增强for语句目标
• 它是JDK5之后出现的，其内部原理是一个Iterator迭代器

增强for的格式

• 格式：

for(元素数据类型 变量名 : 数组或者Collection集合){

//在此处使用变量访问，该变量就是元素

}

• 范例：

int[] arr = {1,2,3,4,5};
for(int i : arr){
  System.out.println(i);
}

2.7 案例：List集合存储学生对象用三种方式遍历

需求：创建一个学生对象的集合，存储三个学生对象，使用程序是实现在控制台遍历该集合。

思路：

①定义学生类

②创建List集合对象

③创建学生对象

④把学生添加到集合

⑤遍历集合

​ 迭代器：集合特有的遍历方式

​ 普通for循环：带有索引的遍历方式

​ 增强for循环：最方便的方式

2.8 数据结构

数据结构是计算机存储、组织数据的方式，是指相互之间存在一种或多中国特定关系的数据元素的集合

通常情况下，精心选择的数据结构都可以带来更高的运行或存储效率

2.9 常见数据之栈

​ 数据进入栈模型的过程称为：压/进栈

​ 数据离开栈模型的过程称为：弹/出栈

栈是一种数据先进后出的模型

2.10常见数据结构之队列

数据从后端进入队列模型的过程称为：入队列

数据从前端离开队列模型的过程称为：出队列

队列是一种先进先出，后进后出的模型

2.11 常见数据结构之数组

数组是一种查询快，增删慢的模型

2.12 常见数据结构之链表

链表连接过程：

链表是一种增删块的模型(对比数组)

链表是一种查询慢的模型(对比数组)

查询数据是否存在，必须从头(head)开始查询

2.13 ：List集合子类特点

list集合的常用子类：ArrayList，LinkedList

• ArrayList：底层数据结构是数组，查询快，增删慢
• LinkedList：底层数据结构是链表，查询慢，增删快

练习：分别使用ArrayList和LinkedList完成存储字符串并遍历

package com.fun07;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/**
 * @author 23389.
 * @date 2021/6/20.
 */

/*
list集合的常用子类：ArrayList，LinkedList

- ArrayList：底层数据结构是数组，查询快，增删慢
- LinkedList：底层数据结构是链表，查询慢，增删快

练习：分别使用ArrayList和LinkedList完成存储字符串并遍历


 */

public class ListDemo {
    public static void main(String[] args){
        //创建集合对象
        ArrayList<String> array = new ArrayList<String>();
        array.add("hello");
        array.add("world");
        array.add("java");
        //遍历
        Iterator<String> it = array.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("-------");
        for(int i = 0;i < array.size();i++){
            String s = array.get(i);
            System.out.println(s);
        }
        System.out.println("--------");
        for(String s : array){
            System.out.println(s);
        }
        System.out.println("-------");

        LinkedList<String> linkedList = new LinkedList<String>();
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");
        //遍历
        for(String s : linkedList){
            System.out.println(s);
        }
        System.out.println("-------");
        for(int i = 0;i < linkedList.size();i++){
            String s = linkedList.get(i);
            System.out.println(s);
        }
        System.out.println("----------");

        Iterator<String> it2 = linkedList.iterator();
        while(it2.hasNext()){
            String s = it2.next();
            System.out.println(s);
        }
    }


}

2.14 案例：ArrayList 集合存储学生对象 用三种方式遍历

需求：创建一个学生对象的集合，存储三个学生对象，使用程序是实现在控制台遍历该集合。

思路：

①定义学生类

②创建ArrayList集合对象

③创建学生对象

④把学生添加到集合

⑤遍历集合

​ 迭代器：集合特有的遍历方式

​ 普通for循环：带有索引的遍历方式

​ 增强for循环：最方便的方式

package com.fun08;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * @author 23389.
 * @date 2021/6/20.
 */
public class ArrayListDemo {
    public static void main(String[] args){
        ArrayList<Student> arr = new ArrayList<Student>();
        Student s1 = new Student("张三",18);
        Student s2 = new Student("李四",20);
        Student s3 = new Student("王五",19);
        arr.add(s1);
        arr.add(s2);
        arr.add(s3);
        //遍历
        Iterator<Student> it = arr.iterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("-------");
        for(int i = 0;i < arr.size();i++){
            Student s = arr.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("----------");
        for(Student s : arr){
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

2.15 LinkedList集合的特有功能

方法名	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

案例：

package com.fun09;

import java.util.LinkedList;

/**
 * @author 23389.
 * @date 2021/6/20.
 */

/*
| 方法名                    | 说明                             |
| ------------------------- | -------------------------------- |
| public void addFirst(E e) | 在该列表开头插入指定的元素       |
| public void addLast(E e)  | 将指定的元素追加到此列表的末尾   |
| public E getFirst()       | 返回此列表中的第一个元素         |
| public E getLast()        | 返回此列表的最后一个元素         |
| public E removeFirst()    | 从此列表中删除并返回第一个元素   |
| public E removeLast()     | 从此列表中删除并返回最后一个元素 |


 */

public class LinkedListDemo {
    public static void main(String[] args){
        //创建集合对象
        LinkedList<String> linkedList = new LinkedList<String>();

        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");
//        | public void addFirst(E e) | 在该列表开头插入指定的元素       |
//        | public void addLast(E e)  | 将指定的元素追加到此列表的末尾    |
//        linkedList.addFirst("javase");
//        linkedList.addLast("javaee");

//        public E getFirst()       | 返回此列表中的第一个元素         |
//        public E getLast()        | 返回此列表的最后一个元素         |
//        System.out.println(linkedList.getFirst());
//        System.out.println(linkedList.getLast());

//        | public E removeFirst()    | 从此列表中删除并返回第一个元素   |
//        | public E removeLast()     | 从此列表中删除并返回最后一个元素 |
        linkedList.removeFirst();
        linkedList.removeLast();
        System.out.println(linkedList);
    }
}