Java 集合体系

JackFeng

发布于：May 7, 2020

Java

7.5k words

33 min

次浏览

Java集合体系

1、集合体系

0、Collection

集合的体系结构：

有不同的数据结构(数据的组织，存储方式)

学习方式：最顶层

实现：最底层

Collection—-> List—> ArrayList

常用：

add 添加

clear 清空

contains 是否包含指定元素

isEmpty 是否为空

remove 删除

size 返回集合中的元素个数

toArray 返回包含此集合中所有元素的数组。(遍历数组即可)

Modifier and Type	Method and Description
`boolean`	`add(E e)` 确保此集合包含指定的元素（可选操作）。
`boolean`	`addAll(Collection c)` 将指定集合中的所有元素添加到这个集合（可选操作）。
`void`	`clear()` 从这个集合中移除所有的元素（可选操作）。
`boolean`	`contains(Object o)` 返回 `true`如果集合包含指定元素。
`boolean`	`containsAll(Collection c)` 返回 `true`如果这个集合包含指定集合的所有元素。
`boolean`	`equals(Object o)` 将指定的对象与此集合进行比较，以进行相等性。
`int`	`hashCode()` 返回此集合的哈希代码值。
`boolean`	`isEmpty()` 返回 `true`如果集合不包含任何元素。
`Iterator`	`iterator()` 返回此集合中的元素的迭代器。
`default Stream`	`parallelStream()` 返回一个可能并行 `Stream`与集合的来源。
`boolean`	`remove(Object o)` 从这个集合中移除指定元素的一个实例，如果它是存在的（可选操作）。
`boolean`	`removeAll(Collection c)` 删除此集合中包含的所有元素（可选操作）的所有元素（可选操作）。
`default boolean`	`removeIf(Predicate filter)` 删除满足给定谓词的这个集合的所有元素。
`boolean`	`retainAll(Collection c)` 仅保留包含在指定集合中的这个集合中的元素（可选操作）。
`int`	`size()` 返回此集合中的元素的数目。
`default Spliterator`	`spliterator()` 创建此集合中的元素的 `Spliterator`。
`default Stream`	`stream()` 返回一个序列 `Stream`与集合的来源。
`Object[]`	`toArray()` 返回包含此集合中所有元素的数组。
`T[]`	`toArray(T[] a)` 返回包含此集合中所有元素的数组；返回数组的运行时类型是指定的数组的运行时类型。

1、Iterator

集合的遍历方式：

1、toArray(),可以把集合转换成数组,然后遍历数组即可 【有序】

2、iterator(),返回迭代器对象，可以通过迭代器对象来迭代集合

next() : 返回下一个元素。

hasNext() : 判断是否有元素可以获取

注意：

迭代器是依赖于集合的，相当于集合的一个副本,但迭代器在操作的时候，如果发现和集合不一样，则抛出异常。

Exception in thread “main ” java.util.ConcurrentModificationExeption

解决方案：

使用迭代器遍历时，用迭代器本身修改。

List.listIterator()

package learn;

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

/**
 *
 * @author JackFeng
 * @date 2020/3/25
 */
public class IteratorDemo {

    public static void main(String[] args) {
//        method();

        // 创建集合对象
        Collection c = new ArrayList();

        //添加元素
        c.add("hello");
        c.add("2020");
        c.add("你好啊");

        //获取数组 使用迭代器
        Iterator it = c.iterator();

        while (it.hasNext()){
            System.out.println(it.next());
        }



    }

    private static void method() {
        //快捷键：CTRL + ALT + M  将代码封装成方法

        // 创建集合对象
        Collection c = new ArrayList();

        //添加元素
        c.add("hello");
        c.add("2020");
        c.add("你好啊");

        //获取数组

        Object[] objects = c.toArray();

        // 遍历数组
        for (int i = 0; i <objects.length ; i++) {
            System.out.println(objects[i]);
        }
    }

}

2、迭代并发修改

判断集合中是否有 “hello ” 如果有，则添加元素 “wolrd”

异常：
Exception in thread "main" java.util.ConcurrentModificationException

package learn;

import java.util.*;

/**
 *
 * @author JackFeng
 * @date 2020/3/25
 */
