1.双列集合Map

Map：双列集合，每一个集合分为键和值两个部分组成，是一个键值对的关系—对应关系（映射关系）

  • 实际使用中利用键找到对应的值。
  • 最常用的Map集合是HashMap，键是唯一且无序！
  • 键———key
  • 值———value
  • 键值对—key-value（entrySet）

  • 常用的方法：
  • put(key,value):添加元素—当key相同的时候，新值会覆盖旧值
  • value get(key):获取元素——key所对应的value
  • Set keySet()—返回的是所有键的集合
  • Collection values()—返回的是所有值的集合

  • 补充：Map是一个接口，是单独的一个接口，不属于Collection ```java package com.igeek_01;

/**

  • @author Lynn
  • @create 2020-12-09-9:27 */

import java.util.HashMap;

public class MapDemo { public static void main(String[] args) { //创建一个集合对象 //第一个String—key；第二个String—value HashMap map=new HashMap<>();

  1.     //向集合中添加元素
  2.     map.put("及时雨","宋江");
  3.     map.put("玉麒麟","卢俊义");
  4.     map.put("智多星","吴用");
  5.     map.put("智多星","高俅");
  7.     //打印map
  8.     System.out.println(map);//{玉麒麟=卢俊义, 智多星=高俅, 及时雨=宋江}
  10.     /*//获取元素--通过key获得value
  11.     String value=map.get("技能：");
  12.     System.out.println(value);
  14.     //没有key
  15.     String value1=map.get("剑法");
  16.     System.out.println(value1);//null--找不到key，就返回一个value--null*/
  17. }

}

  1. ```java
  2. package com.igeek_02;
  4. /**
  5.  * @author Lynn
  6.  * @create 2020-12-09-9:27
  7.  */
  9. import java.util.*;
  11. public class MapDemo {
  12.     public static void main(String[] args) {
  13.         //创建一个集合对象
  14.         //第一个String--key；第二个String--value
  15.         HashMap<String,String> map=new HashMap<>();
  17.         //向集合中添加元素
  18.         map.put("及时雨","宋江");
  19.         map.put("玉麒麟","卢俊义");
  20.         map.put("智多星","吴用");
  21.         map.put("智多星","高俅");
  23.         //返回所有的键的集合--无序且不可重复
  24.         Set<String> ketset=map.keySet();
  25.         System.out.println(ketset);//[玉麒麟, 智多星, 及时雨]
  27.         System.out.println("------------------------");
  29.         //返回所有的值得集合--在添加第二个智多星的时候把吴用覆盖了
  30.         Collection<String> values=map.values();
  31.         System.out.println(values);//[卢俊义, 高俅, 宋江]
  33.         //遍历操作--迭代器处理
  34.         //迭代所有的键的set，依次获取每一个键
  35.         Iterator<String> iterator= ketset.iterator();
  36.         //问取删
  37.         while (iterator.hasNext()){
  38.             String thisKey= iterator.next();
  39.             //通过键找到相应的值，使用map集合
  40.             String thisValue=map.get(thisKey);
  41.             System.out.println(thisKey+"<--->"+thisValue);
  42.         }
  44.     }
  45. }

