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

Question

I have two arrays. int and string . How do I convert that arrays to map ?

My code. first of all, I have converted int to wrapper 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;
    }

After that, I have converted two arrays into 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;
    }

This is correct ? After that I need to convert in primitive arrays. how to do this ?

Example:

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

But I need to implement this in method. How to do this ? And that is not all. I need to convert result wrapper arrays in primitive.

May be, you tell me, how to implement it in your method ?

• First: I need to convert two primitive arrays in all map method (hashmap, treemap, linkedhashmap).
• Second: I need to convert result hashmap in my two primitive arrays.

Answer 1

if you know you're using int is easy. If you don't know which primitive class you are going to use the solution is more complicated, but not much more

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

If I'm guessing correctly, you want a generic method that receives a pair of arrays of primitive types and returns a specific map, with its keys and values matching those of the arrays.

Also, you want another method that receives a map and returns a pair of arrays of primitive types, with its elements matching the map's entries.

If these assumptions are correct, then you could try something like this to box your primitives:

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

Then, you could implement a generic toMap() method as follows:

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

This collects a stream to a map by iterating on the keys and values arrays, putting each respective pair of elements on the map provided by the factory argument. This factory is actually a Supplier that will be used to create a concrete map implementation, ie HashMap , TreeMap , LinkedHashMap , etc.

Note that you might loose elements order if the map implementation does not preserve insertion order, such as it happens with HashMap .

For the reverse operation, you'd need a helper class that would hold two arrays:

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

This is a simple pair holder. Then, you could transform a given map to a pair of arrays as follows:

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

This creates the keys and values arrays by streaming on the given map's keySet() and values() collection, respectively. Respective IntFunction s playing the role of factories for the arrays are provided. This is to make generics mechanics work as expected, otherwise you wouldn't be able to fix arrays' elements generic types to map's keys and values' generic types.

Within the Pair class, you cannot hold primitive arrays, since it is generic, and (by Sept 2015) it is still not allowed to use primitive types as type parameters.

So we need several unbox methods:

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

Finally, here's an example that shows how this code could be used:

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]

There are no streams for floats, booleans, shorts, chars neither bytes in Java, so you have to use a couple of workarounds.

Generics syntax is not very clear, but it lets you fix generic types, such as I did with keys and values of a map.

A final note: HashMap doesn't preserve insertion order, while LinkedHashMap does. This explains the difference in the output between map and map2 .