Javaコレクション：忘れられているもの

コードレビューの経験とStackOverflowへの回答から、Java Collections APIに関して私には明らかな点がたくさんありましたが、何らかの理由で他の開発者はそれらについて知らなかったか知らなかったが、それらを使用する自信はありませんでした。 この記事では、蓄積したすべてをヒープに収集します。

内容：

1. List.subList
2. PriorityQueue
3. EnumSetおよびEnumMap
4. Set.add（E）およびSet.remove（E）はブール値を返します
5. Map.put（K、V）、Map.remove（K）、List.set（idx、E）、List.remove（idx）は前のアイテムを返します
6. Map.keySet（）およびMap.values（）
7. Arrays.asListがキーになります
8. Collections.max
9. LinkedList、Stack、Vector、Hashtable

List.subList

彼らはすでにこれについて書いていますが、繰り返す価値はあります。 おそらく、Collections APIで最も過小評価されているメソッドです。 リストの一部を何らかの方法で処理する必要がある場合があります（たとえば、「分割統治」ファミリーのアルゴリズムで、またはタスクを並列化する場合）。 多くの場合、3つのパラメーター（List、fromおよびto）に関連付けられたメソッドまたはクラスが作成されます。

void processListPart(List<Item> list, int from, int to) { for(int idx = from; idx < to; idx++) { Item item = list.get(idx); ... } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

そのため、それを行う必要はありません。 アルゴリズムの実装は、リストの一部を処理することを気にするべきではありません。 書く：

 void processList(List<Item> list) { for(Item item : list) { ... } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

そして電話する

 processList(list.subList(from, to));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

1つのメソッドにすべてが含まれている場合でも、インデックスを使用するよりも拡張forループを使用する方が便利です。

 for(Item item : list.subList(from, to)) {...}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

さらに、subListは完全に機能するリストであり、書き込み時にも機能し、親リストに適切な変更を加えます。 リストの中央から多くのアイテムを削除する必要がありますか？ これ以上簡単なことはありません：

 list.subList(from, to).clear();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ArrayListのような一般的な実装では、これは非常に高速です。



リストが特定の要素で始まるかどうかを調べる必要がありますか？ そして、subListを手に入れます！

 List<String> prefix = Arrays.asList("a", "prefix", "values"); if(myList.size() >= prefix.size() && myList.subList(0, prefix.size()).equals(prefix)) {...}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

あるリストに、最初のリストを除く別のリストのすべての要素を追加する必要がありますか？ そしてここでsubListが助けになります：

 list1.addAll(list2.subList(1, list2.size()));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Arrays.asList(array).subList(from, to)



を記述できることを忘れないでください。したがって、上記は非プリミティブ配列にも適用されます。 それらを構造的に変更することはできませんが、配列の一部を読み取りリストを受け入れるメソッドに渡すのは簡単です。

PriorityQueue

subListが最も過小評価されているメソッドである場合、PriorityQueueは最も過小評価されているクラスです。 多くの場合、ソートされていない大きなリストの最小値を10個見つけるタスクに直面しています。 ほとんどの場合、リストはソートされてから、最初の10個の値が取得されます。 元のリストを変更できない場合は、並べ替えのためにコピーする必要があります。 ただし、優先度キューはこのタスクに簡単に対処できます。

 public static <T extends Comparable<T>> List<T> leastN(Collection<T> input, int n) { assert n > 0; PriorityQueue<T> pq = new PriorityQueue<>(Collections.reverseOrder()); for (T t : input) { if (pq.size() < n) { pq.add(t); } else if (pq.peek().compareTo(t) > 0) { pq.poll(); pq.add(t); } } List<T> list = new ArrayList<>(pq); Collections.sort(list); return list; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

そのようなコードは、データに応じて、ソートよりもはるかに高速に動作します。 たとえば、n = 10で、ランダムに入力された100万個の要素のリストの場合、優先度キューはほぼ100回ソート方法を追い越します。 この場合、追加のメモリにはO（n）が必要で、入力要素はストリーミングモードで処理できます（たとえば、入力ファイルから10個の最小の数字を選択します）。



一般に、人々はいくつかのデータ構造を研究し、どこでもそれらを使用する傾向があります。 怠けてはいけません、異なる構造に精通してください。

EnumSetおよびEnumMap

HashSetおよびHashMapで列挙値がキーとして使用されるコードはまだあります。 それは機能しますが、不当に無駄です。 既存の特別なクラスEnumSetとEnumMapは、生産性が大幅に向上しています。 したがって、enumの値が64個以下の場合、EnumSetはすべてをビットマスクのlong型の1つのフィールドに格納します。 EnumMapには、enumの要素と同じ長さの通常の配列にすべての値が含まれますが、キーはまったく格納されません。 enumの各値には序数（）シリアル番号があるため、enumキーから配列要素に簡単に切り替えることができます。 また、配列のサイズを変更する必要はありません。

Set.add（E）およびSet.remove（E）はブール値を返します

多くの場合、同様のコードが表示されます。

 if(!set.contains(item)) { set.add(item); // do something } else { // do something else }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Setに追加する操作は、追加が成功した場合（つまり、要素がなかった場合）にtrueを返し、そのような要素が既に存在する場合にfalseを返すことを忘れないでください。 次のように記述できるため、コードを複雑にし、ハッシュテーブルまたはバイナリツリーを介して要素をダブルパンチする必要はありません。

 if(set.add(item)) { // do something } else { // do something else }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

同様に削除します。 チェーンif(set.contains(item)) { set.remove(item); ... }



if(set.contains(item)) { set.remove(item); ... }



はif(set.remove(item)) { ... }



置き換えられif(set.remove(item)) { ... }



。

Map.put（K、V）、Map.remove（K）、List.set（idx、E）、List.remove（idx）は前のアイテムを返します

同じオペラから状況。 コレクション内のアイテムを変更または削除するメソッドは、以前の値を返すため、これを使用する必要があります。 たとえば、次のように書かないでください。

 Item item = myMap.get(key); myMap.put(key, newItem);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

単に書きますItem item = myMap.put(key, newItem);



。 Mapの2つのエントリをキーkey1、key2と交換したいですか？ 一時変数は必要ありません。

 myMap.put(key1, myMap.put(key2, myMap.get(key1)));
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Map.keySet（）およびMap.values（）

何らかの理由で、多くの人々は、 Map.keySet()



およびMap.values()



が元のMapのマッピングを返すことを忘れています。これにより、要素を削除できます（Mapが変更可能な場合）。 Mapに特定の値（および任意のキー）のレコードのみを残す必要がありますか？ お願い：

 myMap.values().retainAll(toRetain);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

removeIf



も動作し、Java-8ではremoveIf



もremoveIf



ます：

 //      Map<String, List<Employee>> perDepartment = employees.stream().collect(groupingBy(Employee::getDepartmentName, HashMap::new, toList())); //         10 perDepartment.values().removeIf(list -> list.size() < 10);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Arrays.asListがキーになります

値のタプルを使用してマップまたはセットを作成する必要が生じることがあります。 たとえば、 name, type, version



フィールドを持つItem PoJoオブジェクトがあります。 これらにはすでにequals



とhashCode



記述されており、 HashSet



に追加できますが、すべて問題ありません。 ただし、バージョンを無視して、 name



フィールドとtype



フィールドのみでコレクションから一意のオブジェクトを選択する必要があります。 既存のequals



とhashCode



はhashCode



できません。 このような状況では、多くの場合、 name



とtype



フィールドのみを持つ別のクラスを作成し、それをキーとして使用します。 ただし、1回限りの操作の場合は、 Arrays.asList()



を使用する方が簡単です。

 Map<List<Object>, Item> map = new HashMap<>(); for(Item item : items) { map.put(Arrays.asList(item.name, item.type), item); } Collection<Item> unique = map.values();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Arrays.asList()



は、必要な要素数のリストを作成します。それには、 equals



とhashCode



equals



適切に実装されているだけです。ボイラープレートは必要ありません。 したがって、任意の長さのキーを作成でき、null値とプリミティブは正しく処理されます（ボクシングのおかげです）。 キーの一部として配列が必要な場合にのみ機能しません。

Collections.min / max

何らかの基準で何かの最大要素または最小要素を見つける手動で記述されたコードを見つけることができる頻度は驚くべきことです。 そのような些細な作業はずっと前に解決されるべきだと思われます。 実際、それはすでに長い間解決されています。メソッドCollections.min



とCollections.max



ます。 コンパレーターを書くのはあまり便利ではありませんでしたが、Java-8ではすべてが簡単になりました。



たとえば、最大値に対応するマップのキーを見つける必要があります。 このように書く：

 maxKey = Collections.max(map.entrySet(), Map.Entry.comparingByValue()).getKey();
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Stream APIを使用することもできますが、 Collections.max()



多少高速です。 Java-8を使用できず、 Entry.comparingByValue()



などのコンパレーターが使用できない場合は、簡単に記述できます。

スタック、ベクトル、ハッシュテーブル、LinkedList

これらのクラスは使用しないでください。 それらの利点はありません。 Stackの代わりにArrayDeque、Vectorの代わりにArrayList、Hashtableの代わりにHashMapを使用します。 スレッドセーフが必要な場合、とにかく助けにはなりません。 おそらく、9つはまだ@Deprecatedとマークします（ JEP 277を参照）。



LinkedListは特別なケースです。 リンクされたリストによく似たものはなく、実際に役立つという伝説があるようです。 実際には、LinkedListがArrayListよりも優れている状況は、実際にはほとんどありません。 Java-8より前のバージョンでは、何らかの条件で、順番に並んでいないアイテムを頻繁に削除する場合に、LinkedListが便利な場合がありました。 Java-8では、これらの目的のためにList.removeIf



が登場しましたが、これはもちろんArrayListではより最適に実装されています（要素は1回しか移動しません）。 さまざまな場所で多くの挿入を行う必要がある場合（タスク自体はエキゾチックです）、既存のLinkedListに挿入するよりも新しいArrayListを作成する方が高速である可能性が高いです。 各要素はヒープ内の個別のオブジェクトであり、次の要素と前の要素へのリンクがあるため、LinkedListは数倍のメモリを消費することに注意してください。 LinkedListは、ケーススタディとしてのみ使用できます。



今日は以上です。 喜んでプログラム！