public class ListIteratorDemo {
    public static void main(String[] args) {
//        mothod();


        //创建集合对象
//        Collection c = new ArrayList();
        List c = new ArrayList();

        // 添加元素
        c.add("hello");
        c.add("2020您好");

        //迭代器遍历
/*        Iterator it = c.iterator();
        while (it.hasNext()){
            String s = (String) it.next();
            if (s.equals("hello")) {
                c.add("world");
            }

        }*/
        ListIterator lit = c.listIterator();
        while (lit.hasNext()) {
            String s = (String) lit.next();
            if (s.equals("hello")) {
                // 注意 使用迭代器添加，不可使用集合添加，迭代器就会同步集合
                lit.add("world");
            }
        }
        System.out.println(c);




    }

    private static void mothod() {
        //创建集合对象
        Collection c = new ArrayList();

        // 添加元素
        c.add("hello");
        c.add("2020您好");
        if (c.contains("hello")){
            c.add("world");
        }
        System.out.println(c);
    }
}

3、泛型

泛型：是一种广泛的类型

优点：

避免类型转换的问题

减少黄色警告线

简化代码书写

什么情况使用泛型—— ** **

package learn;

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

/**
 *
 * @author JackFeng
 * @date 2020/3/25
 */
public class GenericDemo {

    public static void main(String[] args) {

        // 创建集合对象
//        Collection c = new ArrayList();
        Collection<Student> c = new ArrayList<Student>();

        //创建元素对象
        Student s = new Student("Jack", 22);
        Student s1 = new Student("Jack1", 25);
        // 添加元素

        c.add(s);
        c.add(s1);

        //遍历集合对象
//        Iterator ir = c.iterator();
        Iterator<Student> ir = c.iterator();
        while (ir.hasNext()) {
            // 转换出错
//            Exception in thread "main" java.lang.ClassCastException: learn.Student cannot be cast to java.lang.String
//            String str = (String) ir.next();
//            System.out.println(str);

            Student stu = ir.next();
            System.out.println(stu.name);

        }


    }

}


class Student{
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

4、foreache

增强for循环，一般用于遍历集合或者数组

格式：

for（元素的类型变量：集合或者数组对象) {

可以使用变量；

}

package learn;

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

/**
 *
 * @author JackFeng
 * @date 2020/3/25
 */




public class ForEachDemo {
    public static void main(String[] args) {


        //创建集合对象
//        Collection c = new ArrayList();
        Collection<String> c = new ArrayList<String>();

        //添加集合元素
        c.add("hello");
        c.add("20200325");

        //增强for循环
/*        for (Object obj:c
             ) {
            System.out.println(obj);
        }*/

        for (String string:c
             ) {

            // 在增强for循环中不可修改集合 否则会出现 并发修改错误
//            c.add("123");

            System.out.println(string.toUpperCase());

        }

    }

}

2、数据结构

0、数组

数组： int [] arr = { 11,12,13,14};

查找快，增删慢

1、链表

链表：由链子连接起来的一堆结点

结点： 地址值，值，下一个结点地址值

获取x结点方式：

遍历查找

x结点的后边添加新的结点：

x结点的下一个结点地址值修改为新的地址值，把新结点的下一个地址值改为 x+1

查询慢，增删快

2、栈&队列

栈：先进后出

堆：先进先出

3、集合List

序列：指哪插哪

特点：

有序（存储和读取顺序一样）

整数索引

允许重复的

功能：

增 add(int index, E element) —– 在指定索引位置添加指定元素

删 remove(int index) —– 删除指定元素并返回

改 set(int index, E element) —- 将指定索引位置的元素替换为指定元素，并将原来的元素返回。

查 get(int index) —– 根据索引返回元素(防止越界(不存在))

常用子类

ArrayList：

底层是数组结构，查询快，增删慢

LinkedList:

底层结构是链表，查询慢，增删快

常用

void addLast

getFirst

getLast

removeFirst

removeLast

