1.map双列集合，每一个集合分为值和键两个部分组成，是一个键值对的关系-对应关系（映射关系）；map中的键是唯一且无序的
键：key;值：value；键值对：entrySet
2.常用方法
image.png
3.
image.png
4.collections是静态工具类
image.png
5.当集合里面装的是对象时，用collections.sort()排序
image.png
4.

可变参数

什么是方法签名？
* main(String[] args) - 方法签名
* 包含方法名和参数列表

  • 可变参数的优点：使参数列表更加灵活
  • 可变参数：参数的数量可变！

注意：

  • 1.数据类型…代表可变参数，即可以传入任意个该类型的数据
  • 2.可变参数不能放在前面，只能放在后面
  • 3.可变参数的方法与数组的方法不能重载，因为可变参数就是一个数组
  1. import java.util.ArrayList;
  2. import java.util.Collection;
  3. import java.util.Collections;
  5. /**
  6.  * 讲解方法的可变参数
  7.  *
  8.  */
  9. public class ArgsDemo {
  10.     public static void main(String[] args) {
  11.         //利用父类的接口创建对象
  12.         Collection<String> c = new ArrayList<>();
  14.         //添加数据 - 调用方法
  15.         Collections.addAll(c,"黄药师","段誉","虚竹");//jvm会自动将多个参数封装成一个数组
  16.         System.out.println(c);
  18.         System.out.println("--------------------------------");
  20.         //自定义一个方法 - 可以灵活的处理参数列表
  21.         int sum = add(10, 20, 50, 88);
  22.         System.out.println("sum="+sum);
  24.         System.out.println("--------------------------------");
  26.         int[] arr = {10,20,50,88};
  27.         int sum2 = add(arr);
  28.         System.out.println("sum2="+sum2);
  29.     }
  31.     //封装一个灵活参数的方法
  32.     public static int add(int...a){
  33.         //声明变量，记录所有数字的和
  34.         int sum = 0;
  35.         //变量数组 - 参数列表数组
  36.         for (int i = 0; i < a.length; i++) {
  37.             int j = a[i];
  38.             System.out.println("j="+j);
  39.             //没遇到一个数字就累加
  40.             sum += j;
  41.         }
  42.         return sum;
  43.     }
  45.     /**
  46.      * 可变参数其实就是一个数组
  47.      * 这里int[]其实就和int...是一样的，所以jvm判断为两个方法一样，并不是重载
  48.      * public static int add(int[] arr){
  49.      *     return 0;
  50.      * }
  51.      */
  54. }

数组与集合的相互转换

Arrays工具类

Arrays是一个工具类 - 专门服务于数组的 - 是一个静态类
toString()其实就是在Arrays中重写了Object中的方法
**

数组转成集合

Java数组的特点：
1.一旦声明不能修改长度
2.存放的元素只能是当前声明的数据类型

java集合的特点：
1.长度任意改变
2.存放的元素可以是任意类型 - 包装类

数组转成集合的方法：
public static * List asList(T…a):将数组转换成集合
*注意：数组转换成集合后，该集合就不支持添加或删除操作，否则会抛出异常

集合转成数组：

public T[] toArray(T[] a);__ public Object[] toArray(); - __集合转换为数组

  1. import java.util.ArrayList;
  2. import java.util.Arrays;
  4. /**
  5.  * 集合转换为数组：
  6.  *  public <T> T[] toArray(T[] a);
  7.  *  public Object[] toArray(); - 集合转换为数组
  8.  *
  9.  *
  10.  *  总结：
  11.  *  1.当数组转为集合的时候要注意：不能进行添加和删除的操作 - 遵循数组的结构规则
  12.  *  2.当集合转为数组的时候要注意：数据类型的强制转型或者泛型的使用
  13.  *  3.数组转为集合 - 从小到大
  14.  *    集合转为数组 - 从大到小
  15.  */
  16. public class ArrayListToArrayDemo {
  17.     public static void main(String[] args) {
  18.         //声明一个集合
  19.         ArrayList<Integer> list = new ArrayList<>();
  20.         list.add(10);
  21.         list.add(1);
  22.         list.add(5);
  23.         list.add(7);
  24.         list.add(3);
  26.         //调用方法 - 将集合转换为Object类型的数组
  27.         Object[] objArr = list.toArray();
  28.         System.out.println(Arrays.toString(objArr));
  29.         //向下转型
  30.         Integer i = (Integer) objArr[0];
  31.         System.out.println(i.intValue());
  33.         System.out.println("-------------------------");
  35.         //调用方法，将集合转换为带类型的数组
  36.         Integer[] intArr = new Integer[6];
  37.         Integer[] returnArr = list.toArray(intArr);
  39.         System.out.println(Arrays.toString(intArr));//[10, 1, 5, 7, 3, null]
  40.         System.out.println(Arrays.toString(returnArr));//[10, 1, 5, 7, 3, null]
  42.         /*如果给定的数组的长度不足以存放下集合中的元素，这个时候系统会再次自动创建
  43.         一个能够存放集合中元素的数组，原来声明好的数组就不用了*/
  44.         Integer[] intArr = new Integer[3];
  45.         Integer[] returnArr = list.toArray(intArr);
  46.         System.out.println(Arrays.toString(intArr));//[null，null，null]
  48.         //帶泛型的
  49.         Integer integer = returnArr[3];
  50.         System.out.println(integer.intValue());//7
  51.     }
  52. }

