java 循环问题

you_xueyang 2015-03-09 06:46:29
从画面得到数据:{15,M},{15,L},{15,XL},{16,黑色},{16,红色},{16,蓝色},{17,棉},{17,麻}
怎样才能变成这样的数据:M黑色棉,M黑色麻,M红色棉,M红色麻,M蓝色棉,M蓝色麻,L黑色棉……XL蓝色麻
...全文
256 8 打赏 收藏 转发到动态 举报
写回复
用AI写文章
8 条回复
切换为时间正序
请发表友善的回复…
发表回复
you_xueyang 2015-03-10
  • 打赏
  • 举报
回复
引用 1 楼 oh_Maxy 的回复:
没看错的话,这不是三层循环么?
在帮我看看呗
you_xueyang 2015-03-10
  • 打赏
  • 举报
回复
有可能是15,16,也有可能是15,16,17,18
you_xueyang 2015-03-10
  • 打赏
  • 举报
回复
补充一下,15,16,17不是固定的,所以不知道几层循环
you_xueyang 2015-03-10
  • 打赏
  • 举报
回复
引用 5 楼 oh_Maxy 的回复:

    public static void main(String[] args) {
        // {15,M},{15,L},{15,XL},{16,黑色},{16,红色},{16,蓝色},{17,棉},{17,麻}
        // 整合成如下数据应该不难,不赘述
        Map<Integer, List<String>> map = new HashMap<Integer, List<String>>();
        List<String> list15 = new ArrayList<String>();
        list15.add("M");
        list15.add("L");
        list15.add("XL");
        List<String> list16 = new ArrayList<String>();
        list16.add("黑色");
        list16.add("红色");
        list16.add("蓝色");
        List<String> list17 = new ArrayList<String>();
        list17.add("棉");
        list17.add("麻");
        map.put(15, list15);
        map.put(16, list16);
        map.put(17, list17);

        // 单独一个List记录map的有序的key值列表// 关键是有序
        List<Integer> keys = new ArrayList<Integer>();
        keys.add(15);
        keys.add(16);
        keys.add(17);

        // 递归调用
        combination(keys, map);
    }

    /**
     * keys已经排好序,map为需要显示的内容。初始的keys一定会在map中找到对应值,这里不做过多合法性校验
     */
    private static void combination(List<Integer> keys, Map<Integer, List<String>> map) {
        // 合法性校验
        if (null == keys || keys.isEmpty()) {
            return;
        }

        // 第一个为起始
        List<String> starts = map.get(keys.get(0));

        // 遍历并开始拼接显示内容
        for (String start : starts) {
            coreCombinate(start, keys.subList(1, keys.size()), map);
        }
    }

    /**
     * 核心递归的方法
     */
    private static void coreCombinate(String start, List<Integer> subList, Map<Integer, List<String>> map) {
        // 递归的收敛处
        if (null == subList || subList.isEmpty()) {
            // 如果需要返回,可以透传一个List<String>用来存储
            System.out.println(start);
            return;
        }

        // 第一个为起始
        List<String> starts = map.get(subList.get(0));

        // 遍历并开始拼接显示内容// 这里与上一层方法略有不同
        for (String startInner : starts) {
            String startNew = start + startInner;
            coreCombinate(startNew, subList.subList(1, subList.size()), map);
        }
    }
大神,我崇拜你!!!
you_xueyang 2015-03-10
  • 打赏
  • 举报
