java - 转换 map 中的两个原始数组。并将结果映射转换为该数组

Question

我有两个数组。 int 和 string。如何将该数组转换为映射？

我的代码。首先，我已经将 int 转换为包装 Integer

   public static Integer[] toObject(int[] array) {
        Integer[] result = new Integer[array.length];
        for (int i = 0; i < array.length; i++) {
            result[i] = new Integer(array[i]);
        }
        return result;
    }

之后，我将两个数组转换成map

public static <T,V> HashMap<T, V> toHM(T[] array, V[] array2) {
        HashMap<T,V> h = new LinkedHashMap<>();

        for(int i= 0; i < array.length; i++){
            h.put(array[i], array2[i]);
        }
        return h;
    }

这是正确的吗？之后我需要转换为原始数组。如何做到这一点？

示例:

Map<Integer, String> map = new HashMap<Integer, String>();
Integer[] keys = new Integer[map.size()];
String[] values = new String[map.size()];
int index = 0;
for (Map.Entry<Integer, String> mapEntry : map.entrySet()) {
    keys[index] = mapEntry.getKey();
    values[index] = mapEntry.getValue();
    index++;
}

但我需要在方法中实现它。这个怎么做 ？这还不是全部。我需要以原始形式转换结果包装器数组。

也许，你告诉我，如何在你的方法中实现它？

• 首先:我需要在所有 map 方法(hashmap、treemap、linkedhashmap)中转换两个原始数组。
• 其次:我需要在我的两个原始数组中转换结果 hashmap。

Answer 1

如果我没猜错的话，您需要一个通用方法来接收一对基本类型数组并返回一个特定的映射，其键和值与数组的键和值匹配。

此外，您还需要另一个方法来接收映射并返回一对原始类型数组，其元素与映射的条目匹配。

如果这些假设是正确的，那么您可以尝试这样的操作来装箱您的原语:

public static Integer[] box(int[] primitives) {
    return IntStream.of(primitives).boxed().toArray(Integer[]::new);
}

public static Byte[] box(byte[] primitives) {
    return IntStream.range(0, primitives.length).mapToObj(
        i -> primitives[i]).toArray(Byte[]::new);
}

// short, char and boolean left as an exercise

public static Double[] box(double[] primitives) {
    return DoubleStream.of(primitives).boxed().toArray(Double[]::new);
}

public static Float[] box(float[] primitives) {
    return IntStream.range(0, primitives.length).mapToObj(
        i -> primitives[i]).toArray(Float[]::new);
}

public static Long[] box(long[] primitives) {
    return LongStream.of(primitives).boxed().toArray(Long[]::new);
}

然后，您可以实现一个通用的 toMap() 方法，如下所示:

public static <K, V, M extends Map<K, V>> M toMap(
    K[] keys, 
    V[] values, 
    Supplier<M> factory) {

    return IntStream.range(0, keys.length).boxed().collect(
        Collectors.toMap(i -> keys[i], i -> values[i], (a, b) -> a, factory));
}

这通过迭代 keys 和 values 数组将流收集到 map ，将每一对元素放在 factory< 提供的 map 上参数。这个factory实际上是一个Supplier，将用于创建具体的 map 实现，即HashMap、TreeMap、 LinkedHashMap等

请注意，如果 map 实现不保留插入顺序，您可能会松散元素顺序，例如 HashMap。

对于反向操作，您需要一个包含两个数组的辅助类:

public class Pair<A, B> {

    public Pair(A a, B b) {
        this.a = a;
        this.b = b;
    }

    public final A a;

    public final B b;
}

这是一个简单的一对支架。然后，您可以将给定的映射转换为一对数组，如下所示:

public static <K, V, M extends Map<K, V>> Pair<K[], V[]> toArrays(
    M map, 
    IntFunction<K[]> keysFactory,
    IntFunction<V[]> valuesFactory) {

    K[] keys = map.keySet().stream().toArray(keysFactory);
    V[] values = map.values().stream().toArray(valuesFactory);
    return new Pair<>(keys, values);
}

这通过在给定 map 的 keySet() 和 values() 上流式传输来创建 keys 和 values 数组> Collection ，分别。提供了扮演数组工厂角色的各个 IntFunction。这是为了使泛型机制按预期工作，否则您将无法将数组的元素泛型类型固定为映射的键和值的泛型类型。

在 Pair 类中，您不能保存原始数组，因为它是通用的，并且(到 2015 年 9 月)仍然不允许使用原始类型作为类型参数。

所以我们需要几个unbox方法:

public static int[] unbox(Integer[] wrappers) {
    return Arrays.stream(wrappers).mapToInt(Integer::intValue).toArray();
}

public static float[] unbox(Float[] wrappers) {
    float[] result = new float[wrappers.length];
    IntStream.range(0, wrappers.length).forEachOrdered(
        i -> result[i] = wrappers[i].floatValue());
    return result;
}

// Rest of unbox methods left as an exercise

最后，这是一个显示如何使用此代码的示例:

String[] keys = { "one", "two", "three" };
int[] intValues = { 1, 2, 3 };
float[] floatValues = { 1.1f, 2.2f, 3.3f };

Integer[] integers = box(intValues);
Map<String, Integer> map = toMap(keys, integers, HashMap::new);
System.out.println(map); // {one=1, three=3, two=2}

Float[] floats = box(floatValues);
Map<String, Float> map2 = toMap(keys, floats, LinkedHashMap::new);
System.out.println(map2); // {one=1.1, two=2.2, three=3.3}

Pair<String[], Integer[]> arrays = toArrays(map, String[]::new, Integer[]::new);
System.out.println(Arrays.toString(arrays.a)); // [one, three, two]
int[] unboxedInts = unbox(arrays.b);
System.out.println(Arrays.toString(unboxedInts)); // [1, 3, 2]

Pair<String[], Float[]> arrays2 = toArrays(map2, String[]::new, Float[]::new);
System.out.println(Arrays.toString(arrays2.a)); // [one, two, three]
float[] unboxedFloats = unbox(arrays2.b);
System.out.println(Arrays.toString(unboxedFloats)); // [1.1, 2.2, 3.3]

在 Java 中没有用于 float 、 boolean 值、短裤、字符和字节的流，因此您必须使用一些变通方法。

泛型语法不是很清楚，但它可以让您修复泛型类型，例如我对映射的键和值所做的。

最后一点:HashMap 不保留插入顺序，而 LinkedHashMap 保留。这解释了 map 和 map2 之间的输出差异。