集合继承体系的面向对象思想
接口：用来明确所有集合中该具有的功能，相当于在定义集合功能标准；
抽象类：把多个集合中功能实现方式相同的方法，抽取到抽象类实现，具体集合不再遍写，继承使用即可；
具体类：继承抽象类，实现接口，重写所有抽象方法，达到具备指定功能的集合。
每个具体集合类，根据自身的数据存储结构方式，对接口中的功能方法，进行不同方式的实现。
Map接口概述：
Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。
Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。
Collection中的集合称为单列集合，Map中的集合称为双列集合。
需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。
Map中常用的集合为HashMap集合、LinkedHashMap集合。
Map接口中常用集合概述
HashMap集合、LinkedHashMap集合：
HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。
由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。
通过链表结构可以保证元素的存取顺序一致；
通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。
注意：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。
两个泛型变量<K,V>的数据类型可以相同，也可以不同。
Map接口中的常用方法
put方法：将指定的键与值对应起来，并添加到集合中
方法返回值为键所对应的值
使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；
使用put方法时，若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），
并把指定键所对应的值，替换成指定的新值。
get方法：获取指定键(key)所对应的值(value)
remove方法：根据指定的键(key)删除元素，返回被删除元素的值(value)。
代码实现：
1 package com.oracle.map;
2
3 import java.util.HashMap;
4 import java.util.Iterator;
5 import java.util.Map;
6 import java.util.Set;
7
8 public class Demo01 {
9
10 public static void main(String[] args) {
11 HashMap<Integer,String> map=new HashMap<Integer,String>();
12 map.put(1, "aaa");
13 map.put(2, "bbb");
14 map.put(3, "aaa");
15 map.put(3, "ccc");
16 /*System.out.println(map.get(3));
17 System.out.println(map.remove(2));*/
18 //1.键找值keySet()
19 //获取所有键所对应的set集合
20 /*Set<Integer> set=map.keySet();
21 //遍历所有的键
22 Iterator<Integer> it=set.iterator();
23 while(it.hasNext()){
24 //获取键
25 int key=it.next();
26 //通过键找值
27 String value=map.get(key);
28 System.out.println(key+"...."+value);
29 }*/
30 //2.获取结婚证entrySet()
31 //获取结婚证集合
32 Set<Map.Entry<Integer, String>> set=map.entrySet();
33 //增强for遍历结婚证集合 获取到每一个结婚证对象
34 for(Map.Entry<Integer, String> entry:set){
35 //通过每一个结婚证对象获取key和value
36 int key=entry.getKey();
37 String value=entry.getValue();
38 System.out.println(key+"....."+value);
39 }
40
41 }
42
43 }
Map集合遍历键找值方式
键找值方式：即通过元素中的键，获取键所对应的值
1.获取Map集合中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键
2.遍历键的Set集合，得到每一个键
3.根据键，获取键所对应的值
HashMap存储自定义类型键值:
HashMap:
特点：
是Map集合的子集合
底层采用哈希表结构
HashMap集合中的key不能重复，通过重写hashCode() 与 equals()方法来保证键的唯一。
不能保证元素存与取的顺序完全一致
LinkedHashMap:
特点：
是HashMap集合的子集合
底层采用哈希表+链表结构
LinkedHashMap集合中的key不能重复，通过重写hashCode() 与 equals()方法来保证键的唯一。
集合嵌套：
1 package com.oracle.map;
2
3 import java.util.HashMap;
4 import java.util.Map;
5 import java.util.Set;
6
7 //HashMap<String, HashMap<String,String>>
8 //基地Oracle
9 //Java0601
10 // 1 熊大
11 // 2 熊二
12 //Java0328
13 // 1 张维
14 // 2 王荣臣
15 public class Demo03 {
16 public static void main(String[] args) {
17 //基地oracle
18 HashMap<String, HashMap<String,String>> oracle
19 =new HashMap<String, HashMap<String,String>>();
20 //班级class
21 HashMap<String,String> java0601=new HashMap<String,String>();
22 java0601.put("1", "熊大");
23 java0601.put("2", "熊二");
24 HashMap<String,String> java0328=new HashMap<String,String>();
25 java0328.put("1", "张维");
26 java0328.put("2", "王荣臣");
27 //基地oracle
28 oracle.put("java0601", java0601);
29 oracle.put("java0328", java0328);
30 //keySet(oracle);
31 entry(oracle);
32 }
33 //第一种方式：keySet()
34 public static void keySet(HashMap<String, HashMap<String,String>> oracle){
35 //先获取所有班级String所对应的key
36 Set<String> classname=oracle.keySet();
37 for(String c:classname){
38 //根据班级名称，获取所有学生信息所在的map
39 HashMap<String,String> students=oracle.get(c);
40 //获取所有学生的序号
41 Set<String> numbers=students.keySet();
42 for(String num:numbers){
43 //根据每个同学的学号获取姓名
44 String stuname=students.get(num);
45 System.out.println(c+"...."+num+"..."+stuname);
46 }
47 }
48 }
49 //第二种方式，通过entrySet()
50 public static void entry(HashMap<String, HashMap<String,String>> oracle){
51 //获取第一个结婚证
52 Set<Map.Entry<String, HashMap<String,String>>> classname=oracle.entrySet();
53 //
54 for(Map.Entry<String, HashMap<String,String>> c:classname){
55 //获取班级名称
56 String cname=c.getKey();
57 //获取学生信息的map
58 HashMap<String,String> students=c.getValue();
59 //获取第二个结婚证集合
60 Set<Map.Entry<String, String>> stu=students.entrySet();
61 //遍历结婚证集合 得到每一个结婚证
62 for(Map.Entry<String, String> s:stu){
63 String num=s.getKey();
64 String name=s.getValue();
65 System.out.println(cname+"..."+num+"..."+name);
66
67 }
68
69 }
70 }
71 }
Entry键值对对象：
Entry是Map接口中提供的一个静态内部嵌套接口。
entrySet()方法：用于返回Map集合中所有的键值对(Entry)对象，以Set集合形式返回。
静态导入
Collections中的方法：
public static <T> void sort(List<T> list) 排序
public static void shuffle(List<?> list) 集合中的元素存储位置随机打乱
代码实现：
1 import static java.lang.System.out;
2 public class Demo01 {
3
4 public static void main(String[] args) {
5 System.out.println("aaa");
6 out.println("aaa");
7
8 }
9
10 }
可变参数：int...a
1 public class Demo02 {
2
3 public static void main(String[] args) {
4 //写方法：计算几个数的求和
5 add(4,5,6,7,8,9,23,44,55);
6 }
7 //可变参数int...a 相当于一个数组int[] a
8 //必须放在参数列表最后 一次只能传一个
9 public static void add(int b,int...a){
10 int sum=0;
11 for(int i:a){
12 sum+=i;
13 }
14 System.out.println(a.length);
15 System.out.println(sum);
16 }
17
18 }
sort、shuffle方法代码实现
1 public static void main(String[] args) {
2 // 给List集合打乱顺序
3 ArrayList<Integer> list=new ArrayList<Integer>();
4 list.add(123);
5 list.add(2);
6 list.add(33);
7 list.add(44);
8 list.add(56);
9 list.add(633);
10 list.add(72);
11 System.out.println(list);
12 //打乱
13 /* Collections.shuffle(list);
14 System.out.println(list);*/
15 //对集合进行排序
16 Collections.sort(list);
17 System.out.println(list);
18 }
19 }
斗地主案例：
1 import java.util.ArrayList;
2 import java.util.Collections;
3 import java.util.HashMap;
4
5
6 public class DouDiZhu {
7 private static ArrayList<Integer> bottom;
8
9 public static void main(String[] args) {
10 //1.定义扑克牌Map
11 HashMap<Integer,String> pooker=new HashMap<Integer,String>();
12 //2.定义装扑克牌编号的ArrayList
13 ArrayList<Integer> pookernumber=new ArrayList<Integer>();
14 //3.定义花色数组
15 String[] color={"♥","♣","♦","♠"};
16 //4.数字数组
17 String[] number={"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
18 //组合牌
19 int index=2;
20 for(String num:number){
21 for(String col:color){
22 pooker.put(index, col+num);
23 pookernumber.add(index);
24 index++;
25 }
26 }
27 //手动封装大小王
28 pooker.put(0, "大☻");
29 pookernumber.add(0);
30 pooker.put(1, "小☺");
31 pookernumber.add(1);
32 //洗牌
33 Collections.shuffle(pookernumber);
34 //发牌
35 ArrayList<Integer> player1=new ArrayList<Integer>();
36 ArrayList<Integer> player2=new ArrayList<Integer>();
37 ArrayList<Integer> player3=new ArrayList<Integer>();
38 ArrayList<Integer> bottom=new ArrayList<Integer>();
39
40 for(int i=0;i<pookernumber.size();i++){
41 if(i<3){
42 bottom.add(pookernumber.get(i));
43 }else if(i%3==0){
44 player1.add(pookernumber.get(i));
45 }else if(i%3==1){
46 player2.add(pookernumber.get(i));
47 }else if(i%3==2){
48 player3.add(pookernumber.get(i));
49 }
50 }
51 //对玩家及底牌进行排序
52 Collections.sort(player1);
53 Collections.sort(player2);
54 Collections.sort(player3);
55 Collections.sort(bottom);
56 //看牌
57 look("薛之谦",pooker,player1);
58 look("刘德华",pooker,player2);
59 look("王祖蓝",pooker,player3);
60 look("底牌",pooker,bottom);
61 }
62 public static void look(String name,HashMap<Integer,String> pooker,ArrayList<Integer> player){
63 System.out.print(name+":");
64 for(int num:player){
65 System.out.print(pooker.get(num)+" ");
66 }
67 System.out.println();
68 }
69 }