Java基础-集合的嵌套

　　　　　　　　　　　　　　　　　　　　　　Java基础-集合的嵌套

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

一.静态导入

　　静态导入是在JDK1.5后的新特性，可以减少开发的代码量，但是实际用处是很一般，静态导入的标准写法只有在导入包的时候才能使用。导入包的最末尾必须是一个静态成员。接下来我们可以看一下案例

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 package cn.org.yinzhengjie.note3;

 import static java.lang.System.out;
 import static java.util.Arrays.sort;

 public class StaticImportDemo {
     public static void main(String[] args) {
         //发现没有，打印的时候不用写System啦！
         out.println("yinzhengjie");
         int [] arr = {9,7,5,3,1};
         //发现没有，我没有写类名，直接写方法就可以啦！
         sort(arr);
         for (int i : arr) {
             System.out.println(i);
         }
     }
 }

 /*
 以上代码执行结果如下：
 yinzhengjie
 1
 3
 5
 7
 9
 */

二.方法的可变参数

　　JDK1.5后的新特性，方法的可变参数，前提是方法参数数据类型确定，参数的个数任意。案例如下：

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 package cn.org.yinzhengjie.note4;

 public class VarArgumentsDemo {
     public static void main(String[] args) {
         int sum = getsum(512,321,14,53,566,768,854,123,21,534,786);
         System.out.println(sum);
     }

     //定义方法求任何个整数和，由于传入的参数不固定，因此我们就将形式参数设置为可变参数。
     private static int getsum(int... args) {
         int sum = 0;
         for (int i : args) {
             sum += i;
         }
         return sum;
     }
 }

 /*
 以上代码执行结果如下：
 4552
 */

　　可变采参数的注意事项：

　　　　　　1>.一个方法中，可变参数只能有一个；

　　　　　　2>.可变参数必须写在参数列表的最后一个；

三.Collection工具类

1>.Collections.sort静态方法【对List结合进行升序排列】

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 package cn.org.yinzhengjie.note4;

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

 public class CollectionsDemo {
     public static void main(String[] args) {
         List<String> list = new ArrayList<>();
         list.add("Y");
         list.add("I");
         list.add("N");
         list.add("zheng");
         list.add("jie");
         System.out.println(list);
         //对List集合，继续升序排序。
         Collections.sort(list);
         System.out.println(list);

     }
 }

 /*
 以上代码执行结果如下：
 [Y, I, N, zheng, jie]
 [I, N, Y, jie, zheng]
 */

2>.Collections.binarySearch静态方法【对List集合进行二分搜索，方法参数，传递List集合，传递被查找的元素】

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 package cn.org.yinzhengjie.note4;

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

 public class CollectionsDemo {
     public static void main(String[] args) {
         List<Integer> list = new  ArrayList<>();
         list.add(1);
         list.add(3);
         list.add(5);
         list.add(7);
         list.add(9);
         list.add(11);
         //调用工具类静态方法binarySearch
         int index = Collections.binarySearch(list, 9);
         System.out.println(index);
         //若找不到索引的话，就返回插入点的相反数减去一的值，比如8应该是在7的后面，7后面的索引应该是4，相反数为-4，在相反数的基础上减去1，因此返回值应该是-5
         index = Collections.binarySearch(list, 8);
         System.out.println(index);
     }
 }

 /*
 以上代码执行结果如下：
 4
 -5
 */

3>.Collections.shuffle静态方法【对List集合中的元素，进行随机排序】

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 package cn.org.yinzhengjie.note4;

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

 public class CollectionsDemo {
     public static void main(String[] args) {
         List<Integer> list = new  ArrayList<>();
         list.add(1);
         list.add(3);
         list.add(5);
         list.add(7);
         list.add(9);
         list.add(11);
         System.out.println(list);

         Collections.shuffle(list);

         System.out.println(list);

     }
 }

 /*
 以上代码执行结果如下：
 [1, 3, 5, 7, 9, 11]
 [11, 5, 1, 3, 9, 7]
 */

4>.将不安全的集合改变成为安全的集合，常见的方法如下：

四.集合的嵌套

