转换 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

如果您知道自己在使用 int 就很容易了。如果您不知道要使用哪个原语class，解决方案会更复杂，但不会更多

public static void thereAndBack(int[] keys, String[] values) {
    // to map
    Map<Integer, String> map = new HashMap<>();
    for (int i = 0; i < keys.length; i++) {
        // int autobox to Integer
        map.put(keys[i], values[i]);
    }

    // to array
    int[] keys2 = new int[map.size()];
    String[] values2 = new String[map.size()];
    int i = 0;
    for (Entry<Integer, String> entry : map.entrySet()) {
        // Integer autobox to int
        keys2[i] = entry.getKey();
        values2[i] = entry.getValue();
        i++;
    }
}

Answer 2

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

此外，您还需要另一种方法来接收映射和 returns 一对基本类型数组，其元素与映射的条目匹配。

如果这些假设是正确的，那么你可以尝试这样的事情来 box 你的原语：

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 数组将流收集到地图，将每个相应的元素对放在 factory 参数提供的地图上。这个factory实际上是一个Supplier，将用于创建具体的地图实现，即HashMap、TreeMap、LinkedHashMap等

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

对于反向操作，您需要一个可以容纳两个数组的助手 class：

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);
}

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

在 Pair class 中，您不能保存原始数组，因为它是通用的，并且（到 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 中没有用于浮点数、布尔值、短裤、字符和字节的流，因此您必须使用一些变通方法。

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

最后一点：HashMap 不保留插入顺序，而 LinkedHashMap 保留。这解释了 map 和 map2.

之间的输出差异

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

Convert two primitive arrays in map. and convert result map to that arrays

java

arrays

dictionary

converter

wrapper