Map遍历的方式1：

  1. //遍历操作--迭代器处理
  2.         //迭代所有的键的set，依次获取每一个键
  3.         Iterator<String> iterator= ketset.iterator();
  4.         //问取删
  5.         while (iterator.hasNext()){
  6.             String thisKey= iterator.next();
  7.             //通过键找到相应的值，使用map集合
  8.             String thisValue=map.get(thisKey);
  9.             System.out.println(thisKey+"<--->"+thisValue);

Map遍历的方式2：

Map遍历的方式2：—相对于第一种遍历方式的优点是可以一次性遍历键值对

  • Set> entrySet()—-方法用于返回集合中所有的键值对对象

  • Entry将键值对的对应关系封装成了一个对象，可以从一个Entry对象中获取每一个键值对的键和值

  • Map.Entry说明Entry是属于Map的一个内部接口

  • Entry中的方法：
  • K getKey()—获取键
  • V getValue()—获取值 ```java package com.igeek_03;

/**

  • @author Lynn
  • @create 2020-12-09-10:20 */

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

public class MapDemo2 { public static void main(String[] args) { //创建集合对象 HashMap map=new HashMap<>(); //添加元素 map.put(“黑旋风”,”李逵”); map.put(“金毛狮王”,”段景柱”); map.put(“母夜叉”,”孙二娘”);

  1.     //获取集合中的所有的键值对对象的set集合
  2.     Set<Map.Entry<String,String>> entrySet=map.entrySet();
  3.     System.out.println(entrySet);
  5.     System.out.println("----------------------");
  7.     //迭代集合，获取，每一个键值对的对象--增强for循环--底层还是一个迭代器
  8.     for (Map.Entry<String,String> thisEntry:entrySet){
  9.         //通过键值对对象获取键
  10.         String key=thisEntry.getKey();
  11.         //通过键值对获取值
  12.         String value=thisEntry.getValue();
  13.         System.out.println(key+":"+value);
  14.     }
  15. }

}

  1. <a name="MhnkH"></a>
  2. ### LinkedHashMap
  3. LinkedHashMap的作用和使用：
  5. - LinkedHashMap继承自HashMap并且实现了Map接口
  6. - 能够保证集合是有序且不重复的
  7. - 如果key重复，就遵循父类（HashMap）中的覆盖机制
  8. - <br />
  9. - LinkedHashMap作用：
  10. - 1.Linked链表结构可以保证元素有序
  11. - 2.Hash结构可以保证元素的唯一性
  12. - 3.**以上约束只仅仅对键有效**
  13. - <br />
  14. - 注意：底层的链式结构实现怎么存就怎么取--不用考虑，使用就行
  15. - 实际上LinkedHashMap的底层使用的是Node节点做的排序处理
  16. ```java
  17. package com.igeek_04;
  19. /**
  20.  * @author Lynn
  21.  * @create 2020-12-09-10:51
  22.  */
  24. import java.util.LinkedHashMap;
  25. import java.util.LinkedHashSet;
  26. import java.util.Set;
  28. public class LinkedHashMapDemo {
  29.     public static void main(String[] args) {
  30.         //创建一个对象
  31.         LinkedHashMap<String,String> map=new LinkedHashMap<>();
  32.         //向集合中添加元素
  33.         map.put("近平","丽媛");
  34.         map.put("干将","莫邪");
  35.         map.put("Lucy","Jack");
  36.         map.put("Lucy","Lily");
  37.         //打印
  38.         System.out.println(map);//{近平=丽媛, 干将=莫邪, Lucy=Lily}
  40.         //遍历集合
  41.         Set<String> keyset=map.keySet();
  42.         for (String thisKey:keyset){
  43.             //通过map的键找到值
  44.             String thisValue=map.get(thisKey);
  45.             System.out.println(thisKey+"<----->"+thisValue);
  46.         }
  48.     }
  49. }

2.Collections

Collections是一个工具类

  • 这个类是一个静态类，也就是意味着可以直接通过类名.方法来调用—不需要实例化
  • 这个类中的方法都是静态方法—基本上都是为集合中服务的
  • public static void shuffle(List<?> list):打乱元素的顺序—其实打乱的是集合中元素的下标

  • 有顺序：每一个元素都是按照添加元素的时候生成的下标进行排序
  • 排序后：不管是第几个放的元素，只要是到了集合中，就会按照一定的顺序重新排列

  • Collections.shuffle(list);—-打乱顺序

    Collections.sort(list2)———排序（默认正序）

    binarySearch(查找的集合，在集合中查找的内容)

    ```java package com.igeek_05;

/**

  • @author Lynn
  • @create 2020-12-09-11:11 */

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

/**

  • Collections是一个工具类
  • 这个类是一个静态类，也就是意味着可以直接通过类名.方法来调用—不需要实例化
  • 这个类中的方法都是静态方法—基本上都是为集合中服务的
  • public static void shuffle(List<?> list):打乱元素的顺序—其实打乱的是集合中元素的下标 *
  • 有顺序：每一个元素都是按照添加元素的时候生成的下标进行排序
  • 排序后：不管是第几个放的元素，只要是到了集合中，就会按照一定的顺序重新排列 *

  • 演示其他的方法： / public class CollectionsDemo { public static void main(String[] args) {

    1.  //创建有序的集合
    2.  List<Integer> list=new ArrayList<>();//向上造型
    3.  //添加数据
    4.  list.add(2);
    5.  list.add(7);
    6.  list.add(6);
    7.  list.add(9);
    8.  list.add(10);
    9.  list.add(1);
    11. /* //打乱前的顺序--按照存入的顺序
    12.  System.out.println(list);
    14.  //打乱后的顺序--每一次的顺序都不一样
    15.  Collections.shuffle(list);
    16.  System.out.println(list);*/
    18.  //排序--默认的是正序排列
    19.  Collections.sort(list);
    20.  System.out.println(list);//[1, 2, 6, 7, 9, 10]
    22.  System.out.println("----------------------------------------------");
    24.  List<String> list2=new ArrayList<>();
    25.  list2.add("a");
    26.  list2.add("d");
    27.  list2.add("b");
    28.  list2.add("c");
    29.  System.out.println(list2);//[a, d, b, c]
    31.  //排序--默认的是正序排列--ASCII表
    32.  Collections.sort(list2);
    33.  System.out.println(list2);//[a, b, c, d]
    35.  //还能处理对象
    36.  //实例化对象
    37.  Person p=new Person("Jack",18);
    38.  Person p2=new Person("Rose",18);
    39.  Person p3=new Person("Trump",18);
    41.  List<Person> list3=new ArrayList<>();
    42.  list3.add(p);
    43.  list3.add(p2);
    44.  list3.add(p3);
    45.  System.out.println(list3);
    47.  //排序
    48.  //Collections.sort(list3);
    49.  /**
    50.   * 当Person对象类型进行排序的时候会报错，因为定义这个数据类型的对象没有比较顺序，
    51.   * 不知道什么叫大和小，所以不能排序
    52.   * 没有比较规则
    53.   */

    } } java package com.igeek_05;

/**

  • @author Lynn
  • @create 2020-12-09-14:17 */

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

/**

  • 二分查找法：在一个集合中，如果找得到返回一个值，如果找不到就返回一个负数索引
  • 不管这个指定元素的下标是多少
  • 二分查找法必须要求集合中的元素排列好顺序 *

  • binarySearch(查找的集合，在集合中查找的内容) */ public class CollectionsDemo3 { public static void main(String[] args) {

    1.  //创建有序的集合
    2.  List<Integer> list=new ArrayList<>();//向上造型
    3.  //添加数据
    4.  list.add(2);
    5.  list.add(7);
    6.  list.add(6);
    7.  list.add(9);
    8.  list.add(10);
    9.  list.add(1);
    10.  System.out.println(list);//[2, 7, 6, 9, 10, 1]
    12.  //直接进行二分查找--没有排序
    13. /* int i = Collections.binarySearch(list, 7);
    14.  System.out.println(i);//-4*/
    16.  //先排序，在进行二分查找
    17.  Collections.sort(list);
    18.  System.out.println(list);
    20.  int i1 = Collections.binarySearch(list, 7);
    21.  System.out.println(i1);

    } } ```

    可变参数

    ```java package com.igeek_06;

/**

  • @author Lynn
  • @create 2020-12-09-14:28 */

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

/**

  • 讲解方法的可变参数
  • 好处是：是的参数列表更加的灵活
  • 通常用于处理不清楚用户到底传入多少个参数的情况—例如：计算器程序 *
  • 可变参数：参数的数量可变 *
  • 注意：
  • 1.数据类型…代表可变参数，即可以传入任意个该类型的数据
  • 2.可变参数不能放在前面，只能放在后面

  • 3.参数的方法与数组的方法不能重载，因为可变参数就是一个数组 */ public class ArgsDemo { public static void main(String[] args) {

    1.  //利用父类的接口创建对象
    2.  Collection<String> c=new ArrayList<>();
    4.  //添加数据--调用方法--一次添加多个数据
    5.  Collections.addAll(c,"黄药师","段誉","虚竹");//jvm会自动将多个参数封装成一个数组
    6.  System.out.println(c);
    8.  System.out.println("--------------------------------");
    10.  //自定义一个方法--可以灵活地处理参数列表
    11.  int sum = add(10, 20, 88, 50);
    12.  System.out.println(sum);
    14.  System.out.println("--------------------------------");
    16.  int[] arr={10,25,40,88};
    17.  sum=add(arr);//表示可变参数的列表--其实就是一个数组
    18.  System.out.println(sum);

    }

    //封装一个可变参数的方法 public static int add(int… a){

    1.  //声明一个变量用来记录所有数字的和
    2.  int sum=0;
    3.  //遍历参数列表的数组
    4.  for (int i = 0; i <a.length ; i++) {
    5.      int j=a[i];
    6.      System.out.println(j);
    7.      //每遇到一个数组就累加
    8.      sum+=j;
    9.  }
    10.  return sum;

    }

    /**

    • 可变参数其实就是一个数组

    • 这里int[]其实和int…是一样的，所以jvm判定为两个方法重名，并不是重载 / /public static int add(int[] a){ return 0; }*/

      /**

    • 什么是方法签名？
    • main(String[] args)—就是方法签名
    • 包含方法名和参数列表 */ } ```

      ArrayAsList—-数组转换为集合

      ```java package com.igeek_07;

/**

  • @author Lynn
  • @create 2020-12-09-15:16 */

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

/**

  • java数组的特点：
  • 1.一旦声明不能修改长度
  • 2.存放的元素只能是当前声明的数据类型 *
  • java集合的特点：
  • 1.长度可以任意改变
  • 2.存放的元素可以是任意类型—包装类 *
  • 数组转成集合的方法：
  • public static List asList(T… a)：将数组转换成集合 *
  • 注意：

  • 数组转换成集合以后，该集合就不支持添加或者是删除操作，否则会抛出异常 / public class ArrayAsListDemo { public static void main(String[] args) {

    1.  //直接将一个数组转换为集合
    2.  List<String> newList= Arrays.asList("Jack","Rose","Aobama");
    3.  System.out.println(newList);//[Jack, Rose, Aobama]
    5.  //当数组转换为集合之后，还是不能直接添加或者删除元素，因为数组的特点就是一旦声明长度不能改变
    6.  newList.add("黄飞鸿");
    7.  System.out.println(newList);//java.lang.UnsupportedOperationException

    } }

  1. <a name="ArrayListToArray"></a>
  2. ### ArrayListToArray---集合转换为数组
  3. ```java
  4. package com.igeek_07;
  6. /**
  7.  * @author Lynn
  8.  * @create 2020-12-09-15:30
  9.  */
  11. import java.util.ArrayList;
  12. import java.util.Arrays;
  14. /**
  15.  * 集合转换为数组：
  16.  * public <T> T[] toArray(T[] a);
  17.  * public Object[] toArray();--集合转换为数组
  18.  *
  19.  * 总结：
  20.  * 1.当数组转换为集合的时候要注意：不能进行添加和删除的操作--遵循数组的结构规则
  21.  * 2.当集合转换为数组的时候要注意：数据类型的强制转型或者泛型的使用
  22.  * 3.数组转为集合--理解从小到大
  23.  *   集合转为数组--理解从大到小
  24.  */
  25. public class ArrayListToArrayDemo {
  26.     public static void main(String[] args) {
  27.         //声明一个集合
  28.         ArrayList<Integer> list=new ArrayList<>();
  29.         list.add(1);
  30.         list.add(2);
  31.         list.add(9);
  32.         list.add(5);
  33.         list.add(6);
  34.         list.add(4);
  36.         //调用方法--将集合转换为Object类型的数组
  37.         Object[] obj= list.toArray();
  38. //        System.out.println(obj);//地址值
  39.         System.out.println(Arrays.toString(obj));//[1, 2, 9, 5, 6, 4]
  41.         //向下转型
  42.         Integer i=(Integer)obj[0];
  43.         System.out.println(i.intValue());//1
  45.         //调用方法，将集合转换为带类型的数组
  46.         Integer[] intArr=new Integer[4];
  47.         Integer[] returnArr=list.toArray(intArr);
  49.         //如果给定的数组的长度不足以存放下集合中的元素，这个时候系统会再次自动创建一个能够存放集合
  50.         //中元素的数组，原来声明好的数组就不再用了
  51.         System.out.println(Arrays.toString(intArr));//[1, 2, 9, 5, 6, 4]
  52.         System.out.println(Arrays.toString(returnArr));//[1, 2, 9, 5, 6, 4]
  54.         //带泛型的-当前这个类型就直接是集合中元素的类型了，不需要强转
  55.         Integer integer=returnArr[3];//下标是3
  56.         System.out.println(integer.intValue());//5
  57.     }
  58. }

斗地主洗牌案例

  1. package com.igeek_08;
  3. /**
  4.  * @author Lynn
  5.  * @create 2020-12-09-16:07
  6.  */
  8. import java.util.ArrayList;
  9. import java.util.Collections;
  10. import java.util.HashMap;
  11. import java.util.Map;
  13. /**
  14.  *
  15.  */
  16. public class CardDemo {
  17.     public static void main(String[] args) {
  18.         //确定牌和数字的对应关系
  19.         Map<Integer, String> map = new HashMap<>();
  21.         //花色集合
  22.         ArrayList<String> colors = new ArrayList<>();
  23.         colors.add("♣");
  24.         colors.add("♦");
  25.         colors.add("♠");
  26.         colors.add("♥");
  28.         //数字集合
  29.         ArrayList<String> numbers = new ArrayList<>();
  30.         for (int i = 2; i <= 10; i++) {
  31.             numbers.add(i + " ");
  32.         }
  33.         //添加其他
  34.         Collections.addAll(numbers, "J", "Q", "K", "A");
  36.         //设置对应关系
  37.         int cardNum = 0;
  38.         //遍历数字集合
  39.         for (String thisNum : numbers) {
  40.             //使用数字匹配花色
  41.             for (String thisColor : colors) {
  42.                 String thisCard = thisColor + thisNum;
  43.                 //放入Map集合
  44.                 map.put(cardNum, thisCard);
  45.                 //对应成功一个就累计
  46.                 cardNum++;
  47.             }
  48.         }
  49.         //添加大小王
  50.         map.put(cardNum++, "大王");
  51.         map.put(cardNum++, "小王");
  52.         //测试
  53. //        System.out.println(map);
  55.         //准备牌
  56.         ArrayList<Integer> poker = new ArrayList<>();
  57.         for (int i = 0; i < 54; i++) {
  58.             poker.add(i);
  59.         }
  60.         System.out.println(poker);
  61.         // 制造下标，目的是为了打乱顺序
  62. //        Collections.shuffle(poker);//打乱下标
  64.         //发牌
  65.         ArrayList<Integer> player1 = new ArrayList<>();
  66.         ArrayList<Integer> player2 = new ArrayList<>();
  67.         ArrayList<Integer> player3 = new ArrayList<>();
  68.         ArrayList<Integer> dipai = new ArrayList<>();
  70.         for (int index = 0; index < poker.size() - 3; index++) {
  71.             //通过索引获取代表牌的数字
  72.             Integer integerCard = poker.get(index);
  73.             //对3取余
  74.             if (index % 3 == 0) {
  75.                 player1.add(integerCard);
  76.             } else if (index % 3 == 1) {
  77.                 player2.add(integerCard);
  78.             } else {
  79.                 player3.add(integerCard);
  80.             }
  81.         }
  83.         System.out.println(player1);
  84.         System.out.println(player2);
  85.         System.out.println(player3);
  87.         //最后3张底牌
  88.         for (int i = poker.size() - 3; i < poker.size(); i++) {
  89.             Integer integerCard = poker.get(i);
  90.             dipai.add(integerCard);
  91.         }
  93.         //看牌--排序
  94.         /*Collections.sort(player1);
  95.         Collections.sort(player2);
  96.         Collections.sort(player3);
  97.         Collections.sort(dipai);*/
  99.         //从大到小进行排序
  100.         for (int i = player1.size() - 1; i >= 0; i--) {
  101.             Integer integer = player1.get(i);
  102.             String realCard = map.get(integer);
  103.             System.out.print(integer+" ");
  104.             System.out.print(realCard + " ");
  105.         }
  106.         System.out.println();
  107.         for (int i = player2.size() - 1; i >= 0; i--) {
  108.             Integer integer = player2.get(i);
  109.             String realCard = map.get(integer);
  110.             System.out.print(integer+" ");
  111.             System.out.print(realCard + " ");
  112.         }
  113.         System.out.println();
  115.         for (int i = player3.size() - 1; i >= 0; i--) {
  116.             Integer integer = player3.get(i);
  117.             String realCard = map.get(integer);
  118.             System.out.print(integer+" ");
  119.             System.out.print(realCard + " ");
  120.         }
  121.         System.out.println();
  122.         //增强for循环
  123.         for (Integer integer : dipai) {
  124.             String realCard = map.get(integer);
  125.             System.out.print(realCard + " ");
  126.         }
  127.     }
  128. }