　　集合嵌套并不是一个新的指示单，仅仅是集合存储的对象还是集合，如Collection集合嵌套，Collection集合与Map集合互相嵌套，Map集合嵌套。

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 package cn.org.yinzhengjie.note4;

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

 public class MapMapDemo {
     public static void main(String[] args) {
         //定义安康的集合
         HashMap<String, String> ankang = new HashMap<>();
         //定义北京的集合
         HashMap<String, String> beijing = new HashMap<>();
         //定义存放地名的集合
         HashMap<String, HashMap<String,String>> CtiyScenicSpot =
                 new HashMap<String, HashMap<String,String>> ();
         //往安康这个集合存放数据
         ankang.put("岚皋县", "南宫山");
         ankang.put("平利县", "腊肉");
         ankang.put("紫阳县", "富硒茶");
         ankang.put("汉滨区", "长江大桥");
         //往北京这个集合存放数据
         beijing.put("大兴区", "野生动物园");
         beijing.put("朝阳区", "望京SOHO");
         beijing.put("海淀区", "中关村");

         //将安康和北京两个集合放入存放地名的集合中去
         CtiyScenicSpot.put("安康", ankang);
         CtiyScenicSpot.put("北京", beijing);
 //        keySet(CtiyScenicSpot);
         entrySet(CtiyScenicSpot);
     }

     //遍历方式一：通过keySet方式进行遍历
     public static void keySet(HashMap<String, HashMap<String,String>> CtiyScenicSpot) {
         //调用CtiyScenicSpot集合方法keySet将键存储到Set集合
         Set<String> cityNameset = CtiyScenicSpot.keySet();
         //迭代Set集合
         Iterator<String> cityName = cityNameset.iterator();
         while(cityName.hasNext()) {
             //获取CtiyScenicSpot集合的键
             String cityNameKey = cityName.next();
             //CtiyScenicSpot集合的方法get获取值，值是一个HashMap集合
             HashMap<String,String> cityMap = CtiyScenicSpot.get(cityNameKey);
             //调用cityMap集合方法keySet，键存储到Set集合
             Set<String> CountyAreaSet = cityMap.keySet();
             Iterator<String> CountyAreaIt = CountyAreaSet.iterator();
             while(CountyAreaIt.hasNext()) {
                 //CountyAreaIt.hasNext()获取出来的是cityMap的键，县和区
                 String CountyAreaKey = CountyAreaIt.next();
                 //调用cityMap集合中的get方法取值
                 String CharacteristicRepresentation = cityMap.get(CountyAreaKey);
                 System.out.println(cityNameKey+"--"+CountyAreaKey+"--"+CharacteristicRepresentation);
             }
         }
     }

     //遍历方式二：通过entrySet方式进行遍历
     public static void entrySet(HashMap<String, HashMap<String,String>> CtiyScenicSpot) {
         //调用CtiyScenicSpot集合entrySet方法，将CtiyScenicSpot集合的键值对关系对象，存储到Set集合
         Set<Entry<String, HashMap<String, String>>> cityNameset = CtiyScenicSpot.entrySet();
         //迭代器迭代Set集合
         Iterator<Entry<String, HashMap<String, String>>> cityNameIt = cityNameset.iterator();
         while(cityNameIt.hasNext()) {
             //cityNameIt.hasNext()方法，取出的是CtiyScenicSpot结合键值对关系对象
             Entry<String, HashMap<String, String>> cityNameEntry = cityNameIt.next();
             //cityNameEntry方法getkey，getValue
             String cityNamekey = cityNameEntry.getKey();
             //获取值，值是一个Map集合
             HashMap<String, String> classMap = cityNameEntry.getValue();
             //调用集合classMap方法entrySet，键值对关系对象存储Set集合
             Set<Entry<String, String>> CountyAreaSet = classMap.entrySet();
             //迭代CountyAreaSet集合
             Iterator<Entry<String, String>> CountyAreaIt = CountyAreaSet.iterator();
             while(CountyAreaIt.hasNext()) {
                 //CountyAreaIt.hasNext()获取出来的是cityMap的键，县和区
                 Entry<String, String> CountyAreaEntry = CountyAreaIt.next();
                 //调用CountyAreaEntry的getKey和getValue方法
                 String CountyAreaKey = CountyAreaEntry.getKey();
                 String CountyAreaValue = CountyAreaEntry.getValue();
                 System.out.println(cityNamekey+"--"+CountyAreaKey+"--"+CountyAreaValue);
             }

         }
     }
 }

 /*
 以上代码执行结果如下：
 安康--岚皋县--南宫山
 安康--平利县--腊肉
 安康--紫阳县--富硒茶
 安康--汉滨区--长江大桥
 北京--朝阳区--望京SOHO
 北京--大兴区--野生动物园
 北京--海淀区--中关村
 */

五.模拟斗地主洗牌发牌案例

1>.项目需求

　　按照斗地主的规则，完成洗牌发牌的动作，具体规则如下：

　　　　a>.组装54张扑克牌；

　　　　b>.将54张牌顺序打乱；

　　　　c>.三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌；

　　　　d>.查看三人各自手中的底牌（按照牌的大小顺序）；

　　注意：手中扑克牌从小到大的摆放顺序依次是：“大王，小王，2，A,K,Q,J,10,9,8,7,6,5,4,3”。

2>.案例需求分析

　　a>.准备牌：