Modifier and Type	Method and Description
`boolean`	`add(E e)` 将指定的元素列表的结束。
`void`	`add(int index, E element)` 在列表中指定的位置上插入指定的元素。
`boolean`	`addAll(Collection c)` 追加指定集合的所有元素到这个列表的末尾，按他们的指定集合的迭代器返回。
`boolean`	`addAll(int index, Collection c)` 将指定集合中的所有元素插入到该列表中，从指定位置开始。
`void`	`addFirst(E e)` 在此列表的开始处插入指定的元素。
`void`	`addLast(E e)` 将指定的元素列表的结束。
`void`	`clear()` 从这个列表中移除所有的元素。
`Object`	`clone()` 返回该 `LinkedList`浅拷贝。
`boolean`	`contains(Object o)` 返回 `true`如果这个列表包含指定元素。
`Iterator`	`descendingIterator()` 返回在反向顺序在deque容器元素的迭代器。
`E`	`element()` 检索，但不删除，此列表的头（第一个元素）。
`E`	`get(int index)` 返回此列表中指定位置的元素。
`E`	`getFirst()` 返回此列表中的第一个元素。
`E`	`getLast()` 返回此列表中的最后一个元素。
`int`	`indexOf(Object o)` 返回此列表中指定元素的第一个出现的索引，或-如果此列表不包含元素，或- 1。
`int`	`lastIndexOf(Object o)` 返回此列表中指定元素的最后一个发生的索引，或-如果此列表不包含元素，或- 1。
`ListIterator`	`listIterator(int index)` 返回此列表中元素的列表迭代器（在适当的顺序），从列表中的指定位置开始。
`boolean`	`offer(E e)` 将指定的元素添加到列表的尾部（最后一个元素）。
`boolean`	`offerFirst(E e)` 在列表的前面插入指定的元素。
`boolean`	`offerLast(E e)` 在列表的结尾插入指定的元素。
`E`	`peek()` 检索，但不删除，此列表的头（第一个元素）。
`E`	`peekFirst()` 检索，但不删除该列表的第一个元素，或返回 `null`如果这个列表是空的。
`E`	`peekLast()` 检索，但不删除该列表的最后一个元素，或返回 `null`如果这个列表是空的。
`E`	`poll()` 检索并删除此列表的头（第一个元素）。
`E`	`pollFirst()` 检索并移除此列表的第一个元素，或返回 `null`如果这个列表是空的。
`E`	`pollLast()` 检索并移除此列表的最后一个元素，或返回 `null`如果这个列表是空的。
`E`	`pop()` 从这个列表所表示的堆栈中弹出一个元素。
`void`	`push(E e)` 将一个元素推到由该列表所表示的堆栈上。
`E`	`remove()` 检索并删除此列表的头（第一个元素）。
`E`	`remove(int index)` 移除此列表中指定位置的元素。
`boolean`	`remove(Object o)` 从该列表中移除指定元素的第一个发生，如果它是存在的。
`E`	`removeFirst()` 移除并返回此列表中的第一个元素。
`boolean`	`removeFirstOccurrence(Object o)` 删除此列表中指定元素的第一个出现（当遍历从头到尾的列表）。
`E`	`removeLast()` 移除并返回此列表中的最后一个元素。
`boolean`	`removeLastOccurrence(Object o)` 删除此列表中指定元素的最后一次（当遍历从头到尾的列表时）。
`E`	`set(int index, E element)` 用指定元素替换此列表中指定位置的元素。
`int`	`size()` 返回此列表中元素的数目。
`Spliterator`	`spliterator()` 创建一个后期绑定和快速失败 `Spliterator`超过此列表中的元素。
`Object[]`	`toArray()` 返回一个数组，包含在这个列表中的所有元素在适当的顺序（从第一个到最后一个元素）。
`T[]`	`toArray(T[] a)` 返回一个数组，包含在这个列表中的所有元素在适当的顺序（从第一到最后一个元素）；返回数组的运行时类型是指定的数组的运行时类型。

package learn;

import java.util.ArrayList;
import java.util.List;

/**
 *
 * @author JackFeng
 * @date 2020/3/26
 */

/*
* 定义一个方法，返回指定列表中指定元素的索引位置
*
*
* 升级
* */


public class ListedListDemo {

    public static void main(String[] args) {

        List list = new ArrayList();

        list.add("hello");
        list.add("A2Data");
        list.add("scala");

        int index = index(list, "python");
        System.out.println(index);


        boolean flag = contains(list, "scala");
        System.out.println(flag);


        boolean flag1 = list.contains("java");
        System.out.println(flag1);


    }

