第十一章、集合_Collection/泛型/斗地主案例（单列）/数据结构/List/Set/Collections/Map/斗地主案例（双列）_黑马Java第57期个人学习笔记_个人笔记

第十一章：集合【Collection、泛型、斗地主案例（单列）、数据结构、List集合、Set集合、Collections工具类、Map集合、Debug调试、斗地主案例（双列）】

 

 

第一节、Collection集合

 

一、集合

（一）概述

1、集合：集合是java中提供的一种容器，可以用来存储多个数据。

2、集合和数组的区别

（1）数组的长度是固定的。集合的长度是可变的。

（2）数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。

（二）集合框架

Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是`java.util.List`和`java.util.Set`。

其中，`List`的特点是元素有序、元素可重复。`Set`的特点是元素无序，而且不可重复。

`List`接口的主要实现类有`java.util.ArrayList`和`java.util.LinkedList`，`Set`接口的主要实现类有`java.util.HashSet`和`java.util.TreeSet`。

二、Collection

（一）概述

Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。

（二）常用方法

- `public boolean add(E e)`：  把给定的对象添加到当前集合中。

 

- `public boolean contains(E e)`: 判断当前集合中是否包含给定的对象。

 

- `public boolean remove(E e)`: 把给定的对象在当前集合中删除。

 

- `public int size()`: 返回集合中元素的个数。

 

- `public Object[] toArray()`: 把集合中的元素，存储到数组中。

 

- `public void clear()` :清空集合中所有的元素。

 

- `public boolean isEmpty()`: 判断当前集合是否为空。

 

 

 

第二节、Iterator迭代器（遍历集合）

一、概述

（一）在程序开发中，经常需要遍历集合中的所有元素。

（二）针对这种需求，JDK专门提供了一个接口`java.util.Iterator`。`Iterator`接口也是Java集合中的一员，但它与`Collection`、`Map`接口有所不同，`Collection`接口与`Map`接口主要用于存储元素，而`Iterator`主要用于【迭代访问（即遍历）】`Collection`中的元素，因此`Iterator`对象也被称为迭代器。

二、方法

（一）构造方法

public Iterator iterator(): 获取集合对应的迭代器，用来遍历集合中的元素

（二）常用方法

1、public E next()`:返回迭代的下一个元素。

2、public boolean hasNext()`:如果仍有元素可以迭代，则返回 true。

三、迭代器的实现原理

Iterator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素，

 

在调用Iterator的next方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，

 

当第一次调用迭代器的next方法后，迭代器的索引向后移动一位，指向第一个元素并将该元素返回，

 

当再次调用next方法时，迭代器的索引会指向第二个元素并将该元素返回，

 

依此类推，直到hasNext方法返回false，表示到达了集合的末尾，终止对元素的遍历。

 

四、增强for（也叫for each）

（一）概念、格式、特点

1、概念：增强for循环(也称for each循环)是JDK5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

2、格式：

for(元素的数据类型  变量 : Collection集合or数组){

    //写操作代码

}

3、特点：遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

（二）用法（遍历数组、集合）

1、遍历数组

2、遍历集合

 

第三节、泛型

一、泛型的概念、格式、特点

（一）泛型的概念：

1、可以在类或方法中预支地使用未知的类型。

（创建对象时，将未知的类型确定具体类型。当没有指定泛型时，默认类型为Object类型）

2、使用泛型： 即什么时候确定泛型。

（二）泛型的格式

1、类的泛型格式  修饰符 class 类名<代表泛型的变量> {  }

（1）创建对象确定泛型

（2）自定义泛型类

2、方法的泛型格式  修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

3、接口的泛型格式  修饰符 interface接口名<代表泛型的变量> {  }

（1）创建接口确定泛型

（2）始终不确定泛型的类型，直到创建对象时，确定泛型的类型

 

（三）泛型的特点

1、将运行时期的ClassCastException，转移到了编译时期变成了编译失败。

2、避免了类型强转的麻烦。

3、当没有指定泛型时，默认类型为Object类型。

4、泛型不存在继承关系 Collection<Object> list = new ArrayList<String>();这种是错误的。

二、泛型通配符

（一）泛型通配符的概念、格式、特点

1、泛型通配符的概念

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

2、泛型通配符的格式 符号问号 ？

3、泛型通配符的特点：受限泛型 （高级使用）

（1）泛型的上限 ？extens

格式：类型名称 <? extends 类 > 对象名称

意义：只能接收该类型及其子类

（2）泛型的下限 ？super

格式：类型名称 <? super 类 > 对象名称

意义：只能接收该类型及其父类型

 

• - - - - 半天 - - - - - - - - - - - - - - - - - - - - - - - - - - - -

