java - 文字列配列をマップに変換する

Question

2つの文字列配列のキーと値があります

String[] keys = {a,b,c,d};

String[] values = {1,2,3,4};

それらを地図に変換する最速の方法は何ですか？私たちはそれらを繰り返すことができることを知っています。しかし、ユーティリティはありますか？

Answer 1

これより速い？

Map<String,String> map = new HashMap<>();

if(keys.length == values.length){
    for(int index = 0; index < keys.length; index++){
        map.put(keys[index], values[index]);
    }
}

Answer 2

私はあなたに2つの非常に単純な実装を目的としています。1つはJava8のストリームAPIを使用し、もう1つは使用しません。

Java <8 （ストリームAPIなし）

if(keys.length != values.length) { 
    throw new IllegalArgumentException("Keys and Values need to have the same length."); 
}
Map<String,String> map = new HashMap<>();
for (int i = 0; i < keys.length; i++) {
    map.put(keys[i], values[i]);
}

Java> 8 （ストリームAPIを使用）

if(keys.length != values.length) { 
    throw new IllegalArgumentException("Keys and Values need to have the same length."); 
}
Map<String,String> map = IntStream.range(0, keys.length).boxed()
    .collect(Collectors.toMap(i -> keys[i], i -> values[i]));

Answer 3

最初から一定時間のルックアップ

キーに関連付けられた値を一定時間で取得する（つまり、ほとんどの値を確認する必要がない）マップを探している場合は、配列を処理する必要があるため、これ以上高速化することはできません。

ただし、すでにそのように記述されているユーティリティを使用できます。com.google.common.collect.Maps.uniqueIndex

瞬時変換、線形時間ルックアップ

毎回配列でキーを検索するMapに問題がない場合は、Mapインターフェイスを実装する新しいクラスを定義することで、2つの配列を使用してMapを即座に作成できます。

class TwoArrayMap implements Map<String, String> {

   private final String[] keys;
   private final String[] values;
   // If you want to enable to add more key value pairs to your map, and
   // want to make the process faster, you could use ArrayLists instead of arrays

   public TwoArrayMap(String[] array1, String[] array2){
       if(array1 == null || array2 == null || array2.length < array1.length)
          throw new IllegalArgumentException();
       keys = array1;
       values = array2;
       // Alternatively, you could want to clone the arrays, to 
       // make sure they are not modified, using array1.clone(), etc
   }

   public String get(String key){

       for(int i=0; i<keys.length; i++)
             if(key == null && key == null || key != null && key.equals(k) )
                return values[i];
       return null;                     
   }

   public String put(String key, String Value) throws OperationNotSupportedException {
        throw new OperationNotSupportedException();
        // alternatively, you could resize the arrays and add a new key, or use an ArrayList
   }

}

Map<String, String> myMap = new TwoArrayMap(keys, values);

遅延変換、変換後の一定時間のルックアップ

別のアプローチは、それを「怠惰に」行うことです。つまり、上記のクラスを変更して、HashMapへの参照を内部的に保持し、要素を検索しているときにのみそれを埋めます。

class TwoArrayMap implements Map<String, String> {

   private final Map<String, String> hashmap;
   private int maxIndexAlreadyTransferred = -1;

   private final String[] keys;
   private final String[] values;

   public TwoArrayMap(String[] array1, String[] array2){
       if(array1 == null || array2 == null || array2.length < array1.length)
          throw new IllegalArgumentException();
       hashmap = new HashMap<>();
       keys = array1;
       values = array2;
       // Alternatively, you could want to clone the arrays, to 
       // make sure they are not modified, using array1.clone(), etc
   }

   public String get(String key){

       if(hashmap.containsKey(key))
            return hashmap.get(key);

       String k, value;
       while( maxIndexAlreadyTransferred + 1 < keys.length ){
             k = keys[ maxIndexAlreadyTransferred + 1 ];
             value = values[ maxIndexAlreadyTransferred +1 ];
             if(!hashmap.containsKey(k))
                 hashmap.put( k, value );
             maxIndexAlreadyTransferred++;
             if(key == null && k == null || key != null && key.equals(k) )
                return value;
       }
       return null;                     
   }

   public String put(String key, String Value) {
        hashmap.put(key, value);
   }

}

この解決策は次のことを意味します：

• 新しいオブジェクトの瞬時の作成
• すべてが転送されるまで、初めてクエリを実行する線形時間ルックアップ
• その後、ハッシュテーブルとして動作する一定時間のルックアップ

Answer 4

私見ですが、そのようなユーティリティが見つかる可能性はほとんどありません。

ただし、1つの可能性が非常に低い場合でも、パフォーマンスが向上する可能性があります。なぜなら、両方の配列のすべての要素を反復処理しないと、それを実行できないと思うからです。

私が提案できることの1つは、（配列に膨大な数の要素がある場合にのみ）マップをインスタンス化するときにマップの容量を指定して、エントリを入力する際のサイズ変更のオーバーヘッドを減らすことができるということです。

Map<String, String> map = new HashMap<String, String>(keys.length);
//put keys and values into map ...

Answer 5

2つの文字列配列をJavaでマップに変換します

import java.util.HashMap;
 public static void main(String[] args){
    String[] keys= {"a", "b", "c"};
    int[] vals= {1, 2, 3};
    HashMap<String, Integer> hash= new HashMap<String, Integer>();

    for(int i= 0; i < keys.length; i++){
      hash.put(keys[i], vals[i]);
    }
 }

さまざまなプログラミング言語でのその他のソリューションについては、このリンクを確認してください

Note：キーは一意である必要があります。