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 + "]" + "	:");
        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 
*/

六.集合的总结

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