-4

例えば：

key1: 1,2,3,4
key2: 5,6

に変換されます

key1|key2
1|5
2|6
3
4

そして、これを繰り返し行うと、効率的ではない方法がたくさんあることを私は知っています。組み込みのメソッドや、それらを直接変換できるものがあるかどうか疑問に思っています。

HashMap<String, String> h1 = new HashMap<String, String>;
h1.put("key1", "1,2,3,4"); 
h1.put("key2", "5,6");

パイプ区切り形式で印刷する必要があります。

key1|key2
1|5
2|6
3
4
4

2 に答える 2

0

次のようなクラスを使用できます。

import java.util.*;

class LegacyGlueifier
{
    private LegacyGlueifier()
    {
    }

    public static String generateLegacyDataset(Map<String, String> data)
    {
        final ArrayList<ArrayList<String>> lists = new ArrayList<ArrayList<String>>();
        final int width = data.size();

        int i = 0;
        for (Map.Entry<String, String> entry : data.entrySet())
        {
            String[] values = entry.getValue().split(",");
            changeDims(lists, width, values.length + 1);

            for (int j = 0; j < values.length; ++j) setValue(lists, j + 1, i, values[j]);
            setValue(lists, 0, i, entry.getKey());
            ++i;
        }

        return stringify(lists);
    }

    private static void changeDims(ArrayList<ArrayList<String>> lists, int width, int newHeight)
    {
        while (lists.size() < newHeight) lists.add(arrayListOfSize(width));
    }

    private static ArrayList<String> arrayListOfSize(int w)
    {
        ArrayList<String> list = new ArrayList<String>(w);
        while (list.size() < w) list.add(null);
        return list;
    }

    private static void setValue(ArrayList<ArrayList<String>> lists, int row, int col, String val)
    {
        ArrayList<String> temp = lists.get(row);
        temp.set(col, val);
        // System.out.println("SET: " + row + " " + col + ": " + val);
    }

    private static String swapNullWithEmpty(String s)
    {
        if (s == null) return "";
        return s;
    }

    private static String stringify(ArrayList<ArrayList<String>> lists)
    {
        StringBuilder sb = new StringBuilder();
        for (ArrayList<String> sublist : lists)
        {
            if (sublist.size() != 0) sb.append(swapNullWithEmpty(sublist.get(0)));
            for (int i = 1; i < sublist.size(); ++i)
                sb.append("|").append(swapNullWithEmpty(sublist.get(i)));
            sb.append("\n");
        }

        return sb.toString();
    }
}

呼び出しはString dataset = LegacyGlueifier.generateLegacyDataset(myMap)

基本的なテストケースを実行して動作するかどうかを確認しましたが、使用する予定なので、さらに徹底的にテストします.

その時間計算量は、元のデータセットのコンマ区切りフィールドの総数に比例するものと、出力データセットのフィールドの総数に比例するもの (空白のフィールドを含む) の間のどこかです。

于 2012-11-06T15:34:05.320 に答える
0

これで変換が行われます。コードは長く複雑に見えますが、全体的な複雑さは依然として O(n) です。すべてのキーと値は、マップのサイズに関係なく一定回数触れられます。

public static void main(final String[] args) {
    Map<String, String> map = getMap();
    Map<String, String[]> map2 = new TreeMap<>();

    // (1) Read the map into an intermediate map and
    // get the number of rows needed
    int maxSize = 0;
    for (Map.Entry<String, String> entry : map.entrySet()) {
        String[] array = entry.getValue().split(",");
        maxSize = array.length > maxSize ? array.length : maxSize;
        map2.put(entry.getKey(), array);
    }

    // (2) prepare the table structure
    List<List<String>> table = new ArrayList<>();
    for (int i = 0; i < (maxSize + 1); i++) {
        table.add(new ArrayList<String>());
    }

    // (3) read the values into the table structure
    for (Map.Entry<String, String[]> entry : map2.entrySet()) {
        table.get(0).add(entry.getKey());
        for (int i = 0; i < maxSize; i++) {
            if (i < entry.getValue().length) {
                table.get(i + 1).add(entry.getValue()[i]);
            } else {
                table.get(i + 1).add("");
            }
        }
    }

    // (4) dump the table
    for (List<String> row : table) {
        StringBuilder rowBuilder = new StringBuilder();
        boolean isFirst = true;
        for (String value : row) {
            if (isFirst) {
                isFirst = false;
            } else {
                rowBuilder.append('|');
            }
            rowBuilder.append(value);
        }
        System.out.println(rowBuilder.toString());
    }

}

private static Map<String, String> getMap() {
    Map<String, String> map = new TreeMap<>();
    map.put("key1", "1,2,3,4");
    map.put("key2", "5,6");
    map.put("key3", "7,8,9");
    return map;
}

このサンプルの結果は次のとおりです。

key1|key2|key3
1|5|7
2|6|8
3||9
4||

（間違った推測に基づく最初の回答）

5 と 6 がキー1 と 2 の値であると仮定すると、これは適切な解決策です。

public static void dumpMap(Map<String, String> map) {
    for (Map.Entry<String, String> entry:map.entrySet()) {
        System.out.printf("%s|%s%n", entry.getKey(), nullSafe(entry.getValue()));
    }
}

private static String nullSafe(String value) {
    return value == null ? "" : value;
}

これは O(n) であり、出力するためにすべてのキーと値のペアに一度アクセスする必要があるため、これ以上効率的に行うことはできません。

(並列コンピューティングを使用できない限り;))

于 2012-11-06T14:29:47.680 に答える