    public static int index(List list, Object object) {

        // 索引遍历方式
        for (int i = 0; i <list.size() ; i++) {
            // 获取列表中的元素
            Object o = list.get(i);

            // 判断列表中的元素和指定元素是否相等
            // 如果使用 ==  是拿地址值去比较的
            if (o.equals(object)){
                return i;
            }

        }
        // 查找不到指定元素
        return -1;

    }


    public static boolean contains(List list, Object o) {
        // 获取指定元素在指定列表中的索引位置
        int index = index(list, o);
        // 判断是否村子
        if (index >= 0) {
            return true;
        } else {
            return false;
        }

    }



}

4、集合Set

特点：

无序（存储和读取顺序有可能不一样）

不允许重复（要求元素唯一）

没有索引

HashSet的add() 方法流程：

首先会使用当前集合中的每一个元素和新添加的元素进行hash值比较

如果hash值不同，则直接添加新的元素

如果hash值相同，比较地址值，或使用 equals方法进行比较

比较结果一样，则认为是重复不添加

所有结果都不一样则添加

package learn;

import java.util.HashSet;
import java.util.Iterator;

/**
 * Created by JackFeng on 2020/3/26.
 */

/*
*使用HashSet存储字符串 并且遍历
*
* */


public class HashSetDemo {
    public static void main(String[] args) {
        // 创建集合对象
//        HashSet<String> hs = new HashSet<>();
        HashSet<String> set = new HashSet<>();

        //添加元素对象
        set.add("hello");
        set.add("2020");
        set.add("您好啊");

        //遍历集合
//        mothod(set);
//        method1(set);
//        method2(set);


    }

    private static void method2(HashSet<String> set) {
        //增强for
        for (String s:set
             ) {
            System.out.println(s);

        }
    }

    private static void method1(HashSet<String> set) {
        //迭代器
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
    }

    private static void mothod(HashSet<String> set) {
        //数组
        Object[] objects = set.toArray();
        for (int i = 0; i <objects.length ; i++) {
            System.out.println(objects[i]);
        }
    }
}

HashSet方法优化

package learn;

import java.util.HashSet;
import java.util.Objects;

/**
 *
 * @author JackFeng
 * @date 2020/3/26
 */
public class HashSetDemoTo {
    public static void main(String[] args) {

        //创建集合对象
        HashSet<Students> hs = new HashSet<Students>();

        //创建元素对象
        Students s = new Students("JackFeng", 22);
        Students s1 = new Students("JackFeng", 22);
        Students s2 = new Students("Jack", 25);

        //添加元素
        hs.add(s);
        hs.add(s1);
        hs.add(s2);

        //遍历集合对象
        for (Students students:hs
             ) {
            System.out.println(students);

        }


    }
}


class Students{
    String name;
    int age;