_

总结：

1.当数组转为集合的时候要注意：不能进行添加和删除的操作 - 遵循数组的结构规则 2.当集合转为数组的时候要注意：数据类型的强制转型或者泛型的使用 3.数组转为集合 - 从小到大 集合转为数组 - __从大到小

  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. import com.igeek_07.ArrayAsListDemo;
  8. /**  
  9. * 重构案例：   
  10. *    
  11. * ♣♦♠♥ 大☺小☺
  12. * 具体规则：
  13. *         使用54张牌打乱顺序
  14. *         三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
  15. * 
  16. * 逻辑分析:
  17. * 
  18. *     每张牌由花色数字两部分组成，我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。
  19. *     使用一个Map集合,<<将小的数字与小的牌对应起来>>,做成Map集合的键与值
  20. *     即:
  21. *         键:数字
  22. *         值:花色+数字的字符串(牌)
  23. * 
  24. * 准备牌：
  25. *     牌可以设计为一个ArrayList<Integer>,每个数字为一张牌。
  26. *     牌由Collections类的shuffle方法进行随机排序。
  27. * 发牌：
  28. *     将每个人以及底牌设计为ArrayList<Integer>,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。
  29. * 看牌：
  30. *     将所有集合排序Collections类的sort方法进行排序
  31. *     将每个集合的数字依次找到对应的纸牌字符串打印出来
  32. */
  33. public class CardDemo {
  34.     public static void main(String[] args) {
  35.         //确定牌和数字的对应关系
  36.         Map<Integer, String> map = new HashMap<>();
  38.         //花色集合
  39.         ArrayList<String> colors = new ArrayList<>();
  40.         colors.add("♣");
  41.         colors.add("♦");
  42.         colors.add("♠");
  43.         colors.add("♥");
  45.         //数字集合
  46.         ArrayList<String> numbers = new ArrayList<>();
  47.         for(int i=3; i<=10; i++){
  48.             numbers.add(i + "");
  49.         }
  50.         //添加其他的牌
  51.         Collections.addAll(numbers, "J","Q","K","A","2");
  53.         //设置对应关系
  54.         int cardNumber = 0;
  55.         //遍历数字集合，使用每一种颜色匹配每一个花色
  56.         for(String thisNumber : numbers){
  57.             //使用数字匹配花色
  58.             for(String thisColor : colors){
  59.                 String thisCard = thisColor + thisNumber;
  60.                 //放入map
  61.                 map.put(cardNumber, thisCard);
  62.                 //对应成功一个就累计
  63.                 cardNumber++;
  64.             }
  65.         }
  66.         //添加大小王
  67.         map.put(cardNumber++, "大☺");
  68.         map.put(cardNumber++, "小☺");
  69.         //测试
  70.         //System.out.println(map);
  72.         //准备牌
  73.         ArrayList<Integer> poker = new ArrayList<>();
  74.         for(int i=0;i<54;i++){
  75.             poker.add(i);
  76.         }
  77.         //System.out.println(poker);
  78.         //制造下标，目的是为了打乱顺序
  79.         Collections.shuffle(poker);
  81.         //发牌
  82.         ArrayList<Integer> player01 = new ArrayList<>();
  83.         ArrayList<Integer> player02 = new ArrayList<>();
  84.         ArrayList<Integer> player03 = new ArrayList<>();
  85.         ArrayList<Integer> dipai = new ArrayList<>();
  86.         for(int index=0;index<poker.size()-3;index++){
  87.             //通过索引，获取代表牌的数字
  88.             Integer integerCard = poker.get(index);
  89.             //对3取余
  90.             if(index%3==0){
  91.                 player01.add(integerCard);
  92.             }else if(index%3==1){
  93.                 player02.add(integerCard);
  94.             }else{
  95.                 player03.add(integerCard);
  96.             }
  97.         }
  98.         //最后的三张底牌
  99.         for(int index=poker.size()-3;index<poker.size();index++){
  100.             Integer integerCard= poker.get(index);
  101.             dipai.add(integerCard);
  102.         }
  104.         //看牌 - 排序
  105.         Collections.sort(player01);
  106.         Collections.sort(player02);
  107.         Collections.sort(player03);
  108.         Collections.sort(dipai);
  110.         //从小到大进行排序
  111.         for(int i=player01.size()-1; i>0; i--){
  112.             Integer integer = player01.get(i);
  113.             String realCard = map.get(integer);
  114.             System.out.print(realCard + " ");
  115.         }
  116.         //换行
  117.         System.out.println();
  119.         for(int i=player02.size()-1; i>0; i--){
  120.             Integer integer = player02.get(i);
  121.             String realCard = map.get(integer);
  122.             System.out.print(realCard + " ");
  123.         }
  124.         //换行
  125.         System.out.println();
  126.         for(int i=player03.size()-1; i>0; i--){
  127.             Integer integer = player03.get(i);
  128.             String realCard = map.get(integer);
  129.             System.out.print(realCard + " ");
  130.         }
  131.         //换行
  132.         System.out.println();
  134.         //增强for
  135.         for(Integer integer : dipai){
  136.             String realCard = map.get(integer);
  137.             System.out.print(realCard + " ");
  138.         }
  140.     }