相同元素分为一组的数组分组问题！

Question

大家好，我又要问一个很老套的数组分组问题。我想要做的是把 var a:int=10;
            var b:int=10;
            var c:int=10;
    var d:Number=10;
            var e:Number=10;
转化为：var a,b,c:int=10;
      var d,e:Number=10;因此，我使用 array= new ArrayList();
    array中的元素为，var a:int=10，var b:int=10，var c:int=10， var d:Number=10，var e:Number=10我现在想把ArrayList的元素进行分组，把冒号后面的字符相等的元素，分为一组，存入另一个ArrayList中，新的ArrayList含有2个元素：var a,b,c:int=10，var d,e:Number=10
谢谢！

Answer 1

好像是和规则有关。
想问一下，var a:int=10;是什么语法？

Answer 2

写出来了。我承认这个东西比我想象的要复杂。import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Arrays;/**
 * 合并定义语句
 */
public class MergeDefinition {    public static void main(String[] args) {
        String str = "var a:int=10;\n" +
                "var b:int=10;\n" +
                "var c:int=10;\n" +
                "var d:Number=10;\n" +
                "var e:Number=10;";/*
        // 你也可以试试这个
        String str = "var a:int=10;\n" +
                "var b:int=10;\n" +
                "var c:int=20;\n" +
                "var d:Number=10;\n" +
                "var e:Number=10;";
*/        // 拆分
        String[] definitions = str.split(";(\n)?");        // 创建解析器
        DefAnalyzer analyzer = new DefAnalyzer();        // 将拆分的语句丢入解析器
        for (String definition : definitions) {
            analyzer.addDefinition(definition);
        }        // 合并
        List<String> merged = analyzer.mergeDifinitions();        // 输出
        System.out.println("合并前：\n" + str + "\n");
        System.out.println("合并后：");
        for (String s : merged) {
            System.out.println(s);
        }
    }
}/**
 * 解析器
 */
class DefAnalyzer {    // 这里三个 String，第一个保存主要分组依据（数据类型），
    // 第二个保存次要分组依据（初始化的值），最里面的 String 保存变量名。
    // 一个数据类型可能对应多个值；一个值可能对应多个变量名。
    private HashMap<String, HashMap<String, List<String>>> definitions =
            new HashMap<String, HashMap<String, List<String>>>();    /**
     * 添加一个定义语句
     *
     * @param def_str 定义语句
     */
    public void addDefinition(String def_str) {
        def_str = StringUtil.cut(def_str, "var");        String var_name = StringUtil.before(def_str, ":");
        String var_type = StringUtil.between(def_str, ":", "=");
        String var_value = StringUtil.after(def_str, "=");        putDefinition(var_type, var_name, var_value);
    }    /**
     * 将定义放入 definitions
     *
     * @param type  变量类型
     * @param name  变量名
     * @param value 变量值
     */
    private void putDefinition(String type, String name, String value) {
        // 根据类型和值找到变量名列表，将变量名加入列表中。
        List<String> names = getNames(type, value);
        names.add(name);
    }    // 根据类型和值找到变量名列表
    private List<String> getNames(String type, String value) {
        HashMap<String, List<String>> definition = getDefinition(type);        List<String> names = definition.get(value);
        if (names == null) {
            names = new ArrayList<String>();
            definition.put(value, names);
        }
        return names;
    }    // 根据类型找到包含值的 Map
    private HashMap<String, List<String>> getDefinition(String type) {
        HashMap<String, List<String>> definition = definitions.get(type);
        if (definition == null) {
            definition = new HashMap<String, List<String>>();
            definitions.put(type, definition);
        }
        return definition;
    }    /**
     * 合并定义并输出合并后的语句
     *
     * @return 合并后的语句，每行为一个元素
     */
    public List<String> mergeDifinitions() {
        ArrayList<String> result = new ArrayList<String>();        for (String type : definitions.keySet()) {
            result.addAll(createDefinition(type, definitions.get(type)));
        }        return result;
    }    // 创建指定 type 的定义语句。该 type 有多少个值，就返回多少个语句。
    private List<String> createDefinition(String type, HashMap<String, List<String>> values) {
        ArrayList<String> result = new ArrayList<String>();
        for (String value : values.keySet()) {
            result.add(createMergedDefinition(type, value, values.get(value)));
        }
        return result;
    }    // 对于一个 type 和一个 value，生成一个合并的定义语句。
    private String createMergedDefinition(String type, String value, List<String> names) {
        String str = "var ";
        for (String name : names) {
            str += name + ",";
        }
        str = StringUtil.cutEnd(str, ",");
        str += ":" + type + " = " + value + ";";
        return str;
    }    // 简单的创建一个 List
    public <T> List<T> list(T... args) {
        return Arrays.asList(args);
    }
}/**
 * 字符串操作
 */
class StringUtil {
    static String cut(String str, String head) {
        return str.trim().substring(head.length()).trim();
    }    public static String before(String str, String token) {
        return str.substring(0, str.indexOf(token));
    }    public static String after(String str, String token) {
        return str.substring(str.indexOf(token) + token.length());
    }    public static String between(String str, String s_before, String s_after) {
        return before(after(str, s_before), s_after);
    }    public static String cutEnd(String str, String end) {
        return (str.endsWith(end) && str.length() > end.length()) ?
                str.substring(0, str.length() - end.length()) :
                str;
    }
}

Answer 3

关于 HashMap<String, HashMap<String, List<String>>> 这个结构需要解释一下：定义语句的格式都是类似于这样的：
   var i:int = 10;可以看出，每个定义语句分为三部分：变量名（var_name）、变量类型（var_type）和值（var_value）三部分。
像上面这句话，可以解析为：var_name="i", var_type="int", var_value="10"
后面就简单写为 name、type 和 value 三个变量了。并不是所有同类型的定义都可以合并成一句，只有类型和值都相同的，才能合并。所以 HashMap<String, HashMap<String, List<String>>> 中，第三个 String 表示变量名，
第二个 String 表示值。同一个值有多个变量名的话，可以考虑合并；但是如果类型不
同的话还要分开。所以第一个 String 表示类型，每个类型包含若干个值，每个值包含若干
个变量名，类型和值都相同的定义才能合并。