如何编写将数组转换为Map的方法？如何实现将mass转换为Map的方法？

Hey there! Let's walk through practical implementations for these two conversion tasks. I'll cover Java (with both traditional loops and modern streams) and JavaScript examples, since those are common for this kind of work.

1. Array to Map Conversion #

Scenario 1: 2D Key-Value Array #

If your array is a 2D structure where each sub-array holds a key-value pair, here's a generic, safe implementation:

import java.util.HashMap;
import java.util.Map;

public class Converter {
    // Generic method to convert 2D array to Map
    public static <K, V> Map<K, V> arrayToMap(Object[][] keyValueArray) {
        Map<K, V> resultMap = new HashMap<>();
        
        // Guard clause for null/empty input
        if (keyValueArray == null || keyValueArray.length == 0) {
            return resultMap;
        }
        
        for (Object[] entry : keyValueArray) {
            // Skip invalid entries with fewer than 2 elements
            if (entry != null && entry.length >= 2) {
                K key = (K) entry[0];
                V value = (V) entry[1];
                resultMap.put(key, value);
            }
        }
        return resultMap;
    }
}

Scenario 2: Array of Custom Objects #

If your array contains custom objects, you can map specific fields to keys and values:

// Example custom class
class Product {
    private String sku;
    private double price;
    
    // Constructor & getters
    public Product(String sku, double price) {
        this.sku = sku;
        this.price = price;
    }
    public String getSku() { return sku; }
    public double getPrice() { return price; }
}

// Conversion method for Product array
public static Map<String, Double> productArrayToMap(Product[] products) {
    Map<String, Double> productMap = new HashMap<>();
    
    if (products == null) {
        return productMap;
    }
    
    for (Product product : products) {
        // Avoid NullPointerException from null elements
        if (product != null) {
            productMap.put(product.getSku(), product.getPrice());
        }
    }
    return productMap;
}

2. Mass (Batch Objects) to Map Conversion #

I'm assuming "mass" refers to a collection of objects (like a List in Java or an array in JavaScript). Here's a flexible way to handle this:

Java (Modern Stream Approach) #

Using streams makes this concise and reusable:

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public static <K, V, T> Map<K, V> massToMap(List<T> objectList, 
                                            java.util.function.Function<T, K> keyExtractor,
                                            java.util.function.Function<T, V> valueExtractor) {
    // Return empty immutable map for null input
    if (objectList == null) {
        return Map.of();
    }
    
    return objectList.stream()
            .filter(item -> item != null) // Skip null objects
            .collect(Collectors.toMap(
                    keyExtractor,
                    valueExtractor,
                    // Handle duplicate keys: keep existing value (customize as needed)
                    (existingValue, newValue) -> existingValue
            ));
}

Usage Example:

List<Product> productList = List.of(
    new Product("SKU001", 19.99),
    new Product("SKU002", 29.99)
);
Map<String, Double> productMap = massToMap(productList, Product::getSku, Product::getPrice);

JavaScript Implementation #

For JavaScript, we can create a similar flexible function:

// Convert array of objects (mass) to Map
function massToMap(objectArray, keyProp, valueProp) {
    const resultMap = new Map();
    if (!objectArray) return resultMap;
    
    objectArray.forEach(item => {
        if (item && item[keyProp] !== undefined) {
            resultMap.set(item[keyProp], item[valueProp]);
        }
    });
    return resultMap;
}

// Example usage
const products = [
    { sku: "SKU001", price: 19.99 },
    { sku: "SKU002", price: 29.99 }
];
const productMap = massToMap(products, 'sku', 'price');

内容的提问来源于stack exchange，提问作者Vitalii Smahlenko