　　　　完成纸牌和数字的映射关系：使用双列Map集合，完成一个数字与字符串纸牌的对应关系（相当于一个字典）。

　　b>.洗牌

　　　　通过数字完成洗牌和发牌。

　　c>.发牌

　　　　将每个人以及底牌设计为ArrayList<String>，将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌，存放过程中要求数字大小与斗地主规则的大小对应，将代表不同纸牌的数字分别分配给不同的玩家与底牌。

　　d>.看牌

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

3>.模拟斗地主代码实现

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:y1053419035@qq.com
 */

 package cn.org.yinzhengjie.note4;

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

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

         //1. 组合牌
         //创建Map集合,键是编号,值是牌
         HashMap<Integer,String> pooker = new HashMap<Integer, String>();
         //创建List集合,存储编号，该集合有序的特点可以存放相应的int类型。
         ArrayList<Integer> pookerNumber = new ArrayList<Integer>();
         //定义出13个点数的数组，注意顺序是从大到小
         String[] numbers = {"2","A","K","Q","J","10","9","8","7","6","5","4","3"};
         //定义4个花色数组，因为扑克牌就四个花色
         String[] colors = {"黑桃","红桃","梅花","方块"};
         //定义整数变量,作为键出现，其中0与1索引空出来用于存放大小王。
         int index = 2;
         //遍历数组,花色+点数的组合,存储到Map集合
         for(String number : numbers){
             for(String color : colors){
                 //将扑克牌的索引与对应的扑克牌进行绑定【注意，字符串需要做一个拼接操作】。
                 pooker.put(index, color+number);
                 //将编号加入集合中并要自加1.
                 pookerNumber.add(index++);
             }
         }
         //存储大王,和小王
         pooker.put(0, "大王");
         pookerNumber.add(0);
         pooker.put(1, "小王");
         pookerNumber.add(1);

         //2>洗牌功能
         //将牌的编号打乱
         Collections.shuffle(pookerNumber);

         //3>.发牌功能
         //将牌编号,发给玩家集合,底牌集合
         ArrayList<Integer> player1 = new ArrayList<Integer>();
         ArrayList<Integer> player2 = new ArrayList<Integer>();
         ArrayList<Integer> player3 = new ArrayList<Integer>();
         ArrayList<Integer> bottom = new ArrayList<Integer>();

         //发牌采用的是集合索引%3
         for(int i = 0 ; i < pookerNumber.size() ; i++){
             //先将底牌做好
             if(i < 3){
                 //存到底牌去
                 bottom.add( pookerNumber.get(i));
                //对索引%3判断
             }else if(i % 3 == 0){
                 //索引上的编号,发给玩家1
                 player1.add( pookerNumber.get(i) );
             }else if( i % 3 == 1){
                 //索引上的编号,发给玩家2
                 player2.add( pookerNumber.get(i) );
             }else if( i % 3 == 2){
                 //索引上的编号,发给玩家3
                 player3.add( pookerNumber.get(i) );
             }
         }

         //4>.对玩家手中的编号排序
         Collections.sort(player1);
         Collections.sort(player2);
         Collections.sort(player3);

         //5>.看牌,
         //将玩家手中的编号,到Map集合中查找,根据键找值.
         look("尹正杰",player1,pooker);
         look("刘亦菲",player2,pooker);
         look("邓紫棋",player3,pooker);
         look("底牌",bottom,pooker);
     }

     //定义看牌的方法
     public static void look(String name,ArrayList<Integer> player,HashMap<Integer,String> pooker){
         //遍历ArrayList集合,获取元素,作为键,到集合Map中找值
         System.out.print("[" + name + "]" + "\t:");
         for(Integer key : player){
             String value = pooker.get(key);
             System.out.print(value+" ");
         }
         System.out.println();
     }
 }

 /*
 以上代码执行结果如下：
 [尹正杰]    :大王 梅花2 红桃A 梅花A 方块A 梅花K 方块K 红桃J 方块J 方块9 红桃8 红桃7 梅花7 方块7 方块4 梅花3 方块3
 [刘亦菲]    :小王 黑桃2 红桃2 方块2 黑桃A 黑桃K 黑桃Q 梅花10 红桃9 方块8 黑桃5 红桃5 方块5 黑桃4 梅花4 黑桃3 红桃3
 [邓紫棋]    :红桃K 红桃Q 梅花Q 方块Q 黑桃J 梅花J 黑桃10 方块10 黑桃9 梅花9 黑桃8 梅花8 黑桃7 黑桃6 红桃6 方块6 梅花5
 [底牌]        :红桃10 红桃4 梅花6
 */

六.集合的总结

　　给大家推荐一款画图软件，百度脑图。它是一款很好使的画图工具，可以把我们学习的知识点进行归纳整理，下面我就抛砖引玉一下，给大家做个案例：