第四节、集合综合案例-斗地主案例（单列）

一、案例介绍

按照斗地主的规则，完成洗牌发牌的动作。

具体规则：

使用54张牌打乱顺序,三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。

二、案例分析

（一）准备牌：

  牌可以设计为一个ArrayList<String>,每个字符串为一张牌。

  每张牌由花色数字两部分组成，我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。

  牌由Collections类的shuffle方法进行随机排序。

（二）发牌

将每个人以及底牌设计为ArrayList<String>,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。

（三）看牌

直接打印每个集合。

三、代码实现

第五节、常见的数据结构（栈、队列、数组、链表、红黑树）

一、栈

（一）概念

1、栈：stack,又称堆栈，它是运算受限的线性表，其限制是仅允许在标的一端进行插入和删除操作，不允许在其他任何位置进行添加、查找、删除等操作。

2、压栈：就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。

3、弹栈：就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置。

（二）特点

1、先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。例如子弹压弹夹

2、栈的入口、出口的都是栈的顶端位置。

二、队列

（一）概念

队列： queue,简称队，它同堆栈一样，也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，而在表的另一端进行删除。

（二）特点

1、先进先出（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。例如火车过山洞

2、队列的入口、出口各占一侧。

三、数组

（一）概念

数组:Array,是有序的元素序列，数组是在内存中开辟一段连续的空间，并在此空间存放元素。

（二）特点

1、查找元素快：通过索引，可以快速访问指定位置的元素

2、增删元素慢

3、指定索引位置增加元素：需要创建一个新数组，将指定新元素存储在指定索引位置，再把原数组元素根据索引，复制到新数组对应索引的位置。

4、指定索引位置删除元素：需要创建一个新数组，把原数组元素根据索引，复制到新数组对应索引的位置，原数组中指定索引位置元素不复制到新数组中。

四、链表

（一）概念

链表:linked list,由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。我们常说的链表结构有单向链表与双向链表。

（二）特点

1、多个结点之间，通过地址进行连接。例如，多个人手拉手，每个人使用自己的右手拉住下个人的左手，依次类推，这样多个人就连在一起了。

2、查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素。

3、增删元素快：只需要修改连接下个元素的地址即可。

五、红黑树

（一）概念

二叉树：binary tree,是每个结点不超过2的有序树（tree）,每个结点上都最多只能有两个子结点。

二叉树是每个节点最多有两个子树的树结构。顶上的叫根结点，两边被称作“左子树”和“右子树”。

（二）红黑树的约束特点

1、节点可以是红色的或者黑色的

2、根节点是黑色的

3、叶子节点(特指空节点)是黑色的

4、每个红色节点的子节点都是黑色的

5、任何一个节点到其每一个叶子节点的所有路径上黑色节点数相同

6、❤❤❤速度特别快,趋*衡树,查找叶子元素最少和最多次数不多于二倍

 

第六节、List接口

一、List接口概念、特点

（一）概念

java.util.List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合。在List集合中允许【重复】的元素，所有的元素是以一种【线性】方式进行存储的，在程序中可以通过【索引】来访问集合中的指定元素。

（二）特点

1、它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。

2、它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。

3、集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

二、常用方法（List集合特有的方法都是跟索引相关）

（一）void add(int index, E element): 添加元素到集合的指定位置。

       boolean add():往集合尾部添加元素，返回布尔值。

（二）E remove(int index)`: 移除集合中指定位置的元素，返回被移除的该元素。

（三）E set(int index, E element): 替换集合中指定位置的元素，返回被替换的该元素。

（四）E get(int index): 返回集合中指定位置的元素。(size、iterator、foreach三选一遍历)

三、List接口的子类

（一）ArrayList集合

1、ArrayList集合的概念、特点

（1）概念

java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。

许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。

（2）特点

元素增删慢，查找快。

2、常用方法

（1）boolean add（E  e）：向集合当中添加元素，参数的类型和泛型一致。

备注：对于ArrayList集合来说，add添加动作【一定成功】，所以返回值可用可不用。

但是对于其他集合，add添加动作【不一定成功】。

（2）E remove（int index）：从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。

（3）int size（）：获取集合的尺寸长度，返回值是集合中包含的元素个数。

（4）E get（int index）：从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。

 

（二）LinkedList集合

1、LinkedList集合的概念

`java.util.LinkedList`集合数据存储的结构是链表结构。方便元素添加、删除的集合。LinkedList是一个双向链表。

2、常用方法（LinkedList特有）

（1）void addFirst(E e)`:将指定元素插入此列表的开头。

（2）void addLast(E e)`:将指定元素添加到此列表的结尾。

（3）E getFirst()`:返回此列表的第一个元素。