    public Students(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Students{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Students students = (Students) o;
        return age == students.age &&
                Objects.equals(name, students.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

Collections

面试题：Collection和collections 有何区别？

collection 是集合体系的最顶层，包含了集合体系的共性

collections 是一个工具类，方法都是用于操作collection

常用方法：

binarySearch ——- 二分查找(元素有序)

copy —— 源列表覆盖目标列表（目标》=源列表）

fill —— 使用指定的对象填充指定列表的所有元素

reverse —– 反转

shuffle —– 随机置换

sort —– 排序（自然顺序排序）

swap —- 指定列表中的两个索引位置互换

Modifier and Type	Method and Description
`static boolean`	`addAll(Collection c, T... elements)` 将所有指定的元素添加到指定的集合中。
`static Queue`	`asLifoQueue(Deque deque)` 返回一个 `Deque`视图为后进先出（LIFO） `Queue`。
`static int`	`binarySearch(List> list, T key)` 使用二进制搜索算法搜索指定对象的指定列表。
`static int`	`binarySearch(List list, T key, Comparator c)` 使用二进制搜索算法搜索指定对象的指定列表。
`static Collection`	`checkedCollection(Collection c, 类 type)` 返回一个指定集合的动态类型安全的观点。
`static List`	`checkedList(List list, 类 type)` 返回一个动态类型安全的查看指定的列表。
`static Map`	`checkedMap(Map m, 类 keyType, 类 valueType)` 返回一个动态类型安全的查看指定的Map。
`static NavigableMap`	`checkedNavigableMap(NavigableMap m, 类 keyType, 类 valueType)` 返回一个动态类型安全的查看指定的导航电子Map。
`static NavigableSet`	`checkedNavigableSet(NavigableSet s, 类 type)` 返回一个动态类型安全的集合视图指定通航。
`static Queue`	`checkedQueue(Queue queue, 类 type)` 返回一个动态类型安全的查看指定队列。
`static Set`	`checkedSet(Set s, 类 type)` 返回一个指定的动态类型安全的观点。
`static SortedMap`	`checkedSortedMap(SortedMap m, 类 keyType, 类 valueType)` 返回一个动态类型安全的查看指定的排序图。
`static SortedSet`	`checkedSortedSet(SortedSet s, 类 type)` 返回一个动态类型安全的查看指定的排序设置。
`static void`	`copy(List dest, List src)` 将所有的元素从一个列表复制到另一个列表中。
`static boolean`	`disjoint(Collection c1, Collection c2)` 返回 `true`如果两个指定集合没有共同的元素。
`static Enumeration`	`emptyEnumeration()` 返回一个没有元素的枚举。
`static Iterator`	`emptyIterator()` 返回一个没有元素的迭代器。
`static List`	`emptyList()` 返回一个空列表（不可变）。
`static ListIterator`	`emptyListIterator()` 返回一个没有元素的列表迭代器。
`static Map`	`emptyMap()` 返回一个空Map（不可变）。
`static NavigableMap`	`emptyNavigableMap()` 返回一个空的导航Map（不可变）。
`static NavigableSet`	`emptyNavigableSet()` 返回一个空的导航集（不可变）。
`static Set`	`emptySet()` 返回一个空集（不可变）。
`static SortedMap`	`emptySortedMap()` 返回一个空的排序映射（不可变）。
`static SortedSet`	`emptySortedSet()` 返回一个空的排序集（不可变）。
`static Enumeration`	`enumeration(Collection c)` 返回指定集合的枚举数。
`static void`	`fill(List list, T obj)` 用指定元素替换指定列表的所有元素。
`static int`	`frequency(Collection c, Object o)` 返回指定集合中等于指定对象的元素的数目。
`static int`	`indexOfSubList(List source, List target)` 返回指定的源列表中指定的目标列表的第一个发生的起始位置，或-如果没有这样的发生，则- 1。
`static int`	`lastIndexOfSubList(List source, List target)` 返回指定的源列表中指定的目标列表的最后一个发生的起始位置，或-如果没有这样的发生，则- 1。
`static ArrayList`	`list(Enumeration e)` 返回一个数组列表，该列表包含在返回的顺序中由枚举返回的元素的元素。
`static >T`	`max(Collection coll)` 返回最大元素的集合，根据其元素的自然排序。
`static T`	`max(Collection coll, Comparator comp)` 返回给定集合的最大元素，根据指定的比较器诱导的顺序。
`static >T`	`min(Collection coll)` 返回最小的元素的集合，根据其元素的自然排序。
`static T`	`min(Collection coll, Comparator comp)` 返回给定集合的最小元素，根据指定的比较器诱导的顺序。
`static List`	`nCopies(int n, T o)` 返回一个不可变列表包含指定对象的 `n`副本。
`static Set`	`newSetFromMap(Map map)` 返回一个由指定的映射支持的集合。
`static boolean`	`replaceAll(List list, T oldVal, T newVal)` 将列表中的某一特定值的所有出现替换为另一个。
`static void`	`reverse(List list)` 反转指定列表中元素的顺序。
`static Comparator`	`reverseOrder()` 返回一个比较器，对一系列的实施 `Comparable`界面对象的自然顺序相反。
`static Comparator`	`reverseOrder(Comparator cmp)` 返回一个对指定比较器的反向排序的比较器。
`static void`	`rotate(List list, int distance)` 按指定的距离旋转指定列表中的元素。
`static void`	`shuffle(List list)` 随机置换指定列表使用随机默认源。
`static void`	`shuffle(List list, Random rnd)` 随机排列指定列表使用指定的随机源。
`static Set`	`singleton(T o)` 返回只包含指定对象的不可改变的集合。
`static List`	`singletonList(T o)` 返回只包含指定对象的不可改变的列表。
`static Map`	`singletonMap(K key, V value)` 返回一个不可改变的Map，只将指定的指定的键映射到指定的值。
`static >void`	`sort(List list)` 指定列表为升序排序，根据其元素的 natural ordering。
`static void`	`sort(List list, Comparator c)` 根据指定的比较器指定的顺序对指定的列表进行排序。
`static void`	`swap(List list, int i, int j)` 在指定的列表中的指定位置上交换元素。
`static Collection`	`synchronizedCollection(Collection c)` 返回由指定集合支持的同步（线程安全）集合。
`static List`	`synchronizedList(List list)` 返回由指定列表支持的同步（线程安全）列表。
`static Map`	`synchronizedMap(Map m)` 返回由指定的Map支持的同步（线程安全）Map。
`static NavigableMap`	`synchronizedNavigableMap(NavigableMap m)` 返回指定的导航Map支持的同步（线程安全）导航Map。
`static NavigableSet`	`synchronizedNavigableSet(NavigableSet s)` 返回由指定的导航集支持的同步（线程安全）导航集。
`static Set`	`synchronizedSet(Set s)` 返回一个由指定集合支持的同步（线程安全）集。
`static SortedMap`	`synchronizedSortedMap(SortedMap m)` 返回一个由指定的排序映射支持的同步（线程安全）排序的Map。
`static SortedSet`	`synchronizedSortedSet(SortedSet s)` 返回一个由指定的排序集支持的同步（线程安全）排序集。
`static Collection`	`unmodifiableCollection(Collection c)` 返回指定集合的一个不可修改的视图。
`static List`	`unmodifiableList(List list)` 返回指定列表中的一个不可修改的视图。
`static Map`	`unmodifiableMap(Map m)` 返回指定映射的一个不可修改的视图。
`static NavigableMap`	`unmodifiableNavigableMap(NavigableMap m)` 返回指定的导航电子Map的一个不可修改的视图。
`static NavigableSet`	`unmodifiableNavigableSet(NavigableSet s)` 返回指定通航设置不可修改的视图。
`static Set`	`unmodifiableSet(Set s)` 返回指定的设置不可修改的视图。
`static SortedMap`	`unmodifiableSortedMap(SortedMap m)` 返回指定的排序图上一个不可修改的视图。
`static SortedSet`	`unmodifiableSortedSet(SortedSet s)` 返回指定的排序设置不可修改的视图。

模拟斗地主发牌

package learn;

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

/**
 * Created by JackFeng on 2020/3/26.
 */

/*
*
* 模拟斗地主发牌
* */

public class CollectionsTest {
    public static void main(String[] args) {

        //创作扑克牌
        //花色
        String[] color = {"黑桃", "红桃", "梅花", "方片"};

        //数字
        String[] nums = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

        //牌盒
        ArrayList<String> box = new ArrayList<String>();

        for (int i = 0; i <color.length ; i++) {
            // 得到每一个花色的牌
            for (int j = 0; j <nums.length ; j++) {
                // 得到每一个数字
                box.add(color[i] + nums[j]);
            }
        }

        box.add("大王");
        box.add("小王");

//        System.out.println(box.size());

        // 洗牌  使用置换方法
        Collections.shuffle(box);
//        System.out.println(box);

        // 牌友分牌  54-3 /3 = 17张  3张底牌
        ArrayList<String> A = new ArrayList<String>();
        ArrayList<String> B = new ArrayList<String>();
        ArrayList<String> C = new ArrayList<String>();

        for (int i = 0; i <box.size() -3; i++) {

            /*
            * i = 0; i % 3 = 0;
            * i = 1; i % 3 = 1;
            * i = 2; i % 3 = 2;
            * */

            if (i % 3 == 0) {
                A.add(box.get(i));
            } else if (i % 3 == 1) {
                B.add(box.get(i));
            } else if (i % 3 == 2) {
                C.add(box.get(i));
            }

        }
        System.out.println(A);

        //底牌
        for (int i = box.size()-3; i < box.size() ; i++) {
            System.out.println(box.get(i));
        }
        System.out.println();


    }
}

5、集合Map

Interface Map<K,V>

参数类型

K -钥匙的Map保持型

V -映射的值的类型

public interface Map<K,V>
映射键到值的对象。一张Map不能包含重复的键，每个键可以映射到至多一个值。

Map 和 Collection 的区别?

Map: 双列集合,常用于处理有对应关系的数据，key是不可以重复的

Collection：单列集合，collection有不同的子体系，有的允许重复有索引有序，有的不允许重复且无序。

Map常用功能：

映射功能

put key映射到value,若key存在，则覆盖value，并且返回原来的value；不存在则返回为null

获取功能

get 根据指定的key 返回对应的value

Set 获取所有的Key

Collection values 获取所有的Value

size 返回对应关系的个数

删除功能

clear 清空所有对应关系

remove 根据指定的key删除对应关系，并返回对应的value值，如果没有删除成功，返回null

判断功能

containsKey 判断指定的key是否存在，存在返回True 否则返回False

containsValue 判断指定的value是否存在

isEmpty 判断是否有对应关系

遍历功能：

Set

Modifier and Type	Method and Description
`void`	`clear()` 从这个映射中移除所有的映射（可选操作）。
`default V`	`compute(K key, BiFunction remappingFunction)` 试图计算出指定键和当前的映射值的映射（或 `null`如果没有当前映射）。
`default V`	`computeIfAbsent(K key, Function mappingFunction)` 如果指定的键是不是已经与价值相关的（或映射到 `null`），尝试使用给定的映射功能，进入到这个Map除非 `null`计算其价值。
`default V`	`computeIfPresent(K key, BiFunction remappingFunction)` 如果指定键的值是存在和非空的，尝试计算一个新的映射，给出了键和它当前的映射值。
`boolean`	`containsKey(Object key)` 返回 `true`如果这Map包含一个指定的键映射。
`boolean`	`containsValue(Object value)` 返回 `true`如果映射到指定的值的一个或多个键。
`Set>`	`entrySet()` 返回一个 `Set`视图的映射包含在这个Map。
`boolean`	`equals(Object o)` 将指定的对象与此映射的相等性进行比较。
`default void`	`forEach(BiConsumer action)` 在该映射中的每个条目执行给定的操作，直到所有的条目被处理或操作抛出异常。
`V`	`get(Object key)` 返回指定的键映射的值，或 `null`如果这个Map不包含的键映射。
`default V`	`getOrDefault(Object key, V defaultValue)` 返回指定的键映射的值，或 `defaultValue`如果这个Map不包含的键映射。
`int`	`hashCode()` 返回此映射的哈希代码值。
`boolean`	`isEmpty()` 返回 `true`如果这个Map不包含键值的映射。
`Set`	`keySet()` 返回一个 `Set`的关键视图包含在这个Map。
`default V`	`merge(K key, V value, BiFunction remappingFunction)` 如果指定的键已与值相关联的值或与空值相关联的，则将其与给定的非空值关联。
`V`	`put(K key, V value)` 将指定的值与此映射中的指定键关联（可选操作）。
`void`	`putAll(Map m)` 从指定的映射到这个Map（可选操作）复制所有的映射。
`default V`	`putIfAbsent(K key, V value)` 如果指定的键是不是已经与价值相关的（或映射到 `null`）将其与给定的值并返回 `null`，否则返回当前值。
`V`	`remove(Object key)` 如果存在（可选操作），则从该Map中移除一个键的映射。
`default boolean`	`remove(Object key, Object value)` 仅当它当前映射到指定的值时，为指定的键移除条目。
`default V`	`replace(K key, V value)` 仅当它当前映射到某一值时，替换指定的键的条目。
`default boolean`	`replace(K key, V oldValue, V newValue)` 仅当当前映射到指定的值时，替换指定的键的条目。
`default void`	`replaceAll(BiFunction function)` 将每个条目的值替换为在该项上调用给定函数的结果，直到所有的条目都被处理或函数抛出异常。
`int`	`size()` 返回这个映射中的键值映射的数目。
`Collection`	`values()` 返回一个 `Collection`视图的值包含在这个Map。

Tips方法实例

package learn;

import java.util.Collection;
import java.util.HashMap;
import java.util.Set;

/**
 *
 * @author JackFeng
 * @date 2020/3/27
 */
public class MapDemo {

    public static void main(String[] args) {
        //创建Map对象
        HashMap<String, String> map = new HashMap<>();

        // put 映射关系
        System.out.println(map.put("001", "Jack"));  // 输出为null
        System.out.println(map.put("002", "Jack Jie"));  // 输出为null
        System.out.println(map.put("001", "Jack Feng"));  // 输出为Jack

        System.out.println(map); //{001=Jack Feng}

        //`containsKey`
        System.out.println(map.containsKey("001"));

        //containsValue
        System.out.println(map.containsValue("Jack Feng"));

        // clear()
//        map.clear();


        //isEmpty
//        System.out.println(map.isEmpty());
//        method(map);


        // Collection
        Collection<String> values = map.values();

        for (String key:values
             ) {
            System.out.println(key);
        }

    }

    private static void method(HashMap<String, String> map) {
        //set 不允许重复
        Set<String> keys= map.keySet();

        for (String key:keys
             ) {
            System.out.println(key);

        }
    }

}

Map遍历

遍历方式：

A(比较繁琐)：

获取所有的key，遍历得到每一个key，让每个key去找对应的value

B：

entrySet()

使用HashMap存储数据（可以自定义对象作为Key）

package learn;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 *
 * @author JackFeng
 * @date 2020/3/27
 */
public class MapTest {
    public static void main(String[] args) {
        // 创建map对象

        HashMap<String, String> map = new HashMap<String, String>();

        // 映射关系
        map.put("001", "A");
        map.put("002", "B");
        map.put("003", "a2data.cn");


        // 第一种遍历方式
        // 方式1 获取所有的key 用过key 来获取value

        method(map);

        // 第二种遍历方式
        System.out.println("第二种遍历方式");
        Set<Map.Entry<String, String>> entries = map.entrySet();

        // 遍历集合
        // 需要用map 去修饰 Ectry ，因为是map的内部类
        // 方式2  获取entry对象 ，通过entry 对象来获取 key value

        for (Map.Entry<String, String> entry:entries
             ) {
            // 获取 key value
            String key = entry.getKey();
            String value = entry.getValue();

            System.out.println("key:"+key + "-----" + "value:"+value);

        }





    }

    private static void method(HashMap<String, String> map) {
        System.out.println("第一种遍历方式");
        // 召集所有key
        Set<String> keys = map.keySet();

        //遍历map对象
        for (String key:keys
             ) {
            // 每个key 找到value
            String value = map.get(key);
            System.out.println("key:"+key + "-----" + "value:"+value);
        }
    }
}

Key：自定义对象

package learn;

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

/**
 *
 * @author JackFeng
 * @date 2020/3/27
 */
public class HashMapTest {
    public static void main(String[] args) {

        // 创建Map对象
        HashMap<Message, String> hashMap = new HashMap<Message,String>();
        // 创建Key对象
        Message ms = new Message("未读消息",12);
        Message ms1 = new Message("已读消息",22);
        Message ms2 = new Message("已读消息",22);  // 如果想要这个不添加  重写 hashcode 和 equals

        // 添加映射关系
        hashMap.put(ms, "001");
        hashMap.put(ms1, "002");
        hashMap.put(ms2, "002");

        // 遍历 我们使用 Entry 使用entrySet

        Set<Map.Entry<Message, String>> entrys = hashMap.entrySet();

        for (Map.Entry<Message, String> entry:entrys
             ) {
            Message key = entry.getKey();
            String value = entry.getValue();


            System.out.println( key + value );
            // 发现输出是如下 是因为少写了 toString 方法
            //learn.Message@74a14482002
            //learn.Message@4554617c001

        }


    }
}



class Message{
    String name;
    int nums;

    public Message(String name, int nums) {
        this.name = name;
        this.nums = nums;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getNums() {
        return nums;
    }

    public void setNums(int nums) {
        this.nums = nums;
    }


    // 解决输出 是地址值
    @Override
    public String toString() {
        return "Message{" +
                "name='" + name + '\'' +
                ", nums=" + nums +
                '}';
    }


    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Message message = (Message) o;
        return nums == message.nums &&
                Objects.equals(name, message.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, nums);
    }
}