回复
引用 5 楼 oh_Maxy 的回复:

    public static void main(String[] args) {
        // {15,M},{15,L},{15,XL},{16,黑色},{16,红色},{16,蓝色},{17,棉},{17,麻}
        // 整合成如下数据应该不难,不赘述
        Map<Integer, List<String>> map = new HashMap<Integer, List<String>>();
        List<String> list15 = new ArrayList<String>();
        list15.add("M");
        list15.add("L");
        list15.add("XL");
        List<String> list16 = new ArrayList<String>();
        list16.add("黑色");
        list16.add("红色");
        list16.add("蓝色");
        List<String> list17 = new ArrayList<String>();
        list17.add("棉");
        list17.add("麻");
        map.put(15, list15);
        map.put(16, list16);
        map.put(17, list17);

        // 单独一个List记录map的有序的key值列表// 关键是有序
        List<Integer> keys = new ArrayList<Integer>();
        keys.add(15);
        keys.add(16);
        keys.add(17);

        // 递归调用
        combination(keys, map);
    }

    /**
     * keys已经排好序,map为需要显示的内容。初始的keys一定会在map中找到对应值,这里不做过多合法性校验
     */
    private static void combination(List<Integer> keys, Map<Integer, List<String>> map) {
        // 合法性校验
        if (null == keys || keys.isEmpty()) {
            return;
        }

        // 第一个为起始
        List<String> starts = map.get(keys.get(0));

        // 遍历并开始拼接显示内容
        for (String start : starts) {
            coreCombinate(start, keys.subList(1, keys.size()), map);
        }
    }

    /**
     * 核心递归的方法
     */
    private static void coreCombinate(String start, List<Integer> subList, Map<Integer, List<String>> map) {
        // 递归的收敛处
        if (null == subList || subList.isEmpty()) {
            // 如果需要返回,可以透传一个List<String>用来存储
            System.out.println(start);
            return;
        }

        // 第一个为起始
        List<String> starts = map.get(subList.get(0));

        // 遍历并开始拼接显示内容// 这里与上一层方法略有不同
        for (String startInner : starts) {
            String startNew = start + startInner;
            coreCombinate(startNew, subList.subList(1, subList.size()), map);
        }
    }
费心了,非常感谢,我研究一下,测试看看如何,因为已经整了很久了
oh_Maxy 2015-03-10
  • 打赏
  • 举报
回复

    public static void main(String[] args) {
        // {15,M},{15,L},{15,XL},{16,黑色},{16,红色},{16,蓝色},{17,棉},{17,麻}
        // 整合成如下数据应该不难,不赘述
        Map<Integer, List<String>> map = new HashMap<Integer, List<String>>();
        List<String> list15 = new ArrayList<String>();
        list15.add("M");
        list15.add("L");
        list15.add("XL");
        List<String> list16 = new ArrayList<String>();
        list16.add("黑色");
        list16.add("红色");
        list16.add("蓝色");
        List<String> list17 = new ArrayList<String>();
        list17.add("棉");
        list17.add("麻");
        map.put(15, list15);
        map.put(16, list16);
        map.put(17, list17);

        // 单独一个List记录map的有序的key值列表// 关键是有序
        List<Integer> keys = new ArrayList<Integer>();
        keys.add(15);
        keys.add(16);
        keys.add(17);

        // 递归调用
        combination(keys, map);
    }

    /**
     * keys已经排好序,map为需要显示的内容。初始的keys一定会在map中找到对应值,这里不做过多合法性校验
     */
    private static void combination(List<Integer> keys, Map<Integer, List<String>> map) {
        // 合法性校验
        if (null == keys || keys.isEmpty()) {
            return;
        }

        // 第一个为起始
        List<String> starts = map.get(keys.get(0));

        // 遍历并开始拼接显示内容
        for (String start : starts) {
            coreCombinate(start, keys.subList(1, keys.size()), map);
        }
    }

    /**
     * 核心递归的方法
     */
    private static void coreCombinate(String start, List<Integer> subList, Map<Integer, List<String>> map) {
        // 递归的收敛处
        if (null == subList || subList.isEmpty()) {
            // 如果需要返回,可以透传一个List<String>用来存储
            System.out.println(start);
            return;
        }

        // 第一个为起始
        List<String> starts = map.get(subList.get(0));

        // 遍历并开始拼接显示内容// 这里与上一层方法略有不同
        for (String startInner : starts) {
            String startNew = start + startInner;
            coreCombinate(startNew, subList.subList(1, subList.size()), map);
        }
    }
oh_Maxy 2015-03-09
  • 打赏
  • 举报
回复
没看错的话,这不是三层循环么?

67,512

社区成员

发帖
与我相关
我的任务
社区描述
J2EE只是Java企业应用。我们需要一个跨J2SE/WEB/EJB的微容器,保护我们的业务核心组件(中间件),以延续它的生命力,而不是依赖J2SE/J2EE版本。
社区管理员
  • Java EE
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