（4）E getLast()`:返回此列表的最后一个元素。

（5）E removeFirst()`:移除并返回此列表的第一个元素。

（6）E removeLast()`:移除并返回此列表的最后一个元素。

（7）E pop()`:从此列表所表示的堆栈处弹出一个元素。

（8）void push(E e)`:将元素推入此列表所表示的堆栈。

（9）boolean isEmpty()`：如果列表不包含元素，则返回true。

第七节、Set接口

一、Set接口概念、特点

（一）概念

`java.util.Set`接口和`java.util.List`接口一样，同样继承自`Collection`接口，它与`Collection`接口中的方法基本一致，并没有对`Collection`接口进行功能上的扩充，只是比`Collection`接口更加严格了。与`List`接口不同的是，`Set`接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

（二）特点

1、Set集合取出元素的方式可以采用：迭代器、增强for。

2、`Set`接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

二、常用方法（Set元素无序、不重复）

与Collection接口中的方法基本一致,没有扩充功能

- `public boolean add(E e)`：  把给定的对象添加到当前集合中。

- `public boolean contains(E e)`: 判断当前集合中是否包含给定的对象。

- `public boolean remove(E e)`: 把给定的对象在当前集合中删除。

- `public int size()`: 返回集合中元素的个数。

- `public Object[] toArray()`: 把集合中的元素，存储到数组中。

- `public void clear()` :清空集合中所有的元素。

- `public boolean isEmpty()`: 判断当前集合是否为空。

三、Set接口的子类

（一）HashSet

1、HashSet集合的概念、特点

（1）概念

①`java.util.HashSet`是`Set`接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。

②`java.util.HashSet`底层的实现其实是一个`java.util.HashMap`支持。

（2）特点

①HashSet是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。

②保证元素唯一性的方式依赖于：hashCode与equals方法。

③HashSet集合存储数据的结构---哈希表。

在JDK8之前，哈希表底层采用【数组+链表】实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。

而JDK1.8中，哈希表存储采用【数组+链表+红黑树】实现，当链表长度超过【阈值（8）】时，将链表转换为红黑树，这样大大减少了查找时间。

总之，JDK8引入红黑树大程度优化了HashMap的性能，对于保证HashSet集合元素的唯一，即根据对象的hashCode和equals方法来决定的。

如果往集合中存放自定义的对象，想保证其唯一，就必须复写hashCode和equals方法建立属于当前对象的比较方式。

④HashSet存储自定义类型元素。

给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一。

（二）LinkedHashSet集合（HashSet的子类）

1、LinkedHashSet集合的特点

（1）HashSet保证元素唯一，元素无序的

（2）LinkedHashSet是链表和哈希表组合的一个数据存储结构。保证存取有序。（遍历序和插入序是一致的）

四、可变参数

（一）可变参数的概念

在JDK5之后，如果定义一个方法需要接受多个参数，并且多个参数类型一致，则可以用可变参数。

（二）可变参数的格式

修饰符 返回值类型 方法名(参数类型... 形参名){  }

【等价于 修饰符 返回值类型 方法名(参数类型[] 形参名){  } ，区别：这个在调用时必须传递数组，而可变参数可以直接传递数据即可。】

（三）可变参数的特点

同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递。

其实是编译成的class文件，将这些元素先封装到一个数组中，在进行传递。（这些动作都在编译.class文件时，自动完成了。）

 

第八节、Collections工具类

一、Collections工具类的概念

java.utils.Collections`是集合工具类，用来对集合进行操作。

二、常用方法

（一）static <T> boolean addAll(Collection<T> c, T... elements)  `:往集合中添加一些元素。

（二）static void shuffle(List<?> list) 打乱顺序`:打乱集合顺序。

（三）static <T> void sort(List<T> list)`:将集合中元素按照默认规则排序。【自己(this) - 参数 = 升序】

sort(List<T> list)使用前提：被排序的集合里边存储的元素，必须【实现Comparable】，【重写接口中的compareTo方法】定义排序的规则

（String泛型是因为jdk自带的String类实现了Comparable并重写了compareTo方法）

（四）★★★★★static <T> void sort(List<T> list，Comparator<? super T> )`:将集合中元素按照指定规则排序。

三、比较器【Comparable和Comparator】【static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。】

（一）Comparable和Comparator的用法（默认、自定义）

1、自然排序（java.lang.Comparable接口）

public static <T> void sort(List<T> list)`:将集合中元素按照默认规则排序。【自己(this) - 参数 = 升序】

2、比较器排序（java.util.Comparator接口）

static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。

public int compare(String o1, String o2)：比较其两个参数的顺序。

前-后：升序

后-前：降序

多重排序规则：

（二）Comparable和Comparator两个接口的区别

1、Comparable：强行对实现它的每个类的对象进行整体排序。

这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。

只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。

实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

2、Comparator：强行对某个对象进行整体排序。

可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。

还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

 

 

第九节、Map接口

一、Map接口的概念、特点

（一）概念

1、映射：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。

2、双列集合。键不重复，值可重复。一键一值。

3、常用子类

（1）HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。

由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

（2）LinkedHashMap<K,V>：HashMap的子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。存取一致。

通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

（二）特点

1、Collection`中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。

2、Map`中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。

3、Collection`中的集合称为单列集合，`Map`中的集合称为双列集合。

4、Map`中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

5、Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以。

二、Map接口的常用方法

（一）V put(K key, V value):把指定的键与值添加到Map集合中。

1、使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；

2、若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

（二）boolean containsKey(Object key)：判断集合是否包含指定的键，返回布尔值。

（三）V remove(Object key):把指定的键 所对应的键值 在Map集合中删除，返回被删除元素的值。

 

（四）Set<K> keySet():返回Map集合中所有的键，存储到Set集合中。

（五）V get(Object key): 根据指定的键，返回Map集合中对应的值。

 

（六）Set<Map.Entry<K,V>> entrySet():返回Map集合中所有的键值对对象的集合(Set集合)。

三、Map接口的遍历和找值（键找值、键值对找值）

（一）遍历键找值

1、【Set<K> keySet()】。返回Map集合中所有的键，存储到Set集合中。

2、【遍历集合】。遍历key所在的Set集合，得到每一个key。

3、【V get(K key) 】。根据指定的键，返回Map集合中对应的值。

（二）遍历键值对找值（Entry键值对对象）

1、Entry的概念、格式

（1）概念：

①Map中存放的是两种对象，一种为key(键)，一种为value(值)，它们在Map中是一一对应关系，这一对对象又称做Map中的一个Entry(项)。

②Entry将键值对的对应关系封装成了对象。即键值对对象

③在遍历Map集合时，可从每一个键值对（Entry）对象中获取对应的键与对应的值。

（2）格式：（在Map集合中提供,获取所有Entry对象的方法）

Set< Map.Entry<K,V> >  entrySet() : 获取Map集合中所有的键值对对象的集合(Set集合)。

2、Entry常用方法（获取对应键、值）

（1）K getKey()：返回Entry对象中的键。

（2）V getValue()：返回Entry对象中的值。

3、遍历键值对找值

（1）【Set< Map.Entry<K,V> >  entrySet() 】。返回 以Set形式存储的 Entry对象。

（2）【遍历集合】。遍历Entry所在的Set集合，得到每一个entry。

（3）【K getkey() && V getValue()】通过entry对象，返回键与值。

四、Map接口的子类（HashMap、LinkedHashMap）

（一）HashMap

1、概念

（1）存储数据采用的哈希表结构，元素的存取顺序不能保证一致。哈希表存储采用【数组+链表+红黑树(8)】实现（jdk8以前为【数组+链表】）

（2）由于要保证键的唯一、不重复， 需要【重写】键的hashCode()方法、equals()方法。

（3）HashMap保证成对元素唯一，并且查询速度很快，成对元素存放进去是没有顺序的。

2、HashMap存储自定义类型键值

练习：每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。

（二）LinkedHashMap（HashMap的子类）

1、概念

（1）存储数据采用的哈希表结构+链表结构。通过链表保证元素的存取顺序一致；通过哈希表保证的键的唯一、不重复。

（2）由于要保证键的唯一、不重复, 需要【重写】键的hashCode()方法、equals()方法。

2、保证有序，唯一不重复还要速度快。哈希表结构+链表结构。

（HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的。）

五、Map集合练习: 计算一个字符串中每个字符出现次数。

第十节、JDK9的补充— of方法（静态工厂方法）

一、of()方法只是Map，List，Set这三个接口的静态方法，其父类接口和子类实现并没有这类方法，比如    HashSet，ArrayList等

二、返回的集合是不可变的；

 

第十一节、斗地主案例（双列）

步骤：

一、准备牌：

完成数字与纸牌的映射关系：

使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个字典)。

二、洗牌：

通过数字完成洗牌发牌

三、发牌：

将每个人以及底牌设计为ArrayList<String>,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。

存放的过程中要求数字大小与斗地主规则的大小对应。

将代表不同纸牌的数字分配给不同的玩家与底牌。

四、看牌：

通过Map集合找到对应字符展示。

通过查询纸牌与数字的对应关系，由数字转成纸牌字符串再进行展示。