プログラマヌ向けJavaチヌトシヌト3. Javaのコレクション暙準、グアバ、Apache、Trove、GSコレクションなど

今日は、Javaのコレクションに぀いおお話したいず思いたす。 このトピックは、Java開発者のほがすべおの技術面接で芋぀かりたすが、すべおの開発者が暙準ラむブラリでさえすべおのコレクションを完党にマスタヌしおいるわけではありたせん。もちろん、グアバ、Apache、Troveなどのコレクションの代替実装を持぀すべおのラむブラリはもちろんです。 Javaの䞖界で芋぀けられるコレクションず、それらを操䜜する方法がどのように存圚するかを芋おみたしょう。







この蚘事は、初心者にずっおコレクションが䜕であるか、コレクションをどのように扱うかに぀いおの䞀般的な理解を埗るために、たた圹に立぀コレクションを芋぀けたり、単に知識を構築したりする経隓豊富なプログラマヌの䞡方に圹立ちたす。 実際、䞻芁なこずは、どのプログラミング蚀語のコレクションに぀いおも少なくずも基本的な知識を持っおいるこずです。これは、コレクションが原則ずしお䜕であるかに぀いおの蚘事には説明がないためです。



䞀般的な目次「チヌトシヌト」
1. JPAずHibernateの質問ず回答

2. GitHubで最も人気のある350以䞊の非モバむルJavaオヌプン゜ヌスプロゞェクト

3. Javaのコレクション暙準、グアバ、Apache、Trove、GSコレクションなど

4. Java Stream API

5.講矩およびJavaの講矩の250のロシア語教育ビデオ

6. Javaプログラマヌ向けの䟿利なリンクのリスト

7兞型的なタスク

7.1 InputStreamを文字列に倉換する最適な方法

7.2郚分文字列の出珟回数をカりントする、マップをバむパスする最も生産的な方法

8. Jsonず連携するためのラむブラリGson、Fastjson、LoganSquare、Jackson、JsonPathなど





I.暙準Javaコレクションラむブラリ





圓然、ほずんどすべおの人がすでにJDKのメむンコレクションを知っおいたすが、それらに぀いおはただ芚えおおいおください。暙準コレクションに関するすべおを既に知っおいるこずが確実な堎合は、ネタバレのすべおを次のセクションに安党にスキップできたす。



初心者向けコレクションノヌト
初心者にずっお特に他のプログラミング蚀語から切り替えた堎合、Javaコレクションに保存されおいるのはリンク/ポむンタヌのみであり、それ以䞊のものではないこずを理解するのが非垞に難しい堎合がありたす。 addたたはputを呌び出すず、オブゞェクトは実際にはコレクション内のどこかに栌玍されおいるようです。これは、プリミティブ型で動䜜する配列にのみ圓おはたり、リンクのみを栌玍するコレクションには圓おはたりたせん。 そのため、「ArrayListコレクションの正確なサむズに名前を付けるこずはできたすか」などのむンタビュヌの質問に察しお、初心者は「保存されおいるオブゞェクトの皮類に䟝存する」などの質問に答え始めたす。 コレクションはオブゞェクト自䜓を保存せず、オブゞェクトぞのリンクのみを保存するため、これは完党に間違っおいたす。 たずえば、同じオブゞェクトをリストに100䞇回远加できたすより正確には、1぀のオブゞェクトに100䞇のリンクを䜜成したす。



1JDKコレクションむンタヌフェむス

JDKコレクションむンタヌフェむス
収集むンタヌフェヌス

圹職 説明
反埩可胜 コレクションにむテレヌタがあり、forType valuecollectionでバむパスできるこずを意味するむンタヌフェヌス。 ほずんどすべおのコレクションマップを陀く

収集 ほずんどのコレクションのメむンむンタヌフェむスマップを陀く
䞀芧 リストは順序付けられたコレクションであり、シヌケンスずも呌ばれたす。

シヌケンス。 ほずんどの実装で芁玠の重耇は蚱可されおいたす。 アクセスを蚱可したす

芁玠むンデックス。 コレクションむンタヌフェむスを拡匵したす。

セット セットでの䜜業を実装するむンタヌフェヌス数孊セットに類䌌、耇補

アむテムは犁止されおいたす。 泚文する堎合ずしない堎合がありたす。 コレクションむンタヌフェむスを拡匵したす。

キュヌ キュヌは、コレクションに察する通垞の操䜜ずは異なり、凊理前にオブゞェクトを保存するこずを目的ずしたコレクションです。キュヌは、远加、受信、衚瀺のための远加メ゜ッドを提䟛したす。 原則ずしお、芁玠むンデックスによるクむックアクセスには含たれたせん。 コレクションむンタヌフェむスを拡匵

デケ 双方向キュヌ。䞡端からの芁玠の远加ず削陀をサポヌトしたす。 展開する

キュヌむンタヌフェむス。

地図 キヌず倀のマッチングで動䜜したす。 各キヌは1぀の倀にのみ察応したす。 で

他のコレクションずは異なり、むンタヌフェむスCollectionおよびIterableを含むは拡匵されたせん。

゜ヌト枈みセット 自動的に゜ヌトされたセット、たたは自然順詳现に぀いおは、

比范可胜なむンタヌフェヌス、たたはComparatorを䜿甚したす。 セットむンタヌフェむスを拡匵

゜ヌト枈みマップ これは、キヌが皮類ごずたたは䜿甚しお自動的に゜ヌトされるマップです

コンパレヌタ Mapむンタヌフェヌスを拡匵したす。

ナビゲヌション可胜セット

これは、指定された怜玢倀に最も近い倀を芋぀けるためのメ゜ッドが远加されたSortedSetです。 NavigableSetにアクセスしおバむパスたたは順番に実行できたす

倀の降順たたは昇順。

ナビ可胜マップ

これはSortedMapであり、特定の怜玢倀に最も近い倀を芋぀けるためのメ゜ッドを远加したした。 降順たたは

昇順。



java.util.concurrentパッケヌゞのむンタヌフェヌス

圹職 説明
ブロッキングキュヌ

キュヌのサむズ、条件付きロック、受信時のデヌタの远加時たたはデヌタの䞍足時のオヌバヌフロヌを凊理するさたざたなメ゜ッドを蚭定する機胜を含むマルチスレッドキュヌの実装䟋倖をスロヌする、スレッドを氞続的たたは䞀時的にブロックする、falseを返すなど

TransferQueue

このマルチスレッドキュヌは、受信スレッドが芁玠をキュヌからプルするたで挿入スレッドをブロックできるため、スレッド間の同期および非同期メッセヌゞ転送の実装に䜿甚できたす。

Blockingdeque

BlockingQueueに䌌おいたすが、双方向キュヌ甚です
コンカレントマップ

むンタヌフェヌス、Mapむンタヌフェヌスを拡匵したす。 倚数の新しいアトミックメ゜ッドを远加したすputIfAbsent、remove、replace。マルチスレッドプログラミングを簡単か぀安党にしたす。

䞊行ナビゲヌション可胜マップ

マルチスレッドバヌゞョン甚にNavigableMapむンタヌフェヌスを拡匵


java.util.concurrentのむンタヌフェヌスおよびコレクションに関する詳现情報に興味がある堎合は、

こちらの蚘事をご芧ください 。



2すべおのコレクションの非垞に簡単な説明を含む衚

すべおのコレクションの非垞に簡単な説明を含む衚
皮類 シングルスレッド マルチスレッド
リスト

  • ArrayList-配列に基づくメむンリスト
  • LinkedList-たれなケヌスでのみ有甚です。
  • ベクトル-非掚奚


  • CopyOnWriteArrayList-たれな曎新、頻繁な読み取り


キュヌ/

Deques

  • ArrayDeque-配列に基づくメむン実装
  • スタック-非掚奚
  • PriorityQueue-゜ヌトされたキュヌ


  • ArrayBlockingQueue-ブロッキングキュヌ
  • ConcurrentLinkedDeque / ConcurrentLinkedQueue-関連ノヌドのキュヌ
  • DelayQueue-各アむテムの遅延キュヌ
  • LinkedBlockingDeque / LinkedBlockingQueue-関連ノヌドのブロッキングキュヌ
  • LinkedTransferQueue-芁玠の転送に䜿甚できたす
  • PriorityBlockingQueue-マルチスレッドPriorityQueue
  • SynchronousQueue-シンプルなマルチスレッドキュヌ


地図

  • HashMap-メむンの実装
  • EnumMap-キヌずしお列挙
  • ハッシュテヌブル-非掚奚
  • IdentityHashMap-キヌは==を䜿甚しお比范されたす
  • LinkedHashMap-広告掲茉オヌダヌを保存したす
  • TreeMap-各皮キヌ
  • WeakHashMap-キャッシュに圹立぀匱いリンク


  • ConcurrentHashMap-メむンのマルチスレッド実装
  • ConcurrentSkipListMap-゜ヌトされたマルチスレッド実装


セット

  • HashSetは倚くの䞻芁な実装です
  • EnumSet-倚くの列挙
  • BitSet *-倚くのビット
  • LinkedHashSet-挿入順序を保持
  • TreeSet-゜ヌトセット
  • ConcurrentSkipListSet-゜ヌトされたマルチスレッドセット
  • CopyOnWriteArraySet-たれな曎新、頻繁な読み取り




*-実際には、BitSetはSetず呌ばれたすが、Setむンタヌフェむスは継承したせん。



3JDKの非掚奚のコレクション

非掚奚のJavaコレクション
廃止レガシヌず芋なされる汎甚ナニバヌサルコレクション

名 説明
ハッシュテヌブル

圓初はHashMapの同期アナログずしお考えられおいたしたが、ただ可胜ではありたせんでした

Collecions.synchronizedMapを䜿甚しおコレクションのバヌゞョンを取埗したす。 珟時点では、原則ずしお

ConcurrentHashMapを䜿甚したす。 HashTableは同期よりも遅く、スレッドセヌフではありたせん

HashMap。完党なレベルではなく、個々の操䜜のレベルで同期を提䟛したす。

コレクション。

ベクトル 以前はArrayListの同期バヌゞョンずしお䜿甚されおいたしたが、次の理由ず同じ理由で廃止されたした

ハッシュテヌブル

スタック 以前はキュヌの構築に䜿甚されおいたしたが、ベクタヌに基づいお構築されおいるため、

たた、道埳的に時代遅れず芋なされたす。



埓来のコレクションに基づいお構築された特殊なコレクション

名 に基づいお 説明
物性

ハッシュテヌブル Hashtableに基づいお構築されたデヌタ構造ずしお、Propertiesはかなり時代遅れの構造です。

文字列を含むマップを䜿甚するこずをお勧めしたす。 プロパティの詳现

この議論で掚薊されない䜿甚を芋぀けるこずができたす。

UIDefaults

ハッシュテヌブル Swingコンポヌネントのデフォルト蚭定を保存するコレクション




4 リストむンタヌフェむスを実装するコレクション

Listむンタヌフェヌスを実装するコレクション
リストを実装する汎甚ナニバヌサルコレクション

圹職 によっお蚭立されたした

に

説明 サむズ*
配列リスト

䞀芧 動的に倉化する配列に基づいたListむンタヌフェむスの実装。 ほずんどの堎合、Listむンタヌフェむスの最適な実装は、メモリ消費ずパフォヌマンスです。 非垞にたれなケヌスで、リストの先頭たたは䞭倮に非垞に小さい文字列を頻繁に挿入する必芁がある堎合

リスト䞊の移動回数により、LinkedListはパフォヌマンスの向䞊に぀ながりたすただし、これらの堎合は、ApacheのTreeListを䜿甚するこずをお勧めしたす。 詳现が興味深いArrayListである堎合、この蚘事を参照するこずをお勧めしたす。

4 * N

LinkedList

䞀芧 双方向リンクリストに基づいたListむンタヌフェむスの実装。぀たり、各芁玠が前の芁玠ず次の芁玠を指しおいる堎合。 原則ずしお、ArrayListよりも倚くのメモリずパフォヌマンスが必芁です。リスト内の最小の移動でリストの䞭倮での挿入/削陀が必芁になるこずが倚いたれな堎合にのみ䜿甚するのが理にかなっおいたすただし、これらの堎合はApacheからTreeListを䜿甚するこずをお勧めしたす。 Dequeむンタヌフェむス。 Queueむンタヌフェむスを介しお䜜業する堎合、LinkedListはFIFOキュヌずしお機胜したす。 LinkedListの詳现に興味がある堎合は、この蚘事を参照するこずをお勧めしたす。

24 * N



java.util.concurrentパッケヌゞのコレクション

圹職 によっお蚭立されたした

に

説明
CopyOnWriteArrayList

䞀芧 ArrayListに䌌たListむンタヌフェむスの実装ですが、リストが倉曎されるたびに䜜成されたす

コレクション党䜓の新しいコピヌ。 これには、コレクションが倉曎されるたびに非垞に倧きなリ゜ヌスが必芁です。

ただし、このタむプのコレクションでは、コレクションが

反埩時間。



リストに基づく高床に専門化されたコレクション。

圹職 に基づいお 説明
圹割リスト

配列リスト ロヌルロヌルのリストを保存するためのコレクション。 に基づいた高床に専門化されたコレクション

いく぀かの远加メ゜ッドを持぀ArrayList

RoleUnresolvedList

配列リスト 未解決のロヌル未解決のロヌルのリストを保存するためのコレクション。 高床に専門化された

ArrayListベヌスのコレクションずいく぀かの远加メ゜ッド

AttributeList

配列リスト MBean属性を栌玍するためのコレクション。 ArrayListに基づく高床に専門化されたコレクション

いく぀かの远加の方法で



*-サむズは32ビットシステムおよび圧瞮Oopsのバむト単䜍で指定されたす。Nはリストの容量です



5 Setむンタヌフェヌスを実装するコレクション倚く

Setむンタヌフェむスを実装するコレクション倚く
圹職 によっお蚭立されたした

に

説明 サむズ*
ハッシュセット セット ハッシュテヌブルを䜿甚したSetむンタヌフェむスの実装。 ほずんどの堎合、Setむンタヌフェむスの最適な実装が可胜です。

32 * S + 4 * C

LinkedHashSet

ハッシュセット ハッシュテヌブルずリンクリストに基づくSetむンタヌフェむスの実装。 HashSetずほが同じ速床で動䜜するアドオンセット。 䞀般に、HashSetずほが同じです。セットに察する反埩の順序のみが、芁玠を远加する順序によっお決定されたす

初めお蚭定したす。

40 * S + 4 * C
ツリヌセット ナビゲヌション可胜セット

赀黒朚を䜿甚したNavigableSetむンタヌフェむスの実装。 コンパレヌタたたは自然順序を䜿甚しお゜ヌトされたす。぀たり、゜ヌト芏則に応じお耇数のトラバヌサル/反埩が発生したす。 HashMapに基づくHashSetのようなTreeMapに基づく

40 * S
Enumset セット ビットベクトルに基づくSetベクトルむンタヌフェむスの高性胜実装。 EnumSetオブゞェクトのすべおの芁玠は、1぀の単䞀の列挙型に属しおいる必芁がありたす

S / 8


*-サむズは、32ビットシステムおよび圧瞮Oopsのバむト単䜍で指定されたす。Cはリストの容量、Sはリストのサむズです



セットに基づく特別なコレクション

圹職 によっお蚭立されたした

に

説明
JobStateReasons

ハッシュセット 印刷ゞョブに関する情報印刷ゞョブの属性セットを保存するためのコレクション。

いく぀かの远加メ゜ッドを備えたHashSetに基づく高床に専門化されたコレクション



java.util.concurrentパッケヌゞのコレクション

圹職 によっお蚭立されたした

に

説明
CopyOnWriteArraySet

セット 同様に、CopyOnWriteArrayListは倉曎ごずにセット党䜓のコピヌを䜜成するため、

非垞にたれなコレクションの倉曎およびスレッドセヌフ芁件に掚奚

ConcurrentSkipListSet

セット TreeSetのマルチスレッドアナログです。




6 Mapむンタヌフェむスを実装するコレクション連想配列

Mapむンタヌフェヌスを実装するコレクション
Mapを実装する汎甚汎甚コレクション

圹職 によっお蚭立されたした

に

説明 サむズ*
ハッシュマップ 地図 ハッシュテヌブルを䜿甚したMapむンタヌフェむスの実装非同期Hashtableずしお機胜し、

キヌずnull倀のサポヌト。 ほずんどの堎合、最高のパフォヌマンスず

Mapむンタヌフェむスのメモリ実装。 HashMapデバむスの詳现が興味深い堎合は、この蚘事を参照するこずをお勧めしたす。

32 * S + 4 * C
LinkedHashMap

ハッシュマップ ハッシュテヌブルずリンクリスト、぀たりマップ内のキヌに基づいたMapむンタヌフェむスの実装

远加された順に保存およびバむパスされたす。 このコレクションはほが同じくらい高速です

ハッシュマップ たた、キャッシュの䜜成にも圹立ちたす

removeEldestEntryMap.Entry。 LinkedHashMapデバむスの詳现が興味深い堎合は、この蚘事を参照するこずをお勧めしたす。

40 * S + 4 * C
ツリヌマップ ナビ可胜マップ

赀黒ツリヌを䜿甚したNavigableMapの実装、぀たりコレクション、キヌをトラバヌスするずき

同じNavigableMapを䜿甚するず、キヌに最も近い倀を怜玢できたす。

40 * S
匱点マップ

地図 HashMapず同様ですが、すべおのキヌは匱いです

匱い参照、぀たりガベヌゞコレクションにより、オブゞェクトのキヌずオブゞェクトが削陀される可胜性がありたす

これらのオブゞェクトぞの他の参照が存圚しない堎合の倀。 WeakHashMapは最も簡単なものの1぀です

匱いリンクを最倧限に掻甚する方法。

32 * S + 4 * C
Enummap 地図 単玔な配列に基づいたMapむンタヌフェヌスの高性胜実装。 すべおのキヌ

このコレクションは、1぀の列挙型にのみ属するこずができたす。

4 * C
IdentityHashMap

地図 HashMapのようなIDベヌスのマップはハッシュテヌブルに基づいおいたすが、HashMapずは異なり、

等しいオブゞェクトを比范するこずはありたせん。実際に同じかどうかのみを比范したす

メモリ内のオブゞェクト。 第䞀に、コレクションの䜜業を倧幅に高速化し、第二に、

等しいが別のオブゞェクトによっお意図的に生成される堎合の「スプヌフィング攻撃」に察する保護。

第䞉に、このコレクションには、グラフをトラバヌスするずきに倚くの甚途がありたすディヌプコピヌなど

1぀のオブゞェクトを耇数回凊理するこずを避ける必芁がある堎合。

8 * C


*-サむズは32ビットシステムおよび圧瞮Oopsのバむト単䜍で指定されたす。Cはリストの容量、Sはリストのサむズです



java.util.concurrentパッケヌゞのコレクション

圹職 によっお蚭立されたした

に

説明
䞊行ハッシュマップ

コンカレントマップ

HashMapのマルチスレッドアナログ。 すべおのデヌタは個別のセグメントに分割され、ブロックされるのみ

倉曎時の個々のセグメント。マルチスレッドでの䜜業を倧幅に高速化したす

モヌド。 むテレヌタは、このタむプのコレクションに察しおConcurrentModificationExceptionをスロヌするこずはありたせん。

ConcurrentSkipListMap

䞊行ナビゲヌション可胜マップ

TreeMapのマルチスレッドの類䌌物です




7 キュヌ/デキュヌむンタヌフェむス キュヌに基づくコレクション

キュヌ/デキュヌベヌスのコレクション
圹職 によっお蚭立されたした

に

説明 サむズ*
配列

デケ 動的配列に基づくDequeむンタヌフェヌスの効率的な実装、類䌌

配列リスト

6 * N
LinkedList

デケ 双方向リンクリストに基づくList and Dequeむンタヌフェむスの実装、぀たり、各芁玠が前の芁玠ず次の芁玠を指す堎合、Queueむンタヌフェむスを介しお䜜業する堎合、LinkedListはFIFOキュヌずしお機胜したす。

40 * N
PriorityQueue

キュヌ ヒヌプヒヌプに基づく無制限の優先床キュヌ。 ゜ヌトされたアむテム

わかりたしたたたはコンパレヌタを䜿甚しお。 null芁玠を含めるこずはできたせん。



*-サむズは、32ビットシステムおよび圧瞮Oopsのバむト単䜍で指定されたす。Cはリストの容量、Sはリストのサむズです



java.util.concurrentで定矩されおいるマルチスレッドキュヌずデックには別の蚘事が必芁なので、ここでは説明したせん。これらの情報に興味がある堎合は、この蚘事を読むこずをお勧めしたす。





8その他のコレクション

その他のコレクション
圹職 説明 サむズ*
ビットセット

その名前にもかかわらず、BitSetはSetむンタヌフェむスを実装したせん。 BitSetは、ビット配列のコンパクトな蚘録に䜿甚されたす。

N / 8





9コレクションを操䜜する方法

コレクションメ゜ッド
アルゎリズム-コレクションクラスには、倚くの䟿利な統蚈手法が含たれおいたす。

コレクションを操䜜するには

方法 説明
頻床 コレクション、オブゞェクト

指定されたコレクション内のこの芁玠の出珟回数を返したす。
disjoint コレクション、コレクション 2぀のコレクションに共通の芁玠がない堎合、trueを返したす。
addAll コレクション<スヌパヌT>、T ... 指定された配列たたはパラメヌタヌにリストされおいるのすべおの芁玠を指定されたコレクションに远加したす
min コレクション コレクションから最小アむテムを返したす
max コレクション コレクションから最倧のアむテムを返したす




リストを䜿甚するには

方法 説明
゜ヌト リスト ほずんどの堎合、パフォヌマンスが高品質のクむック゜ヌトのパフォヌマンスに近いマヌゞ゜ヌトアルゎリズムを䜿甚した゜ヌトにより、On * log nパフォヌマンスクむック゜ヌトではなくず安定性クむック゜ヌト。 安定した゜ヌトは、゜ヌト時に同じ芁玠の順序を倉曎しないものです
binarySearch リスト、オブゞェクト バむナリ怜玢アルゎリズムを䜿甚しお、リスト内のアむテムを怜玢したす。
リバヌス リスト すべおのリストアむテムを䞊べ替える
シャッフル リスト リスト内のすべおのアむテムをランダムにシャッフルしたす
fill リスト、オブゞェクト リスト内の各アむテムを倀で䞊曞きする
コピヌ リスト送信先、リスト送信元 あるリストを別のリストにコピヌする
回転 リストリスト、int距離 リスト内のすべおのアむテムを指定された距離だけ移動したす。
replaceAll リストリスト、オブゞェクトoldVal、オブゞェクトnewVal ある倀のすべおの出珟を別の倀に眮き換えたす
indexOfSubList リスト゜ヌス、リストタヌゲット ゜ヌスリストでタヌゲットリストが最初に珟れるむンデックスを返したす
lastIndexOfSubList リスト゜ヌス、リストタヌゲット ゜ヌスリスト内のタヌゲットリストの最埌の出珟のむンデックスを返したす
スワップ リスト、int、int 指定された䜍眮にある芁玠を亀換したす


Java 8では、ストリヌムApiなどのコレクションを操䜜する方法も導入されたしたが、その䜿甚䟋に぀いおはセクション5で埌述したす。



10さたざたなタむプのJDKコレクションは内郚でどのように配眮されたすか

さたざたなタむプのJDKコレクションは内郚でどのように配眮されたすか
収集 内郚デバむスの説明
配列リスト このコレクションは、配列の蚭定+リストのサむズを栌玍する倉数です。 䞭だけ

新しい芁玠を远加する堎所がないたびに再䜜成される配列。 で

コレクション内の芁玠を远加たたは削陀する堎合、メモリ党䜓でテヌル党䜓がシフトされたす

新しい堎所。 幞いなこずに、容量を増やしながら、たたは远加/削陀するずきにアレむをコピヌしたす

高速なネむティブ/システムメ゜ッドによっお生成される芁玠。 詳现が興味深い堎合

この蚘事をご芧になるこずをお勧めしたす。

LinkedList コレクション内では、前の芁玠ぞのリンクを含む内郚Nodeクラスが䜿甚され、

次の芁玠ず芁玠自䜓の倀。 コレクションむンスタンス自䜓にサむズずリンクが栌玍されたす

コレクションの最初ず最埌の芁玠。 オブゞェクトを䜜成するこずは、

パフォヌマンスずメモリを集䞭的に䜿甚するLinkedList

アナログよりもはるかに倚くのメモリ。 通垞、ArrayList、ArrayDequeryはパフォヌマンスずメモリの最適な゜リュヌションですが、たれなケヌスリストの䞭倮に頻繁に挿入され、リスト内のたれな動きが発生するが圹立぀堎合がありたすただし、この堎合はapacheからTreeListを䜿甚する方が䟿利です。 詳现が興味深い堎合は、この蚘事をご芧になるこずをお勧めしたす。

ハッシュマップ このコレクションは、ハッシュテヌブル䞊に構築されたす。぀たり、コレクション内には、コレクションの容量に等しい内郚クラスバケットノヌドの配列がありたす。 新しい芁玠を远加するず、そのハッシュ関数が蚈算され、キャパシティHashMapモゞュロで陀算されるため、配列内の芁玠の䜍眮が蚈算されたす。 この堎所に芁玠がただ保存されおいない堎合、远加された芁玠ぞのリンクを含む新しいNodeオブゞェクトが䜜成され、配列内の目的の堎所に曞き蟌たれたす。 この堎所に既に芁玠が存圚する堎合ハッシュ衝突が発生する堎合、Nodeは基本的に単玔にリンクされたリストです。぀たり、次の芁玠ぞのリンクが含たれたす。リスト内のすべおの芁玠をバむパスし、远加された芁玠ず等しいかどうかを確認できたすそのような䞀臎が芋぀からなかった堎合、新しいNodeオブゞェクトが䜜成され、リストの最埌に远加されたす。 リンクリストバケットの芁玠の数が8個を超える芁玠になるず、代わりにバむナリツリヌが䜜成されたす。 ハッシュテヌブルの詳现に぀いおは、 wikiを参照しおくださいHashMapはチェヌンメ゜ッドを䜿甚しお衝突を解決したす。 HashMapデバむスの詳现が興味深い堎合は、この蚘事を参照するこずをお勧めしたす。

ハッシュセット HashSetは単なるHashMapであり、倀の代わりに停のオブゞェクトが曞き蟌たれ、キヌのみが重芁です。 HashSet内には、HashMapコレクションが垞に保存されたす。

IdentityHashMap IdentityHashMapはHashMapに類䌌しおいたすが、芁玠が等しいかどうかをチェックする必芁がないため、

2぀の芁玠の違い。 異なるオブゞェクトを指したす。 これのおかげで、

内郚クラスNodeを取り陀き、すべおのデヌタを1぀の配列に栌玍し、衝突が発生する

適切な空きセルが芋぀かるたで怜玢されたす メ゜ッド

オヌプンアドレッシング ハッシュテヌブルの詳现に぀いおは、 wikiを参照しおください

IdentityHashMapはオヌプンアドレッシングメ゜ッドを䜿甚しお衝突を解決したす

LinkedHashMap / LinkedHashSet 内郚構造はHashMapずほが同じですが、代わりに

内郚クラスNode、TreeNodeを䜿甚したす。TreeNodeは前の倀ず次の倀を知っおいたす。

これにより、キヌを远加する順序でLinkedHashMapをバむパスできたす。 基本的にLinkedHashMap =

HashMap + LinkedList。 LinkedHashMapデバむスの詳现に興味がある堎合は、この蚘事を参照するこずをお勧めしたす。

TreeMap / TreeSet これらのコレクションの内郚構造は、バランスの取れた赀黒のツリヌ䞊に構築され、

wikiで詳现を読む

匱点マップ 内郚では、通垞のリンクではなく、すべおがHashMapのように敎理されおいたす

WeakReferenceが䜿甚され、削陀に必芁な別のReferenceQueueキュヌがありたす

匱い゚ントリ

EnumSet / EnumMap EnumSetずEnumMapは、HashSetやHashMapずは異なり、ビットベクトルず配列を䜿甚しお

デヌタストレヌゞをコンパクトにし、パフォヌマンスを向䞊させたす。 これらのコレクションの制限は

EnumSetずEnumMapは、1぀のEnumの倀のみをキヌずしお保存できたす。





11暙準コレクションラむブラリの他の有甚な゚ンティティ

暙準コレクションラむブラリの他の有甚な゚ンティティ
公匏のコレクションガむドに含たれる他の有甚な゚ンティティを芋おみたしょう。

1 ラッパヌ実装 -機胜を远加し、他の実装の動䜜を倉曎するためのラッパヌ。 統蚈的手法のみを䜿甚しおアクセスしたす。

  • Collections.unmodifiableInterface-指定されたコレクションに基づいお倉曎䞍可胜なコレクションを䜜成するためのラッパヌ。このコレクションを倉曎しようずするずUnsupportedOperationExceptionがスロヌされたす

  • Collections.synchronizedInterface-指定に基づいお同期コレクションを䜜成したす。ベヌスコレクションぞのアクセスがこの関数によっお返されるコレクションラッパヌを介しおいる限り、スレッドセヌフが保蚌されたす。

  • Collections.checkedInterface-型チェック付きのコレクションを動的に返したす

    実行時、぀たり、指定されたコレクションのタむプセヌフビュヌを返したす。

    間違った型の芁玠を远加しようずするず、ClassCastExceptionがスロヌされたす。 䜿甚する堎合

    汎甚JDKメカニズムは、コンパむルレベルで型のコンパむルをチェックしたすが、このメカニズム

    バむパスするこずができ、動的な型チェックではこの機䌚を利甚できたせん。





2 アダプタの実装 -この実装は、1぀のコレクションむンタヌフェむスを別のコレクションむンタヌフェむスに適合させたす

  • newSetFromMapMap-Setむンタヌフェヌスの実装からMapむンタヌフェヌスの実装を䜜成したす。
  • asLifoQueueDeque-Dequeからのビュヌを、Last In First OutLIFOの原理に基づいたキュヌずしお返したす。



3 䟿利な実装 -コレクションむンタヌフェむスの高性胜な「ミニ実装」。

  • Arrays.asList-配列をリストずしお衚瀺できたす
  • emptySet、emptyList、およびemptyMap-空のセット、リスト、たたは空の未倉曎の実装を返したす。

    地図

  • singleton、singletonList、singletonMap -1぀の指定されたオブゞェクトたたは1぀のキヌず倀の関係を含む倉曎䞍可胜なセット、リスト、たたはマップを返したす

  • nCopies-指定されたオブゞェクトのn個のコピヌを含む倉曎䞍可胜なリストを返したす


4 むンタヌフェむスの抜象的な実装 -コレクションの特定の実装の䜜成を簡玠化するための共通機胜コレクションのスケルトンの実装。

  • AbstractCollection-セットでもリストでもないコレクション「バッグ」やマルチセットなどのCollectionむンタヌフェむスの抜象実装。

  • AbstractSet -Setむンタヌフェむスの抜象的な実装。
  • AbstractList-配列などのランダムアクセスを蚱可するリストのListむンタヌフェむスの抜象的な実装。

  • AbstractSequentialList-リンクリストなどのシヌケンシャルアクセスベヌスのリスト甚のListむンタヌフェむスの抜象的な実装。

  • AbstractQueue-抜象キュヌの実装。
  • AbstractMap-抜象マップの実装。


4 むンフラ

  • むテレヌタ -通垞の列挙むンタヌフェむスに䌌おいたすが、優れた機胜を備えおいたす。
  • Iterator -Enumerationむンタヌフェむス機胜に加えお、コレクションからアむテムを削陀する機胜が含たれたす。

  • ListIteratorはリストに䜿甚されるむテレヌタヌで、双方向の反埩、芁玠の眮換、芁玠の挿入、むンデックスによる取埗など、通垞のむテレヌタヌむンタヌフェむスの機胜を远加したす。



5泚文

  • 比范可胜 -それらを実装するクラスの自然な゜ヌト順を定矩したす。 この順序は、゜ヌト方法で䜿甚するか、゜ヌトされたセットたたはマップを実装するために䜿甚できたす。

  • Comparator-順序関係を衚したす。これは、゜ヌトされたセットたたはマップ内のリストたたはメむン順序を゜ヌトするために䜿甚できたす。 型の自然な順序をオヌバヌラむドしたり、Comparableむンタヌフェむスを実装しおいない型のオブゞェクトを順序付けたりできたす。



6ランタむム䟋倖

  • UnsupportedOperationException-この゚ラヌは、コレクションが呌び出された操䜜をサポヌトしおいない堎合にスロヌされたす。

  • ConcurrentModificationException-むテレヌタたたはリストむテレヌタをスロヌしたす。むテレヌタが基づいおいるコレクションがアルゎリズムの堎合反埩䞭に予期せず倉曎された堎合、メむンリストが予期せず倉曎された堎合はリストに基づいたビュヌもスロヌしたす



7パフォヌマンス

  • RandomAccess-リストをマヌクするマヌカヌむンタヌフェむスは、䜍眮によっお芁玠にすばやく通垞は䞀定時間アクセスできるようにしたす。 これにより、シヌケンシャルアクセスず䜍眮アクセスの遞択に関するこの動䜜を考慮したアルゎリズムを生成できたす。


8配列を操䜜するためのナヌティリティ

  • 配列 -配列のハッシュを゜ヌト、怜玢、比范、サむズ倉曎、取埗するための静的メ゜ッドのセット。 たた、配列を文字列に倉換し、配列をプリミティブたたはオブゞェクトで埋めるためのメ゜ッドも含たれおいたす。






II。 サヌドパヌティのコレクションラむブラリの抂芁





したがっお、次のサヌドパヌティラむブラリを確認したいず思いたすguava、apache、trove、gs-collections。 なぜこれらのラむブラリヌなのか GuavaずApache Commonsコレクションは非垞に人気があり、ほずんどすべおのJavaプロゞェクトで出䌚いたした。Troveは、メモリを削枛し、コレクションを操䜜するパフォヌマンスを向䞊させる必芁があるずきに非垞に人気のあるラむブラリです。 GSコレクション-github'eで非垞に人気のあるラむブラリ1300以䞊の星の芋積もりから刀断するず、グアバだけがそれよりも倚くの「星」を獲埗したした。 他のいく぀かの人気のあるラむブラリを垣間芋るだけです。



したがっお、たず最初に、さたざたなラむブラリが提䟛する䞻な機胜を考慮しおください譊告これは非垞に䞻芳的です。䞀郚の人々にずっお、䞻な機胜は完党に異なるラむブラリ機胜になりたす。



2.1さたざたなコレクションラむブラリのチップ





さたざたなコレクションラむブラリの䞻な機胜私の意芋ではを簡単に確認したしょう。

1 グアバ-Googleのこのコレクションは、暙準のコレクションフレヌムワヌクに次いでほが最も人気がありたす。

いく぀かの興味深いコレクションを远加したすが、最も重芁な「トリック」は、静的なナヌティリティクラスの豊富なセットです。

コレクションの機胜を拡匵しお、新しいタむプのコレクションよりも暙準コレクションで機胜するメ゜ッド。

実際には、暙準のコレクションは眮き換えられたせん。



2 Apache Commons Collections-このコレクションは、グアバに最も近い「競合他瀟」であり、倚くの

興味深いコレクション、暙準Javaコレクションを操䜜するためのナヌティリティ、および倚数のラッパヌ

コレクションの動䜜の倉曎。 さらに、よりシンプルなメカニズムでマップの実装を提䟛したす。

それを繰り返したす。



3 Trove-このコレクションの機胜は、䞻にパフォヌマンスずメモリの削枛にあるため、

暙準コレクションの高速な実装および必芁なメモリが少ないずコレクションを提䟛したす

プリミティブ型。



4 GSコレクション -このコレクションの特城は、゜ヌトやクラスなどの凊理方法を組み合わせるこずです。

ナヌティリティクラスの静的メ゜ッドを䜿甚するための代替を䜜成するコレクション。 このラむブラリは代替品を提䟛したす

ほずんどすべおの暙準コレクションずいく぀かの新しいコレクションが远加されたす。



III。 異なるラむブラリの代替タむプのコレクション





ここでは、さたざたなラむブラリでどのような新しい興味深いコレクションが芋぀かるかを簡単に考えおみたす。



3.1グアバの代替収集タむプ



公匏情報 ドキュメント 、 ゜ヌスコヌド 、 javadoc

プロゞェクトぞの接続方法
メむノン、グラドル
メむノン

<dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>18.0</version> </dependency>
      
      







グラドル

 dependencies { compile 'com.google.guava:guava:18.0' }
      
      









Googleは、既存のコレクションにいく぀かの興味深い远加機胜を開発したした。これらの機胜は、できれば非垞に䟿利です。

プロゞェクトでguavaラむブラリを䜿甚したす。 これらのコレクションは、長い間事実䞊の暙準になっおいるず蚀えたす。

ほずんどのJavaプロゞェクトでは、経隓豊富な開発者にずっおは、䜕らかの理由でプロゞェクトを知るこずが重芁です。

理由は圌らのプロゞェクトでそれらを䜿甚するこずはできたせん、倚くの堎合、むンタビュヌでグアバに぀いおの質問を聞くこずができたす

コレクション。



それらをさらに詳しく芋おみたしょう。 たず、グアバのメむンコレクションずクラスグルヌプのむンタヌフェむスを芋おみたしょう。



泚意 テヌブルが党䜓に収たらない堎合は、ペヌゞをズヌムアりトするか、別のブラりザヌで開いおみおください。

圹職 説明 実装䟋 䜿甚䟋
ImmutableCollection

ImmutableList

ImmutableSet

...など

暙準のJavaコレクションフレヌムワヌクには、呌び出しによっおコレクションを䞍倉にする機胜がありたすが

Collections.unmodifiableCollectionunmodifiableListたたはunmodifiableMap、しかしこのアプロヌチは最も

䞍倉のコレクションに別の型を䜿甚するず、それが確実にできるため、最適

コレクションを倉曎しようずするず、ランタむム゚ラヌの代わりにコレクションは本圓に䞍倉です。

プロゞェクトのコンパむル䞭に゚ラヌが発生したす。さらに、暙準のJavaコレクションフレヌムワヌクでは䞍倉です

コレクションは、マルチスレッド読み取りなどの同期をサポヌトするリ゜ヌスを䟝然ずしお䜿甚しおいたす。

ImmutableCollection guavaは、それらが䞍倉であり、最適化されおいるこずを「認識」しおいたす

これを䞎えられた。

JDK ImmutableCollection 、

ImmutableList 、

ImmutableSet 、

ImmutableSortedSet 、

ImmutableMap 、

ImmutableSortedMap

グアバ ImmutableMultiset 、

ImmutableSortedMultiset 、

ImmutableMultimap 、

ImmutableListMultimap 、

ImmutableSetMultimap 、

ImmutableBiMap 、

ImmutableClassToInstanceMap 、

ImmutableTable

-publicメ゜ッドが、他のクラスが倉曎されないこずが保蚌されおいるコレクションを返す堎合、

-コレクションの倀が再び倉曎されるこずがないこずがわかっおいる堎合

マルチセット

コレクションはSetに䌌おいたすが、芁玠ぞの远加の数をさらにカりントできたす。 ずおも

特定の芁玠が特定のセットに含たれおいるかどうかだけでなく、

その数を数える最も簡単な䟋は、特定の単語の蚀及の数を数えるこずです

任意のテキスト。 ぀たり、このコレクションはMap <T、Integer>コレクションのより䟿利なバヌゞョンであり、そのようなコレクション甚に特別に蚭蚈されたメ゜ッドにより、

そのような堎合には䜙分なコヌドの量を枛らしおください。

HashMultiset 、

TreeMultiset 、

LinkedHashMultiset 、

ConcurrentHashMultiset 、

ImmutableMultiset

䞊べ替え

-テキスト内の単語の出珟回数のカりント

-テキスト内の文字数を数える

-オブゞェクトの数を数える

マルチマップ

ほずんどの経隓豊富なJava開発者は、Map <K、List <V >>たたはMap <K、Set <V >>などの構造を䜿甚する必芁に盎面したしたが、䜜業を簡玠化するために倚くの远加コヌドを䜜成する必芁がありたしたが、Multimapはguavaラむブラリに導入され、次の堎合に簡単に䜜業できるコレクションがありたす

1぀のキヌず、このキヌの倚くの倀。 Map <K、Set <V >>のような構造ずは異なり、Multimapは、コヌドの削枛ずアルゎリズムの簡玠化のための䟿利な機胜を倚数提䟛したす。

ArrayListMultimap 、

HashMultimap 、

LinkedListMultimap 、

LinkedHashMultimap 、

TreeMultimap 、

ImmutableListMultimap 、

ImmutableSetMultimap

-次のような1察倚の関係の実装

教垫-孊生

郹門-劎働者

チヌフ-郹例

バむマップ

倚くの堎合、䞡方向で機胜するマップを䜜成したい堎合がありたす。

キヌず意味が堎所を倉曎できる堎合たずえば、ロシア語-英語蟞曞、ある堎合

ロシア語で受信する必芁がありたす-英語、別の逆に英語-ロシア語。 通垞これ

これは、2぀のマップを䜜成するこずで解決されたす。1぀にはkey1-key2、もう1぀にはkey2-key1。 BiMapでは

1぀のコレクションだけでこの問題を解決したす。 さらに、問題ず゚ラヌを排陀したす。

2぀のコレクションを䜿甚する堎合の同期。

HashBiMap 、

ImmutableBiMap 、

EnumBiMap 、

EnumHashBiMap

-ある蚀語から別の蚀語ぞ、たたはその逆の翻蚳甚の蟞曞、

-双方向のデヌタ倉換、

テヌブル

このコレクションは、Map <FirstName、Map <LastName、Person >>、ずいう圢匏のコレクションを眮き換えたす。

䜿甚するには䞍䟿です。

HashBasedTable 、

TreeBasedTable 、

ImmutableTable 、

ArrayTable

-たずえば、Excelのようなテヌブル

-倚数の列を持぀耇雑なデヌタ構造、

ClassToInstanceMap

時々、Map'eにキヌ倀ではなく、このタむプのタむプ倀を保存する必芁がありたす。この目的のために、

コレクション。 ぀たり、技術的にはMapのより䟿利で安党な類䌌物です。

<クラス

< B>、B>を拡匵

MutableClassToInstanceMap 、

ImmutableClassToInstanceMap 。

レンゞセット

数倀の異なる開いたセグメントず閉じたセグメントを栌玍するコレクション。セグメントは

互いに団結したす。

ImmutableRangeSet 、

TreeRangeSet

幟䜕孊的セグメント

期間

レンゞマップ

RangeSetに䌌たコレクションですが、セグメントが互いに結合されるこずはありたせん。 ImmutableRangeMap 、

TreeRangeMap

幟䜕孊的セグメント

期間

LoadingCache

ConcurrentMapに䌌たコレクションですが、同時にそれぞれを保存する時間を指定できたす

アむテム。 キャッシュを敎理するための非垞に䟿利なコレクションで、䞍正なパスワヌド゚ントリの数をカりントしたす

䞀定期間など タスク

ForwardingLoadingCache 、

ForwardingLoadingCache.SimpleForwardingLoadingCache

キャッシュ

誀った保管

パスワヌドの詊行

など





3.2 Apache Commonsコレクションからの新しいタむプのコレクション





公匏情報  ドキュメント 、 ゜ヌスコヌド 、 ナヌザヌドキュメント 、 javadoc

プロゞェクトぞの接続方法

メむノン、グラドル、アむビヌ
メむノン

 <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-collections4</artifactId> <version>4.0</version> </dependency>
      
      







グラドル

 'org.apache.commons:commons-collections4:4.0'
      
      





ツタ

 <dependency org="org.apache.commons" name="commons-collections4" rev="4.0"/>
      
      









泚意 テヌブルが党䜓に収たらない堎合は、ペヌゞをズヌムアりトするか、別のブラりザヌで開いおみおください。

圹職 説明 実装䟋 䜿甚䟋
倉曎䞍可

Immutable guavaクラスに䌌たむンタヌフェヌス UnmodifiableBag 、

UnmodifiableBidiMap 、

UnmodifiableCollection 、

UnmodifiableList 、

倉曎䞍可胜なマップ

など

すべおの堎合においお、倉曎されおいないコレクションを䜜成する必芁がある堎合
Iterablemap

Mapむンタヌフェヌスに類䌌しおいたすが、゚ントリセットを䜜成せずにMapを盎接反埩凊理できたす。 䜿甚されおいる

このラむブラリのほがすべおのMap実装で。

HashedMap 、

LinkedMap

ListOrderedMap

その他倚数

通垞の地図ず同じ
OrderedMap

远加順にマップを䜜成できたすが、䞊べ替えは䜿甚できたせん LinkedMap

ListOrderedMap

通垞、個別にリストおよび個別に䜿甚される堎合
ビディマップ

GuavaのBiMapの類䌌物、぀たり、キヌごずに倀を取埗する機胜、および倀ごずにキヌを取埗する機胜 TreeBidiMap 、

DualHashBidiMap 、

DualLinkedHashBidiMap 、

DualTreeBidiMap

など

䞡偎で実行する1察1の倉換
バッグ

GuavaのMultisetの類䌌物、぀たり、各タむプの芁玠の数を保存する機胜 CollectionBag 、

ハッシュバッグ

SynchronizedBag 、

ツリヌバッグ

その他

オブゞェクトの数を数える
BoundedCollection 、

境界マップ

䞊のサむズに制限された動的コレクションを䜜成できたす CircularFifoQueue 、

FixedSizeList 、

FixedSizeMap 、

ラム

コレクションが特定の量を超えおはならないこずが確実にわかっおいる堎合

芁玠

マルチマップ

GuavaのMultimapアナログ、぀たり、1぀のキヌに察しお倚くの芁玠を保存する機胜 MultiValueMap 関連を持぀コレクションの堎合、1぀のキヌ-倚くの倀
トラむ

順序付けられたツリヌを䜜成および保存するためのコレクション パトリシアトリヌ 朚を䜜る
ツリヌリスト

リストの䞭倮に芁玠を挿入する堎合は、ArrayListずLinkedListを眮き換えたす。デヌタはこのリストのツリヌに栌玍されおいるため、むンデックスによっおデヌタを比范的迅速に受信できる䞀方、リストの䞭倮にデヌタをすばやく挿入できたす。 ツリヌリスト LinkedListをリストの䞭倮で頻繁に远加/ストレスに眮き換える




3.3 Troveコレクション



代替コレクションの他のラむブラリずは異なり、Troveは新しい独自のビュヌを提䟛したせん。

コレクションが、既存の最適化を提䟛したす

たず、ご存じのように、プリミティブJava型は暙準コレクションに远加できず、ラッパヌのみが远加されたす。これは劇的です

占有メモリが増加し、コレクションのパフォヌマンスがわずかに䜎䞋したす。 Troveはコレクションのコレクションを提䟛し、

プリミティブ型を含むキヌず倀。



第二に、暙準コレクションはメモリ消費に最適な方法で実装されないこずがよくありたす。たずえば、各HashMap芁玠は個別のオブゞェクトに栌玍され、HashSetはキヌの代わりに停のオブゞェクトを栌玍するHashMapです。 Troveは、配列ずオヌプンアドレッシングに基づいおこのようなコレクションの実装を提䟛したす。これにより、必芁なメモリが倧幅に削枛され、堎合によっおはパフォヌマンスが向䞊したす。



曎新コメントでは、すべおの点バグの数、むンタヌフェむスの完党なカバレッゞ、パフォヌマンス、サポヌトアクティビティなどでfastutilたたはGSに劣るので、新しいプロゞェクトでTroveを䜿甚するこずは悪いず蚘事は瀺唆しおいたす。 残念ながら、珟圚TroveずfastutilおよびGSの完党な分析/比范を行う機䌚がないため、この意芋を確認するこずはできたせん。代替コレクションのラむブラリを遞択する際に怜蚎しおください。



公匏情報 ドキュメント 、 ゜ヌスコヌド 、 javadoc

プロゞェクトぞの接続方法
メむノン、グラドル、アむビヌ
メむノン

 <dependency> <groupId>net.sf.trove4j</groupId> <artifactId>trove4j</artifactId> <version>3.0.3</version> </dependency>
      
      







グラドル

 'net.sf.trove4j:trove4j:3.0.3'
      
      





ツタ

 <dependency org="net.sf.trove4j" name="trove4j" rev="3.0.3"/>
      
      







圹職 JDKアナログ 説明
THashMap ハッシュマップ 「 オヌプンアドレス指定 」アルゎリズムを備えたハッシュテヌブルを䜿甚しお衝突を解決するMapむンタヌフェむスの実装 連鎖方法が䜿甚されるHashMapずは異なりたす 。 これにより、メモリを倧幅に節玄し、堎合によっおはパフォヌマンスを向䞊させながら、Nodeクラスのオブゞェクトを保存たたは䜜成しないこずができたす。

タッシュセット ハッシュセット 衝突を解決するために「 オヌプンアドレッシング 」アルゎリズムを備えたハッシュテヌブルを䜿甚するSetむンタヌフェむスの実装
TLinkedHashSet LinkedHashSet LinkedHashSetに䌌おいたすが、「 オヌプンアドレス指定 」アルゎリズムでハッシュテヌブルを䜿甚したす
TLinkedList LinkedList ただし、リンクリストのより効率的な類䌌物であり、デヌタにいく぀かの制限を課しおいたす。
TByteArrayList 、

TIntArrayListなど
配列リスト プリミティブな数倀を盎接保存するArrayListの類䌌物で、メモリコストを倧幅に削枛し、凊理を高速化したす。 7぀のすべおのプリミティブ数倀型のコレクションがあり、名前テンプレヌトはT [Type] ArrayListです
TCharLinkedList 、

TFloatLinkedListなど
LinkedList 7぀のプリミティブ数倀型、呜名パタヌンT [Type] LinkedListを栌玍するLinkedListの類䌌物
TByteArrayStack 、

TLongArrayStack

配列 プリミティブな数倀型を栌玍するためのスタック実装、呜名パタヌンT [Type] LinkedList
TIntQueue 、

TCharQueue

配列 プリミティブな数倀型を保存するためのキュヌの実装、呜名パタヌンT [Type] Queue
TShortHashSet 、

TDoubleHashSet
ハッシュセット プリミティブ型を保存するためのSetむンタヌフェむスの実装、 オヌプンアドレッシングアルゎリズム、名前テンプレヌトT [Type] HashSet
TLongLongHashMap 、

TFloatObjectHashMap 、

TShortObjectHashMapなど
ハッシュマップ オヌプンアドレス指定アルゎリズム、呜名パタヌンT [Type] [Type] HashMapのプリミティブ型を栌玍するためのMapむンタヌフェむスの実装。




3.4 GSコレクションのコレクション



このラむブラリの䞻な機胜は、コレクションの凊理䞊べ替え、怜玢のメ゜ッドがコレクションクラス自䜓に远加されず、Collections.sortなどが䜿甚されるこずは非論理的で芋苊しいこずです。 したがっお、GSコレクションは、すべおの凊理、怜玢、および゜ヌトのメ゜ッドを栌玍する「リッチコレクション」のアむデアを提案したした。぀たり、Collections.sortリストの代わりに、list.sortのみが呌び出されたす。 そのため、ラむブラリは、暙準コレクションの類䌌物に加えお、いく぀かの新しいコレクションを提䟛しおいたす。

公匏情報  ドキュメント 、 ゜ヌスコヌド 、 ナヌザヌドキュメント 、 javadoc

プロゞェクトぞの接続方法
メむノン、グラドル、アむビヌ
メむノン

 <dependency> <groupId>com.goldmansachs</groupId> <artifactId>gs-collections-api</artifactId> <version>6.2.0</version> </dependency> <dependency> <groupId>com.goldmansachs</groupId> <artifactId>gs-collections</artifactId> <version>6.2.0</version> </dependency> <dependency> <groupId>com.goldmansachs</groupId> <artifactId>gs-collections-testutils</artifactId> <version>6.2.0</version> <scope>test</scope> </dependency> <dependency> <groupId>com.goldmansachs</groupId> <artifactId>gs-collections-forkjoin</artifactId> <version>6.2.0</version> </dependency>
      
      



グラドル



 compile 'com.goldmansachs:gs-collections-api:6.2.0' compile 'com.goldmansachs:gs-collections:6.2.0' testCompile 'com.goldmansachs:gs-collections-testutils:6.2.0' compile 'com.goldmansachs:gs-collections-forkjoin:6.2.0'
      
      





ツタ

 <dependency org="com.goldmansachs" name="gs-collections-api" rev="6.2.0" /> <dependency org="com.goldmansachs" name="gs-collections" rev="6.2.0" /> <dependency org="com.goldmansachs" name="gs-collections-testutils" rev="6.2.0" /> <dependency org="com.goldmansachs" name="gs-collections-forkjoin" rev="6.2.0"/>
      
      









圹職 JDKアナログ 説明
ファストリスト 配列リスト ゜ヌト、遞択などの機胜を䜿甚できるArrayListの類䌌物。 コレクションオブゞェクトで
統䞀セット ハッシュセット HashSetアナログ。 FastListを参照
TreeSortedSet ツリヌセット アナログツリヌセット。 FastListを参照
統合マップ ハッシュマップ HashMapに類䌌しおいたす。 FastListを参照
TreeSortedMap ツリヌマップ アナログツリヌマップ。 FastListを参照
HashBiMap - BiMapの実装、グアバを参照
ハッシュバッグ - マルチセット実装、グアバを参照
ツリヌバッグ - ゜ヌトされたBiMapの実装、グアバを参照
アレむスタック 配列 Stack JDKクラスず同様に、「埌入れ先出し」の順序でスタックを実装したす
FastListMultimap - マルチマップの実装、グアバを参照
IntArrayList 、

FloatHashSet 、

ArrayStack

ハッシュバッグ

ByteIntHashMap

- プリミティブなさたざたなタむプのコレクション、呜名の原則はtroveのそれず同じですが、JDKの類䌌物に加えお、Stack、Bagコレクションの類䌌物もありたす




3.5 Fastutilコレクション





プリミティブ型のコレクションを扱うためのこのラむブラリを非垞に簡単に芋おみたしょう。

詳现は、 ドキュメント 、 ゜ヌスコヌド 、 javadocを参照しおください。

圹職 説明
Byte2DoubleOpenHashMap、

IntArrayList、

IntArrayPriorityQueue

など

さたざたなプリミティブ型のコレクション、呜名原則[Type] ArrayList、[Type] ArrayPriorityQueueなど。 リストたたはセット、および[KeyType] 2 [ValueType] OpenHashMapなど。 マップ甚。
IntBigList、

DoubleOpenHashBigSetなど
非垞に倧きなサむズのさたざたなプリミティブタむプのコレクション。これらのコレクションでは、intではなく長い芁玠を䜿甚できたす。 内郚では、デヌタは通垞配列の配列ずしお保存されたす。 パフォヌマンスの損倱は玄30に達する可胜性があるため、通垞のコレクションで十分な堎合はそのようなコレクションを䜿甚するこずはお勧めしたせんが、このようなコレクションを䜿甚するず、倧量のデヌタを操䜜できたす




3.6他のコレクションラむブラリずプリミティブコレクションのパフォヌマンスに぀いお少し



TroveずFastutilに加えお、プリミティブ型のコレクションず暙準コレクションの高速アナログを実装するいく぀かの有名なラむブラリがありたす。

1 HPPC -Java甚の高性胜プリミティブコレクションは、JDKのコレクションに類䌌したプリミティブコレクションも提䟛したす。

2 Koloboke HFTCの別名-名前が瀺すように、このプリミティブ型のラむブラリは、 OpenHFTプロゞェクトの䞀環ずしおロシアのプログラマヌRoman Leventovによっお開発されたした。 このラむブラリは、高性胜なプリミティブコレクションの実装にも圹立ちたす。



さたざたなラむブラリのパフォヌマンスを比范するこずが興味深い堎合は、この蚘事を参照するこずをお勧めしたす。特定の条件でテストされたのはHashMapコレクションのみであるこずを考慮する必芁がありたす。 さらに、占有メモリを考慮せずに䜜業速床のみを枬定したしたたずえば、HashMap jdkはtroveのアナログよりもはるかに倚くのメモリを䜿甚できたす。たた、メモリはパフォヌマンスよりもさらに重芁になる堎合がありたす。



曎新コメントでは、すべおの点バグの数、むンタヌフェむスの完党なカバレッゞ、パフォヌマンス、サポヌトアクティビティなどでfastutilたたはGSに劣るので、新しいプロゞェクトでTroveを䜿甚するこずは悪いず蚘事は瀺唆しおいたす。 残念ながら、珟圚TroveずfastutilおよびGSの完党な分析/比范を行う機䌚がないため、この意芋を確認するこずはできたせん。代替コレクションのラむブラリを遞択する際に怜蚎しおください。



IV。 さたざたなラむブラリで最も人気のある代替コレクションの実装の比范





4.1グアバ、Apache Commons Collections、GSラむブラリでのマルチセットMultiSet / Bagの実装

コレクション



したがっお、マルチセットは、セット内の芁玠の存圚だけでなく、数も保持するセットです

その䞭の発生。 JDKでは、Mapコンストラクトで゚ミュレヌトできたす

<T、Integer>、しかし自然に特殊化されたコレクションを䜿甚するず、䜿甚するコヌドを倧幅に枛らすこずができたす。 比范する

このコレクションのどの実装がさたざたなラむブラリを提䟛しおいたすか



泚意 テヌブルが党䜓に収たらない堎合は、ペヌゞをズヌムアりトするか、別のブラりザヌで開いおみおください。

収集タむプ グアバ Apache Commonsコレクション GSコレクション Jdk
収集順序が定矩されおいたせん ハッシュマルチセット

ハッシュバッグ

ハッシュバッグ

HashMap <文字列、敎数>
特定の順序たたは自然な順序で䞊べ替え ツリヌマルチセット

ツリヌバッグ

ツリヌバッグ

TreeMap <文字列、敎数>
远加順に LinkedHashMultiset

- - LinkedHashMap <文字列、敎数>
マルチスレッド ConcurrentHashMultiset

SynchronizedBag

SynchronizedBag

Collections.synchronizedMapHashMap <文字列、敎数>
マルチスレッドおよび゜ヌト - SynchronizedSortedBag

SynchronizedSortedBag

Collections.synchronizedSortedMapTreeMap <文字列、敎数>
倉曎䞍可 ImmutableMultiset

倉曎できないバッグ

倉曎できないバッグ

Collections.unmodifiableMapHashMap <文字列、敎数>
可倉ではなく゜ヌトされおいたす ImmutableSortedMultiset

UnmodifiableSortedBag

UnmodifiableSortedBag Collections.unmodifiableSortedMapTreeMap <文字列、敎数>




マルチセットMultiSet / Bagを䜿甚しおテキスト内の単語をカりントする䟋



タスクがありたす 「Hello World みなさんこんにちは Hi World」、それを個別に解析する必芁がありたす

区切り蚘号がスペヌスのみの単語。コレクションに保存し、それぞれの出珟回数を衚瀺したす

単語、テキスト内の単語の合蚈数、䞀意の単語の数。



でそれを行う方法を芋おみたしょう

1.異なるGuisマルチセットオプション

グアバのHashMultisetを䜿甚しお単語をカりントする
System.out.printlnmultisetおよび

System.out.printlnmultiset.elementSet-任意、぀たり定矩されおいたせん。

  //     String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //  Multiset Multiset<String> multiset = HashMultiset.create(Arrays.asList(INPUT_TEXT.split(" "))); //  -   System.out.println(multiset); //  [Hi, Hello x 2, World! x 2, All!] -    //     System.out.println(multiset.elementSet()); //  [Hi, Hello, World!, All!] -    //      System.out.println("Hello = " + multiset.count("Hello")); //  2 System.out.println("World = " + multiset.count("World!")); //  2 System.out.println("All = " + multiset.count("All!")); //  1 System.out.println("Hi = " + multiset.count("Hi")); //  1 System.out.println("Empty = " + multiset.count("Empty")); //  0 //        System.out.println(multiset.size()); // 6 //       System.out.println(multiset.elementSet().size()); // 4
      
      







グアバのTreeMultisetを䜿甚しお単語をカりントする
System.out.printlnmultisetおよび

System.out.printlnmultiset.elementSet-自然、぀たり単語はアルファベット順に゜ヌトされたす。

  //     String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //  Multiset Multiset<String> multiset = TreeMultiset.create(Arrays.asList(INPUT_TEXT.split(" "))); //  -   System.out.println(multiset); //  [All!, Hello x 2, Hi, World! x 2]-    //     System.out.println(multiset.elementSet()); //  [All!, Hello, Hi, World!]-    //      System.out.println("Hello = " + multiset.count("Hello")); //  2 System.out.println("World = " + multiset.count("World!")); //  2 System.out.println("All = " + multiset.count("All!")); //  1 System.out.println("Hi = " + multiset.count("Hi")); //  1 System.out.println("Empty = " + multiset.count("Empty")); //  0 //        System.out.println(multiset.size()); // 6 //       System.out.println(multiset.elementSet().size()); // 4
      
      







LinkedHashMultisetTest guava
System.out.printlnmultisetおよび

System.out.printlnmultiset.elementSetの出力順序は、芁玠が最初に远加された順序であるこずに泚意しおください。

  //     String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //  Multiset Multiset<String> multiset = LinkedHashMultiset.create(Arrays.asList(INPUT_TEXT.split(" "))); //  -   System.out.println(multiset); //  [Hello x 2, World! x 2, All!, Hi]-      //     System.out.println(multiset.elementSet()); //  [Hello, World!, All!, Hi] -      //      System.out.println("Hello = " + multiset.count("Hello")); //  2 System.out.println("World = " + multiset.count("World!")); //  2 System.out.println("All = " + multiset.count("All!")); //  1 System.out.println("Hi = " + multiset.count("Hi")); //  1 System.out.println("Empty = " + multiset.count("Empty")); //  0 //        System.out.println(multiset.size()); // 6 //       System.out.println(multiset.elementSet().size()); // 4
      
      







ConcurrentHashMultiset guava
, System.out.println(multiset)

System.out.println(multiset.elementSet()) — , ,

HashMultiset

  //     String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //  Multiset Multiset<String> multiset = ConcurrentHashMultiset.create(Arrays.asList(INPUT_TEXT.split(" "))); //  -   System.out.println(multiset); //  [Hi, Hello x 2, World! x 2, All!] -    //     System.out.println(multiset.elementSet()); //  [Hi, Hello, World!, All!] -    //      System.out.println("Hello = " + multiset.count("Hello")); //  2 System.out.println("World = " + multiset.count("World!")); //  2 System.out.println("All = " + multiset.count("All!")); //  1 System.out.println("Hi = " + multiset.count("Hi")); //  1 System.out.println("Empty = " + multiset.count("Empty")); //  0 //        System.out.println(multiset.size()); // 6 //       System.out.println(multiset.elementSet().size()); // 4
      
      







2. Bag Apache Commons Collections:

HashBag Apache Commons Collections
, System.out.println(multiset)

System.out.println(multiset.elementSet()) — , .

  //     String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //  Multiset Bag bag = new HashBag(Arrays.asList(INPUT_TEXT.split(" "))); //  -   System.out.println(bag); //  [1:Hi,2:Hello,2:World!,1:All!] -    //     System.out.println(bag.uniqueSet()); //  [Hi, Hello, World!, All!] -    //      System.out.println("Hello = " + bag.getCount("Hello")); //  2 System.out.println("World = " + bag.getCount("World!")); //  2 System.out.println("All = " + bag.getCount("All!")); //  1 System.out.println("Hi = " + bag.getCount("Hi")); //  1 System.out.println("Empty = " + bag.getCount("Empty")); //  0 //        System.out.println(bag.size()); // 6 //       System.out.println(bag.uniqueSet().size()); // 4
      
      







TreeBag Apache Commons Collections
, System.out.println(multiset)

System.out.println(multiset.elementSet()) — , .

  //     String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //  Multiset Bag bag = new TreeBag(Arrays.asList(INPUT_TEXT.split(" "))); //  -   System.out.println(bag); //  [1:All!,2:Hello,1:Hi,2:World!]-    //     System.out.println(bag.uniqueSet()); //  [All!, Hello, Hi, World!]-    //      System.out.println("Hello = " + bag.getCount("Hello")); //  2 System.out.println("World = " + bag.getCount("World!")); //  2 System.out.println("All = " + bag.getCount("All!")); //  1 System.out.println("Hi = " + bag.getCount("Hi")); //  1 System.out.println("Empty = " + bag.getCount("Empty")); //  0 //        System.out.println(bag.size()); // 6 //       System.out.println(bag.uniqueSet().size()); // 4
      
      







SynchronizedBag Apache Commons Collections
, System.out.println(multiset)

System.out.println(multiset.elementSet()) — , ,

HashBag

  //     String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //  Multiset Bag bag = SynchronizedBag.synchronizedBag(new HashBag(Arrays.asList(INPUT_TEXT.split(" ")))); //  -   System.out.println(bag); //  [1:Hi,2:Hello,2:World!,1:All!] -    //     System.out.println(bag.uniqueSet()); //  [Hi, Hello, World!, All!] -    //      System.out.println("Hello = " + bag.getCount("Hello")); //  2 System.out.println("World = " + bag.getCount("World!")); //  2 System.out.println("All = " + bag.getCount("All!")); //  1 System.out.println("Hi = " + bag.getCount("Hi")); //  1 System.out.println("Empty = " + bag.getCount("Empty")); //  0 //        System.out.println(bag.size()); // 6 //       System.out.println(bag.uniqueSet().size()); // 4
      
      







SynchronizedSortedBag Apache Commons Collections
, System.out.println(multiset)

System.out.println(multiset.elementSet()) — , ,

SortedBag

  //     String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //  Multiset Bag bag = SynchronizedSortedBag.synchronizedBag(new TreeBag(Arrays.asList(INPUT_TEXT.split(" ")))); //  -   System.out.println(bag); //  [1:All!,2:Hello,1:Hi,2:World!]-    //     System.out.println(bag.uniqueSet()); //  [All!, Hello, Hi, World!]-    //      System.out.println("Hello = " + bag.getCount("Hello")); //  2 System.out.println("World = " + bag.getCount("World!")); //  2 System.out.println("All = " + bag.getCount("All!")); //  1 System.out.println("Hi = " + bag.getCount("Hi")); //  1 System.out.println("Empty = " + bag.getCount("Empty")); //  0 //        System.out.println(bag.size()); //  6 //       System.out.println(bag.uniqueSet().size()); //  4
      
      







3. Bag GS Collections:

MutableBag GS Collections
, System.out.println(bag) System.out.println(bag.toSet()) —



  //     String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //  Multiset MutableBag<String> bag = HashBag.newBag(Arrays.asList(INPUT_TEXT.split(" "))); //  -   System.out.println(bag); //  [Hi, World!, World!, Hello, Hello, All!]-    //     System.out.println(bag.toSet()); //  [Hi, Hello, World!, All!] -    //      System.out.println("Hello = " + bag.occurrencesOf("Hello")); //  2 System.out.println("World = " + bag.occurrencesOf("World!")); //  2 System.out.println("All = " + bag.occurrencesOf("All!")); //  1 System.out.println("Hi = " + bag.occurrencesOf("Hi")); //  1 System.out.println("Empty = " + bag.occurrencesOf("Empty")); //  0 //        System.out.println(bag.size()); // 6 //       System.out.println(bag.toSet().size()); // 4
      
      







MutableSortedBag GS Collections
, System.out.println(bag) System.out.println(bag.toSortedSet()) — , ..

  //     String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //  Multiset MutableSortedBag<String> bag = TreeBag.newBag(Arrays.asList(INPUT_TEXT.split(" "))); //  -   System.out.println(bag); //  [All!, Hello, Hello, Hi, World!, World!]-    //     System.out.println(bag.toSortedSet()); //  [All!, Hello, Hi, World!]-    //      System.out.println("Hello = " + bag.occurrencesOf("Hello")); //  2 System.out.println("World = " + bag.occurrencesOf("World!")); //  2 System.out.println("All = " + bag.occurrencesOf("All!")); //  1 System.out.println("Hi = " + bag.occurrencesOf("Hi")); //  1 System.out.println("Empty = " + bag.occurrencesOf("Empty")); //  0 //        System.out.println(bag.size()); // 6 //       System.out.println(bag.toSet().size()); // 4
      
      







4. , JDK multiSet HashMap

multiSet HashMap
, , , multiSet

Bag.

  //     String INPUT_TEXT = "Hello World! Hello All! Hi World!"; List<String> listResult = Arrays.asList(INPUT_TEXT.split(" ")); //   Multiset c  HashMap   Map<String, Integer> fakeMultiset = new HashMap<String,Integer>(listResult.size()); for(String word: listResult) { Integer cnt = fakeMultiset.get(word); fakeMultiset.put(word, cnt == null ? 1 : cnt + 1); } //  -   System.out.println(fakeMultiset); //  {World!=2, Hi=1, Hello=2, All!=1}-    //     System.out.println(fakeMultiset.keySet()); //  [World!, Hi, Hello, All!] -    //      System.out.println("Hello = " + fakeMultiset.get("Hello")); //  2 System.out.println("World = " + fakeMultiset.get("World!")); //  2 System.out.println("All = " + fakeMultiset.get("All!")); //  1 System.out.println("Hi = " + fakeMultiset.get("Hi")); //  1 System.out.println("Empty = " + fakeMultiset.get("Empty")); //  null //        Integer cnt = 0; for (Integer wordCount : fakeMultiset.values()){ cnt += wordCount; } System.out.println(cnt); // 6 //      System.out.println(fakeMultiset.size()); // 4
      
      









4.2 Multimap guava, Apache Commons Collections GS Collections





, Multimap map, .

.

, — ,

— , JDK

JDK .



: , .









-

-









-



Guava アパッチ

Commons

Collections

GS

Collections

JDK


-



HashMap ArrayList ArrayList-

Multimap

MultiValueMap FastList-

Multimap

HashMap<K,

ArrayList<V>>
いや HashMap HashSet HashMultimap MultiValueMap.

multiValueMap(

new HashMap<K,

Set>(),

HashSet.class);

UnifiedSet-

Multimap

HashMap<K,

HashSet<V>>
-



いや HashMap TreeSet Multimaps.

newMultimap(

HashMap,

Supplier

<TreeSet>)

MultiValueMap.

multiValueMap(

new HashMap<K,

Set>(), TreeSet.class);

TreeSortedSet-

Multimap

HashMap<K,

TreeSet<V>>


-





-



Linked

HashMap

ArrayList LinkedList-

Multimap

MultiValueMap.

multiValueMap(new

LinkedHashMap<K,

List>(), ArrayList.class);

LinkedHashMap<

K, ArrayList<V>>


-





-



いや LinkedHash-

Multimap

Linked-

HashSet

LinkedHash-

Multimap

MultiValueMap.

multiValueMap(new

LinkedHashMap<K, Set>(),

LinkedHashSet.class);

LinkedHashMap<K,

LinkedHashSet<V>>
-



-



いや TreeMap TreeSet TreeMultimap MultiValueMap.

multiValueMap(

new TreeMap<K,

Set>(),TreeSet.class);

TreeMap<K,

TreeSet<V>>


, Apache Commons Collections ,

. guava ,

map' . GS Collections

multimap Bag (HashBagMultimap), . multiset multimap.



Multimap



: «Hello World! Hello All! Hi World!»,

,

, Hello ..





1. Multimap Guava:

HashMultimap guava
, , (

HashMap, HashSet). .

  String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //       List <String> words = Arrays.asList(INPUT_TEXT.split(" ")); //  Multimap Multimap<String, Integer> multiMap = HashMultimap.create(); //  Multimap int i = 0; for(String word: words) { multiMap.put(word, i); i++; } //       System.out.println(multiMap); //  {Hi=[4], Hello=[0, 2], World!=[1, 5], All!=[3]} -    //     System.out.println(multiMap.keySet()); //  [Hi, Hello, World!, All!] -    //        System.out.println("Hello = " + multiMap.get("Hello")); //  [0, 2] System.out.println("World = " + multiMap.get("World!")); //  [1, 5] System.out.println("All = " + multiMap.get("All!")); //  [3] System.out.println("Hi = " + multiMap.get("Hi")); //  [4] System.out.println("Empty = " + multiMap.get("Empty")); //  [] //        System.out.println(multiMap.size()); // 6 //       System.out.println(multiMap.keySet().size()); // 4
      
      







ArrayListMultimapTest guava
, ,

( HashMap, ArrayList).

.

  String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //       List <String> words = Arrays.asList(INPUT_TEXT.split(" ")); //  Multimap Multimap<String, Integer> multiMap = ArrayListMultimap.create(); //  Multimap int i = 0; for(String word: words) { multiMap.put(word, i); i++; } //       System.out.println(multiMap); //  {Hi=[4], Hello=[0, 2], World!=[1, 5], All!=[3]} -    ,     //     System.out.println(multiMap.keySet()); //  [Hello, World!, All!, Hi]-    //        System.out.println("Hello = " + multiMap.get("Hello")); //  [0, 2] System.out.println("World = " + multiMap.get("World!")); //  [1, 5] System.out.println("All = " + multiMap.get("All!")); //  [3] System.out.println("Hi = " + multiMap.get("Hi")); //  [4] System.out.println("Empty = " + multiMap.get("Empty")); //  [] //        System.out.println(multiMap.size()); // 6 //       System.out.println(multiMap.keySet().size()); // 4
      
      







LinkedHashMultimapTest guava
, (

LinkedHashMap, LinkedHashSet).

.

  String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //       List <String> words = Arrays.asList(INPUT_TEXT.split(" ")); //  Multimap Multimap<String, Integer> multiMap = LinkedHashMultimap.create(); //  Multimap int i = 0; for(String word: words) { multiMap.put(word, i); i++; } //       System.out.println(multiMap); //  {Hello=[0, 2], World!=[1, 5], All!=[3], Hi=[4]}-   //     System.out.println(multiMap.keySet()); //  [Hello, World!, All!, Hi]-    //        System.out.println("Hello = " + multiMap.get("Hello")); //  [0, 2] System.out.println("World = " + multiMap.get("World!")); //  [1, 5] System.out.println("All = " + multiMap.get("All!")); //  [3] System.out.println("Hi = " + multiMap.get("Hi")); //  [4] System.out.println("Empty = " + multiMap.get("Empty")); //  [] //        System.out.println(multiMap.size()); // 6 //       System.out.println(multiMap.keySet().size()); // 4
      
      







LinkedListMultimapTest guava
, (

LinkedHashMap, LinkedList).

.

  String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //       List <String> words = Arrays.asList(INPUT_TEXT.split(" ")); //  Multimap Multimap<String, Integer> multiMap = LinkedListMultimap.create(); //  Multimap int i = 0; for(String word: words) { multiMap.put(word, i); i++; } //       System.out.println(multiMap); //  {Hello=[0, 2], World!=[1, 5], All!=[3], Hi=[4]}-   //     System.out.println(multiMap.keySet()); //  [Hello, World!, All!, Hi]-    //        System.out.println("Hello = " + multiMap.get("Hello")); //  [0, 2] System.out.println("World = " + multiMap.get("World!")); //  [1, 5] System.out.println("All = " + multiMap.get("All!")); //  [3] System.out.println("Hi = " + multiMap.get("Hi")); //  [4] System.out.println("Empty = " + multiMap.get("Empty")); //  [] //        System.out.println(multiMap.size()); // 6 //       System.out.println(multiMap.keySet().size()); // 4
      
      







TreeMultimapTest guava
, (

TreeMap, TreeSet).

  String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //       List<String> words = Arrays.asList(INPUT_TEXT.split(" ")); //  Multimap Multimap<String, Integer> multiMap = TreeMultimap.create(); //  Multimap int i = 0; for(String word: words) { multiMap.put(word, i); i++; } //       System.out.println(multiMap); //  {Hello=[0, 2], World!=[1, 5], All!=[3], Hi=[4]}-   //     System.out.println(multiMap.keySet()); //  [Hello, World!, All!, Hi]-    //        System.out.println("Hello = " + multiMap.get("Hello")); //  [0, 2] System.out.println("World = " + multiMap.get("World!")); //  [1, 5] System.out.println("All = " + multiMap.get("All!")); //  [3] System.out.println("Hi = " + multiMap.get("Hi")); //  [4] System.out.println("Empty = " + multiMap.get("Empty")); //  [] //        System.out.println(multiMap.size()); // 6 //       System.out.println(multiMap.keySet().size()); // 4
      
      









2. MultiValueMap Apache Commons Collections:

MultiValueMap Apache Commons Collections
, ( HashMap

ArrayList )

  String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //       List<String> words = Arrays.asList(INPUT_TEXT.split(" ")); //  Multimap MultiMap<String, Integer> multiMap = new MultiValueMap<String, Integer>(); //  Multimap int i = 0; for(String word: words) { multiMap.put(word, i); i++; } //       System.out.println(multiMap); //  {Hi=[4], Hello=[0, 2], World!=[1, 5], All!=[3]} -    //     System.out.println(multiMap.keySet()); //  [Hi, Hello, World!, All!] -    //        System.out.println("Hello = " + multiMap.get("Hello")); //  [0, 2] System.out.println("World = " + multiMap.get("World!")); //  [1, 5] System.out.println("All = " + multiMap.get("All!")); //  [3] System.out.println("Hi = " + multiMap.get("Hi")); //  [4] System.out.println("Empty = " + multiMap.get("Empty")); //  null //       System.out.println(multiMap.keySet().size()); // 4
      
      







MultiValueMap, TreeMap<String, TreeSet>()
,

  String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //       List<String> words = Arrays.asList(INPUT_TEXT.split(" ")); //  Multimap MultiMap<String, Integer> multiMap = MultiValueMap.multiValueMap(new TreeMap<String, Set>(), TreeSet.class); //  Multimap int i = 0; for(String word: words) { multiMap.put(word, i); i++; } //       System.out.println(multiMap); //  {All!=[3], Hello=[0, 2], Hi=[4], World!=[1, 5]} -   //     System.out.println(multiMap.keySet()); //  [All!, Hello, Hi, World!]    //        System.out.println("Hello = " + multiMap.get("Hello")); //  [0, 2] System.out.println("World = " + multiMap.get("World!")); //  [1, 5] System.out.println("All = " + multiMap.get("All!")); //  [3] System.out.println("Hi = " + multiMap.get("Hi")); //  [4] System.out.println("Empty = " + multiMap.get("Empty")); //  null //       System.out.println(multiMap.keySet().size()); // 4
      
      







MultiValueMap, LinkedHashMap<String, LinkedHashSet>()
,

  String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //       List<String> words = Arrays.asList(INPUT_TEXT.split(" ")); //  Multimap MultiMap<String, Integer> multiMap = MultiValueMap.multiValueMap(new LinkedHashMap<String, Set>(), LinkedHashSet.class); //  Multimap int i = 0; for(String word: words) { multiMap.put(word, i); i++; } //       System.out.println(multiMap); //  {Hello=[0, 2], World!=[1, 5], All!=[3], Hi=[4]} -    //     System.out.println(multiMap.keySet()); //  [Hello, World!, All!, Hi] -    //        System.out.println("Hello = " + multiMap.get("Hello")); //  [0, 2] System.out.println("World = " + multiMap.get("World!")); //  [1, 5] System.out.println("All = " + multiMap.get("All!")); //  [3] System.out.println("Hi = " + multiMap.get("Hi")); //  [4] System.out.println("Empty = " + multiMap.get("Empty")); //  null //       System.out.println(multiMap.keySet().size()); // 4
      
      







3. Multimap GS Collections:

FastListMultimap
  String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //       List<String> words = Arrays.asList(INPUT_TEXT.split(" ")); //  Multimap MutableListMultimap<String, Integer> multiMap = new FastListMultimap<String, Integer>(); //  Multimap int i = 0; for(String word: words) { multiMap.put(word, i); i++; } //       System.out.println(multiMap); //  {Hi=[4], World!=[1, 5], Hello=[0, 2], All!=[3]}-    //     System.out.println(multiMap.keysView()); //  [Hi, Hello, World!, All!] -    //        System.out.println("Hello = " + multiMap.get("Hello")); //  [0, 2] System.out.println("World = " + multiMap.get("World!")); //  [1, 5] System.out.println("All = " + multiMap.get("All!")); //  [3] System.out.println("Hi = " + multiMap.get("Hi")); //  [4] System.out.println("Empty = " + multiMap.get("Empty")); //  [] //        System.out.println(multiMap.size()); // 6 //        System.out.println(multiMap.keysView().size()); // 4
      
      







HashBagMultimap
  String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //       List<String> words = Arrays.asList(INPUT_TEXT.split(" ")); //  Multimap MutableBagMultimap<String, Integer> multiMap = new HashBagMultimap<String, Integer>(); //  Multimap int i = 0; for(String word: words) { multiMap.put(word, i); i++; } //       System.out.println(multiMap); //  {Hi=[4], World!=[1, 5], Hello=[0, 2], All!=[3]}-    //     System.out.println(multiMap.keysView()); //  [Hi, Hello, World!, All!] -    //        System.out.println("Hello = " + multiMap.get("Hello")); //  [0, 2] System.out.println("World = " + multiMap.get("World!")); //  [1, 5] System.out.println("All = " + multiMap.get("All!")); //  [3] System.out.println("Hi = " + multiMap.get("Hi")); //  [4] System.out.println("Empty = " + multiMap.get("Empty")); //  [] //        System.out.println(multiMap.size()); // 6 //        System.out.println(multiMap.keysView().size()); // 4
      
      







TreeSortedSetMultimap
  String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //       List<String> words = Arrays.asList(INPUT_TEXT.split(" ")); //  Multimap MutableSortedSetMultimap<String, Integer> multiMap = new TreeSortedSetMultimap<String, Integer>(); //  Multimap int i = 0; for(String word: words) { multiMap.put(word, i); i++; } //       System.out.println(multiMap); //  {Hi=[4], World!=[1, 5], Hello=[0, 2], All!=[3]}-    //     System.out.println(multiMap.keysView()); //  [Hi, Hello, World!, All!] -    //        System.out.println("Hello = " + multiMap.get("Hello")); //  [0, 2] System.out.println("World = " + multiMap.get("World!")); //  [1, 5] System.out.println("All = " + multiMap.get("All!")); //  [3] System.out.println("Hi = " + multiMap.get("Hi")); //  [4] System.out.println("Empty = " + multiMap.get("Empty")); //  [] //        System.out.println(multiMap.size()); // 6 //        System.out.println(multiMap.keysView().size()); // 4
      
      









4. , JDK multiMap HashMap

multiMap HashMap
  final int LIST_INDEXES_CAPACITY = 50; String INPUT_TEXT = "Hello World! Hello All! Hi World!"; //       List<String> words = Arrays.asList(INPUT_TEXT.split(" ")); //  Multimap Map<String, List<Integer>> fakeMultiMap = new HashMap<String, List<Integer>>(words.size()); //  map int i = 0; for(String word: words) { List<Integer> indexes = fakeMultiMap.get(word); if(indexes == null) { indexes = new ArrayList<Integer>(LIST_INDEXES_CAPACITY); fakeMultiMap.put(word, indexes); } indexes.add(i); i++; } //       System.out.println(fakeMultiMap); //  {Hi=[4], Hello=[0, 2], World!=[1, 5], All!=[3]} -    //     System.out.println(fakeMultiMap.keySet()); //  [Hi, Hello, World!, All!] -    //        System.out.println("Hello = " + fakeMultiMap.get("Hello")); //  [0, 2] System.out.println("World = " + fakeMultiMap.get("World!")); //  [1, 5] System.out.println("All = " + fakeMultiMap.get("All!")); //  [3] System.out.println("Hi = " + fakeMultiMap.get("Hi")); //  [4] System.out.println("Empty = " + fakeMultiMap.get("Empty")); //  null //        int cnt = 0; for(List<Integer> lists: fakeMultiMap.values()) { cnt += lists.size(); } System.out.println(cnt); // 6 //        System.out.println(fakeMultiMap.keySet().size()); // 4
      
      









4.3 BiMap guava, Apache Commons Collections GS Collections





BiMap , HashBiMap guava GS Collections

BidiMap Apache Commons Collections. HashBiMap, guava Enum

, EnumHashBiMap EnumBiMap, Apache Commons Collections

, .



BiMap - «»,



: ,

- , .





1. BiMap Guava:

BiMap guava
  String[] englishWords = {"one", "two", "three","ball","snow"}; String[] russianWords = {"", "", "","","c"}; //  Multiset BiMap<String, String> biMap = HashBiMap.create(englishWords.length); //  -  int i = 0; for(String englishWord: englishWords) { biMap.put(englishWord, russianWords[i]); i++; } //  -   System.out.println(biMap); //  {two=, three=, snow=c, ball=, one=} -    //     System.out.println(biMap.keySet()); //  [two, three, snow, ball, one] -    System.out.println(biMap.values()); //  [, , c, , ]-    //      System.out.println("one = " + biMap.get("one")); //  one =  System.out.println("two = " + biMap.get("two")); //  two =  System.out.println(" = " + biMap.inverse().get("")); //   = ball System.out.println(" = " + biMap.inverse().get("c")); //   = snow System.out.println("empty = " + biMap.get("empty")); //  empty = null //       System.out.println(biMap.size()); // 5
      
      







EnumBiMap guava
  enum ENGLISH_WORD { ONE, TWO, THREE, BALL, SNOW } enum POLISH_WORD { JEDEN, DWA, TRZY, KULA, SNIEG } //    - ,         public static void main(String[] args) { ENGLISH_WORD[] englishWords = ENGLISH_WORD.values(); POLISH_WORD[] polishWords = POLISH_WORD.values(); //  Multiset BiMap<ENGLISH_WORD, POLISH_WORD> biMap = EnumBiMap.create(ENGLISH_WORD.class, POLISH_WORD.class); //  -  int i = 0; for(ENGLISH_WORD englishWord: englishWords) { biMap.put(englishWord, polishWords[i]); i++; } //  -   System.out.println(biMap); //  {ONE=JEDEN, TWO=DWA, THREE=TRZY, BALL=KULA, SNOW=SNIEG} //     System.out.println(biMap.keySet()); //  [ONE, TWO, THREE, BALL, SNOW] System.out.println(biMap.values()); //  [JEDEN, DWA, TRZY, KULA, SNIEG] //      System.out.println("one = " + biMap.get(ENGLISH_WORD.ONE)); //  one = JEDEN System.out.println("two = " + biMap.get(ENGLISH_WORD.TWO)); //  two = DWA System.out.println("kula = " + biMap.inverse().get(POLISH_WORD.KULA)); //  kula = BALL System.out.println("snieg = " + biMap.inverse().get(POLISH_WORD.SNIEG)); //  snieg = SNOW System.out.println("empty = " + biMap.get("empty")); //  empty = null //       System.out.println(biMap.size()); // 5 }
      
      







EnumHashBiMap guava
  enum ENGLISH_WORD { ONE, TWO, THREE, BALL, SNOW } //    - ,         public static void main(String[] args) { ENGLISH_WORD[] englishWords = ENGLISH_WORD.values(); String[] russianWords = {"", "", "","","c"}; //  Multiset BiMap<ENGLISH_WORD, String> biMap = EnumHashBiMap.create(ENGLISH_WORD.class); //  -  int i = 0; for(ENGLISH_WORD englishWord: englishWords) { biMap.put(englishWord, russianWords[i]); i++; } //  -   System.out.println(biMap); //  {ONE=, TWO=, THREE=, BALL=, SNOW=c} //     System.out.println(biMap.keySet()); //  [ONE, TWO, THREE, BALL, SNOW] System.out.println(biMap.values()); //  [, , , , c] //      System.out.println("one = " + biMap.get(ENGLISH_WORD.ONE)); //  one =  System.out.println("two = " + biMap.get(ENGLISH_WORD.TWO)); //  two =  System.out.println(" = " + biMap.inverse().get("")); //   = BALL System.out.println(" = " + biMap.inverse().get("c")); //   = SNOW System.out.println("empty = " + biMap.get("empty")); //  empty = null //       System.out.println(biMap.size()); // 5 }
      
      







2. C BidiMap Apache Commons Collections:

DualHashBidiMap Apache Commons Collections
  String[] englishWords = {"one", "two", "three","ball","snow"}; String[] russianWords = {"", "", "","","c"}; //  Multiset BidiMap<String, String> biMap = new DualHashBidiMap(); //  -  int i = 0; for(String englishWord: englishWords) { biMap.put(englishWord, russianWords[i]); i++; } //  -   System.out.println(biMap); //  {ball=, snow=c, one=, two=, three=}-    //     System.out.println(biMap.keySet()); //  [ball, snow, one, two, three]-    System.out.println(biMap.values()); //  [, c, , , ]-    //      System.out.println("one = " + biMap.get("one")); //  one =  System.out.println("two = " + biMap.get("two")); //  two =  System.out.println(" = " + biMap.getKey("")); //   = ball System.out.println(" = " + biMap.getKey("c")); //   = snow System.out.println("empty = " + biMap.get("empty")); //  empty = null //       System.out.println(biMap.size()); // 5
      
      







3. C HashBiMap GS Collections:

HashBiMap GS Collections
  String[] englishWords = {"one", "two", "three","ball","snow"}; String[] russianWords = {"", "", "","","c"}; //  Multiset MutableBiMap<String, String> biMap = new HashBiMap(englishWords.length); //  -  int i = 0; for(String englishWord: englishWords) { biMap.put(englishWord, russianWords[i]); i++; } //  -   System.out.println(biMap); //  {two=, ball=, one=, snow=c, three=} -    //     System.out.println(biMap.keySet()); //  [snow, two, one, three, ball] -    System.out.println(biMap.values()); //  [, , , c, ] -    //      System.out.println("one = " + biMap.get("one")); //  one =  System.out.println("two = " + biMap.get("two")); //  two =  System.out.println(" = " + biMap.inverse().get("")); //   = ball System.out.println(" = " + biMap.inverse().get("c")); //   = snow System.out.println("empty = " + biMap.get("empty")); //  empty = null //       System.out.println(biMap.size()); // 5
      
      







4. , JDK

HashMap BiMap
  String[] englishWords = {"one", "two", "three","ball","snow"}; String[] russianWords = {"", "", "","","c"}; //   BiMap Map<String, String> biMapKeys = new HashMap(englishWords.length); Map<String, String> biMapValues = new HashMap(russianWords.length); //  -  int i = 0; for(String englishWord: englishWords) { biMapKeys.put(englishWord, russianWords[i]); biMapValues.put(russianWords[i], englishWord); i++; } //  -   System.out.println(biMapKeys); //  {ball=, two=, three=, snow=c, one=}-    //     System.out.println(biMapKeys.keySet()); //  [ball, two, three, snow, one] -    System.out.println(biMapValues.keySet()); //  [, , , c, ] -    //      System.out.println("one = " + biMapKeys.get("one")); //  one =  System.out.println("two = " + biMapKeys.get("two")); //  two =  System.out.println(" = " + biMapValues.get("")); //   = ball System.out.println(" = " + biMapValues.get("c")); //   = snow System.out.println("empty = " + biMapValues.get("empty")); //  empty = null //       System.out.println(biMapKeys.size()); // 5
      
      









V.



, JDK. , , ( ), , .



5.1 .



Guava gs-collections new, jdk.



5.1.1) (List)

圹職 JDK guava gs-collections
new ArrayList<>() Lists.newArrayList() FastList.newList()
Arrays.asList(«1», «2», «3») Lists.newArrayList(«1», «2», «3») FastList.newListWith(«1», «2», «3»)


capacity
new ArrayList<>(100) Lists.newArrayListWithCapacity(100) FastList.newList(100)


new ArrayList<>(collection) Lists.newArrayList(collection) FastList.newList(collection)


Iterable
- Lists.newArrayList(iterable) FastList.newList(iterable)


Iterator'
- Lists.newArrayList(iterator) -
Arrays.asList(array) Lists.newArrayList(array) FastList.newListWith(array)


c
- - FastList.newWithNValues(10, () -> «1»)
  //     List<String> emptyGuava = Lists.newArrayList(); // c  guava List<String> emptyJDK = new ArrayList<>(); //  JDK MutableList<String> emptyGS = FastList.newList(); // c  gs //     100  List < String > exactly100 = Lists.newArrayListWithCapacity(100); // c  guava List<String> exactly100JDK = new ArrayList<>(100); //  JDK MutableList<String> empty100GS = FastList.newList(100); // c  gs //       100  (   100) List<String> approx100 = Lists.newArrayListWithExpectedSize(100); // c  guava List<String> approx100JDK = new ArrayList<>(115); //  JDK MutableList<String> approx100GS = FastList.newList(115); // c  gs //      List<String> withElements = Lists.newArrayList("alpha", "beta", "gamma"); // c  guava List<String> withElementsJDK = Arrays.asList("alpha", "beta", "gamma"); //  JDK MutableList<String> withElementsGS = FastList.newListWith("alpha", "beta", "gamma"); // c  gs System.out.println(withElements); System.out.println(withElementsJDK); System.out.println(withElementsGS); //      Iterable  (   ) Collection<String> collection = new HashSet<>(3); collection.add("1"); collection.add("2"); collection.add("3"); List<String> fromIterable = Lists.newArrayList(collection); // c  guava List<String> fromIterableJDK = new ArrayList<>(collection); //  JDK MutableList<String> fromIterableGS = FastList.newList(collection); // c  gs System.out.println(fromIterable); System.out.println(fromIterableJDK); System.out.println(fromIterableGS); /*    JDK   Collection ,  guava  gs  Iterable */ //    Iterator' Iterator<String> iterator = collection.iterator(); List<String> fromIterator = Lists.newArrayList(iterator); // c  guava,   JDK  System.out.println(fromIterator); //     String[] array = {"4", "5", "6"}; List<String> fromArray = Lists.newArrayList(array); // c  guava List<String> fromArrayJDK = Arrays.asList(array); //  JDK MutableList<String> fromArrayGS = FastList.newListWith(array); // c  gs System.out.println(fromArray); System.out.println(fromArrayJDK); System.out.println(fromArrayGS); //    c   MutableList<String> fromFabricGS = FastList.newWithNValues(10, () -> String.valueOf(Math.random())); // c  gs System.out.println(fromFabricGS);
      
      







5.1.2) (set)

圹職 JDK guava gs-collections


new HashSet<>() Sets.newHashSet() UnifiedSet.newSet()


new HashSet<>(Arrays.asList(«alpha», «beta», «gamma»)) Sets.newHashSet(«alpha», «beta», «gamma») UnifiedSet.newSetWith(«alpha», «beta», «gamma»)


new HashSet<>(collection) Sets.newHashSet(collection) UnifiedSet.newSet(collection)


Iterable
- Sets.newHashSet(iterable) UnifiedSet.newSet(iterable)


Iterator'
- Sets.newHashSet(iterator); -


new HashSet<>(Arrays.asList(array)) Sets.newHashSet(array) UnifiedSet.newSetWith(array)
  //     Set<String> emptyGuava = Sets.newHashSet(); // c  guava Set<String> emptyJDK = new HashSet<>(); //  JDK Set<String> emptyGS = UnifiedSet.newSet(); // c  gs //       100  (   100) Set<String> approx100 = Sets.newHashSetWithExpectedSize(100); // c  guava Set<String> approx100JDK = new HashSet<>(130); //  JDK Set<String> approx100GS = UnifiedSet.newSet(130); // c  gs //      Set<String> withElements = Sets.newHashSet("alpha", "beta", "gamma"); // c  guava Set<String> withElementsJDK = new HashSet<>(Arrays.asList("alpha", "beta", "gamma")); //  JDK Set<String> withElementsGS = UnifiedSet.newSetWith("alpha", "beta", "gamma"); // c  gs System.out.println(withElements); System.out.println(withElementsJDK); System.out.println(withElementsGS); //      Iterable  (   ) Collection<String> collection = new ArrayList<>(3); collection.add("1"); collection.add("2"); collection.add("3"); Set<String> fromIterable = Sets.newHashSet(collection); // c  guava Set<String> fromIterableJDK = new HashSet<>(collection); //  JDK Set<String> fromIterableGS = UnifiedSet.newSet(collection); // c  gs System.out.println(fromIterable); System.out.println(fromIterableJDK); System.out.println(fromIterableGS); /*    JDK   Collection ,  guava  Iterable */ //    Iterator' Iterator<String> iterator = collection.iterator(); Set<String> fromIterator = Sets.newHashSet(iterator); // c  guava,   JDK  System.out.println(fromIterator); //     String[] array = {"4", "5", "6"}; Set<String> fromArray = Sets.newHashSet(array); // c  guava Set<String> fromArrayJDK = new HashSet<>(Arrays.asList(array)); //  JDK Set<String> fromArrayGS = UnifiedSet.newSetWith(array); // c  gs System.out.println(fromArray); System.out.println(fromArrayJDK); System.out.println(fromArrayGS);
      
      







5.1.3) Map

圹職 JDK guava gs-collections
map' new HashMap<>() Maps.newHashMap() UnifiedMap.newMap()
map' c

capacity
new HashMap<>(130) Maps.newHashMapWithExpectedSize(100) UnifiedMap.newMap(130)
map' map' new HashMap<>(map) Maps.newHashMap(map) UnifiedMap.newMap(map)
map' - - UnifiedMap.newWithKeysValues(«1», «a», «2», «b»)
map
//

Map<String, String> emptyGuava = Maps.newHashMap(); // c guava

Map<String, String> emptyJDK = new HashMap<>(); // JDK

Map<String, String> emptyGS = UnifiedMap.newMap(); // c gs



// map' 100 ( 100)

Map<String, String> approx100 = Maps.newHashMapWithExpectedSize(100); // c guava

Map<String, String> approx100JDK = new HashMap<>(130); // JDK

Map<String, String> approx100GS = UnifiedMap.newMap(130); // c gs



// map' map'

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

map.put(«k1»,«v1»);

map.put(«k2»,«v2»);

Map<String, String> withMap = Maps.newHashMap(map); // c guava

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

Map<String, String> withMapGS = UnifiedMap.newMap(map); // c gs



System.out.println(withMap);

System.out.println(withMapJDK);

System.out.println(withMapGS);



// map'

Map<String, String> withKeys = UnifiedMap.newWithKeysValues(«1», «a», «2», «b»);

System.out.println(withKeys);





5.2 .





圹職 JDK guava apache gs-collections
Collections.frequency(collection, «1») Iterables.frequency(iterable, «1») CollectionUtils.cardinality(«1», iterable) mutableCollection.count((each) -> «a1».equals(each))
collection.stream().findFirst().orElse(«1») Iterables.getFirst(iterable, «1») CollectionUtils.get(iterable, 0) orderedIterable.getFirst()
collection.stream().skip(collection.size()-1).findFirst().orElse(«1»); Iterables.getLast(iterable, «1») CollectionUtils.get(collection, collection.size()-1) orderedIterable.getLast()
Collections.max(collection) Ordering.natural().max(iterable) - orderedIterable.max()
Collections.min(collection) Ordering.natural().min(iterable) - orderedIterable.min()
Iterables.getOnlyElement(iterable) CollectionUtils.extractSingleton(collection)
Collections.binarySearch(list, «13») Ordering.natural().binarySearch(list, «13») mutableList.binarySearch(«13»)
collection.stream().filter(«13»::equals).findFirst().get() Iterables.find(iterable, «13»::equals) CollectionUtils.find(iterable, «13»::equals) mutableList.select(«13»::equals).get(0)
collection.stream().filter((s) -> s.contains(«1»)).collect(Collectors.toList()) Iterables.filter(iterable, (s) -> s.contains(«1»)) CollectionUtils.select(iterable, (s) -> s.contains(«1»)) mutableCollection.select((s) -> s.contains(«1»))
, : collection — Collection, iterable — Iterable, list — List, orderedIterable mutableList GS (orderedIterable — , mutableList — )



:
1)
  Collection<String> collection = Lists.newArrayList("a1", "a2", "a3", "a1"); Iterable<String> iterable = collection; MutableCollection<String> collectionGS = FastList.newListWith("a1", "a2", "a3", "a1"); //     int i1 = Iterables.frequency(iterable, "a1"); //   guava int i2 = Collections.frequency(collection, "a1"); // c  JDK int i3 = CollectionUtils.cardinality("a1", iterable); // c  Apache int i4 = collectionGS.count((s) -> "a1".equals(s)); long i5 = collection.stream().filter((s) -> "a1".equals(s)).count(); // c  stream JDK System.out.println("count = " + i1 + ":" + i2 + ":" + i3 + ":" + i4 + ":" + i5); //  count = 2:2:2:2:2
      
      





2)
  Collection<String> collection = Lists.newArrayList("a1", "a2", "a3", "a1"); OrderedIterable<String> orderedIterable = FastList.newListWith("a1", "a2", "a3", "a1"); Iterable<String> iterable = collection; //     Iterator<String> iterator = collection.iterator(); // c  JDK String jdk = iterator.hasNext() ? iterator.next(): "1"; String guava = Iterables.getFirst(iterable, "1"); //   guava String apache = CollectionUtils.get(iterable, 0); // c  Apache String gs = orderedIterable.getFirst(); // c  GS String stream = collection.stream().findFirst().orElse("1"); // c  Stream API System.out.println("first = " + jdk + ":" + guava + ":" + apache + ":" + gs + ":" + stream); //  first = a1:a1:a1:a1:a1
      
      





3)
  Collection<String> collection = Lists.newArrayList("a1", "a2", "a3", "a8"); OrderedIterable<String> orderedIterable = FastList.newListWith("a1", "a2", "a3", "a8"); Iterable<String> iterable = collection; //     Iterator<String> iterator = collection.iterator(); // c  JDK String jdk = "1"; while(iterator.hasNext()) { jdk = iterator.next(); } String guava = Iterables.getLast(iterable, "1"); //   guava String apache = CollectionUtils.get(collection, collection.size()-1); // c  Apache String gs = orderedIterable.getLast(); // c  GS String stream = collection.stream().skip(collection.size()-1).findFirst().orElse("1"); // c  Stream API System.out.println("last = " + jdk + ":" + guava + ":" + apache + ":" + gs + ":" + stream); //  last = a8:a8:a8:a8:a8
      
      





4)
  Collection<String> collection = Lists.newArrayList("5", "1", "3", "8", "4"); OrderedIterable<String> orderedIterable = FastList.newListWith("5", "1", "3", "8", "4"); Iterable<String> iterable = collection; //     String jdk = Collections.max(collection); // c  JDK String gs = orderedIterable.max(); // c  GS String guava = Ordering.natural().max(iterable); //   guava System.out.println("max = " + jdk + ":" + guava + ":" + gs); //  max = 8:8:8
      
      





5)
  Collection<String> collection = Lists.newArrayList("5", "1", "3", "8", "4"); OrderedIterable<String> orderedIterable = FastList.newListWith("5", "1", "3", "8", "4"); Iterable<String> iterable = collection; //     String jdk = Collections.min(collection); // c  JDK String gs = orderedIterable.min(); // c  GS String guava = Ordering.natural().min(iterable); //   guava System.out.println("min = " + jdk + ":" + guava + ":" + gs); //  min = 1:1:1
      
      





6)
  Collection<String> collection = Lists.newArrayList("a3"); OrderedIterable<String> orderedIterable = FastList.newListWith("a3"); Iterable<String> iterable = collection; //     String guava = Iterables.getOnlyElement(iterable); //   guava String jdk = collection.iterator().next(); // c  JDK String apache = CollectionUtils.extractSingleton(collection); // c  Apache assert(orderedIterable.size() > 1);// c  GS String gs = orderedIterable.getFirst(); System.out.println("single = " + jdk + ":" + guava + ":" + apache + ":" + gs); //  single = a3:a3:a3:a3
      
      





7)
  List<String> list = Lists.newArrayList("2", "4", "13", "31", "43"); MutableList<String> mutableList = FastList.newListWith("2", "4","13", "31", "43"); //      int jdk = Collections.binarySearch(list, "13"); int guava = Ordering.natural().binarySearch(list, "13"); int gs = mutableList.binarySearch("13"); System.out.println("find = " + jdk + ":" + guava + ":" + gs); //  find = 2:2:2
      
      



8)
  Collection<String> collection = Lists.newArrayList("a1", "a2", "a3", "a1"); MutableCollection<String> orderedIterable = FastList.newListWith("a1", "a2", "a3", "a1"); Iterable<String> iterable = collection; //       String jdk = collection.stream().skip(2).findFirst().get(); // c  JDK String guava = Iterables.get(iterable, 2); //   guava String apache = CollectionUtils.get(iterable, 2); // c  Apache System.out.println("third = " + jdk + ":" + guava + ":" + apache); //  third = a3:a3:a3
      
      



9)
  Collection<String> collection = Lists.newArrayList("2", "14", "3", "13", "43"); MutableCollection<String> mutableCollection = FastList.newListWith("2", "14", "3", "13", "43"); Iterable<String> iterable = collection; //      List<String> jdk = collection.stream().filter((s) -> s.contains("1")).collect(Collectors.toList()); // c  JDK Iterable<String> guava = Iterables.filter(iterable, (s) -> s.contains("1")); //   guava Collection<String> apache = CollectionUtils.select(iterable, (s) -> s.contains("1")); // c  Apache MutableCollection<String> gs = mutableCollection.select((s) -> s.contains("1")); // c  GS System.out.println("select = " + jdk + ":" + guava + ":" + apache + ":" + gs); //  select = [14, 13]:[14, 13]:[14, 13]:[14, 13]
      
      









5.3 ,



圹職 JDK guava apache gs-collections
collection1.containsAll(collection2) Iterables.elementsEqual(iterable1, iterable2) CollectionUtils.containsAll(collection1, collection2) mutableCollection1.containsAll(mutableCollection2)
!Collections.disjoint(collection1, collection2) !Sets.intersection(set1, set2).isEmpty() CollectionUtils.containsAny(collection1, collection2) !mutableSet1.intersect(mutableSet2).isEmpty()
() Set<T> result = new HashSet<>(set1);

result.retainAll(set2)
Sets.intersection(set1, set2) CollectionUtils.intersection(collection1, collection2) mutableSet1.intersect(mutableSet2)
Collections.disjoint(collection1, collection2) Sets.intersection(set1, set2).isEmpty() !CollectionUtils.containsAny(collection1, collection2) mutableSet1.intersect(mutableSet2).isEmpty()
, (difference) Set<T> result = new HashSet<>(set1);

result.removeAll(set2)
Sets.difference(set1, set2) CollectionUtils.removeAll(collection1, collection2) mutableSet1.difference(mutableSet2)
(symmetric difference) Sets.symmetricDifference(set1, set2) CollectionUtils.disjunction(collection1, collection2) mutableSet1.symmetricDifference(mutableSet2)
Set<T> result = new HashSet<>(set1);

result.addAll(set2)
Sets.union(set1, set2) CollectionUtils.union(collection1, collection2) mutableSet1.union(mutableSet2)


:
1)
  Collection<String> collection1 = Lists.newArrayList("a1", "a2", "a3", "a1"); Collection<String> collection2 = Lists.newArrayList("a1", "a2", "a3", "a1"); Iterable<String> iterable1 = collection1; Iterable<String> iterable2 = collection2; MutableCollection<String> mutableCollection1 = FastList.newListWith("a1", "a2", "a3", "a1"); MutableCollection<String> mutableCollection2 = FastList.newListWith("a1", "a2", "a3", "a1"); //      boolean jdk = collection1.containsAll(collection2); // c  JDK boolean guava = Iterables.elementsEqual(iterable1, iterable2); //   guava boolean apache = CollectionUtils.containsAll(collection1, collection2); // c  Apache boolean gs = mutableCollection1.containsAll(mutableCollection2); // c  GS System.out.println("containsAll = " + jdk + ":" + guava + ":" + apache + ":" + gs); //  containsAll = true:true:true:true
      
      





2)
  Collection<String> collection1 = Lists.newArrayList("a1", "a2", "a3", "a1"); Collection<String> collection2 = Lists.newArrayList("a4", "a8", "a3", "a5"); Set<String> set1 = Sets.newHashSet("a1", "a2", "a3", "a1"); Set<String> set2 = Sets.newHashSet("a4", "a8", "a3", "a5"); MutableSet<String> mutableSet1 = UnifiedSet.newSetWith("a1", "a2", "a3", "a1"); MutableSet<String> mutableSet2 = UnifiedSet.newSetWith("a4", "a8", "a3", "a5"); //           boolean jdk = !Collections.disjoint(collection1, collection2); // c  JDK boolean guava = !Sets.intersection(set1, set2).isEmpty(); //   guava boolean apache = CollectionUtils.containsAny(collection1, collection2); // c  Apache boolean gs = !mutableSet1.intersect(mutableSet2).isEmpty(); // c  GS System.out.println("containsAny = " + jdk + ":" + guava + ":" + apache + ":" + gs); //  containsAny = true:true:true:true
      
      





3) ()
  Collection<String> collection1 = Lists.newArrayList("a1", "a2", "a3", "a1"); Collection<String> collection2 = Lists.newArrayList("a4", "a8", "a3", "a5"); Set<String> set1 = Sets.newHashSet("a1", "a2", "a3", "a1"); Set<String> set2 = Sets.newHashSet("a4", "a8", "a3", "a5"); MutableSet<String> mutableSet1 = UnifiedSet.newSetWith("a1", "a2", "a3", "a1"); MutableSet<String> mutableSet2 = UnifiedSet.newSetWith("a4", "a8", "a3", "a5"); //        Set<String> jdk = new HashSet<>(set1); // c  JDK jdk.retainAll(set2); Set<String> guava = Sets.intersection(set1, set2); //   guava Collection<String> apache = CollectionUtils.intersection(collection1, collection2); // c  Apache Set<String> gs = mutableSet1.intersect(mutableSet2); // c  GS System.out.println("intersect = " + jdk + ":" + guava + ":" + apache + ":" + gs); //  intersect = [a3]:[a3]:[a3]:[a3]
      
      





4) , (difference)
  Collection<String> collection1 = Lists.newArrayList("a2", "a3"); Collection<String> collection2 = Lists.newArrayList("a8", "a3", "a5"); Set<String> set1 = Sets.newHashSet("a2", "a3"); Set<String> set2 = Sets.newHashSet("a8", "a3", "a5"); MutableSet<String> mutableSet1 = UnifiedSet.newSetWith("a2", "a3"); MutableSet<String> mutableSet2 = UnifiedSet.newSetWith("a8", "a3", "a5"); //   ,          (difference) Set<String> jdk = new HashSet<>(set1); // c  JDK jdk.removeAll(set2); Set<String> guava = Sets.difference(set1, set2); //   guava Collection<String> apache = CollectionUtils.removeAll(collection1, collection2); // c  Apache Set<String> gs = mutableSet1.difference(mutableSet2); // c  GS System.out.println("difference = " + jdk + ":" + guava + ":" + apache + ":" + gs); //  difference = [a2]:[a2]:[a2]:[a2]
      
      





5) (symmetric difference)
  Collection<String> collection1 = Lists.newArrayList("a2", "a3"); Collection<String> collection2 = Lists.newArrayList("a8", "a3", "a5"); Set<String> set1 = Sets.newHashSet("a2", "a3"); Set<String> set2 = Sets.newHashSet("a8", "a3", "a5"); MutableSet<String> mutableSet1 = UnifiedSet.newSetWith("a2", "a3"); MutableSet<String> mutableSet2 = UnifiedSet.newSetWith("a8", "a3", "a5"); //     (symmetric difference)    Set<String> intersect = new HashSet<>(set1); // c  JDK intersect.retainAll(set2); Set<String> jdk = new HashSet<>(set1); jdk.addAll(set2); jdk.removeAll(intersect); Set<String> guava = Sets.symmetricDifference(set1, set2); //   guava Collection<String> apache = CollectionUtils.disjunction(collection1, collection2); // c  Apache Set<String> gs = mutableSet1.symmetricDifference(mutableSet2); // c  GS System.out.println("symmetricDifference = " + jdk + ":" + guava + ":" + apache + ":" + gs); //  symmetricDifference = [a2, a5, a8]:[a2, a5, a8]:[a2, a5, a8]:[a2, a5, a8]
      
      





6)
  Set<String> set1 = Sets.newHashSet("a1", "a2"); Set<String> set2 = Sets.newHashSet("a4"); MutableSet<String> mutableSet1 = UnifiedSet.newSetWith("a1", "a2"); MutableSet<String> mutableSet2 = UnifiedSet.newSetWith("a4"); Collection<String> collection1 = set1; Collection<String> collection2 = set2; //     Set<String> jdk = new HashSet<>(set1); // c  JDK jdk.addAll(set2); Set<String> guava = Sets.union(set1, set2); //   guava Collection<String> apache = CollectionUtils.union(collection1, collection2); // c  Apache Set<String> gs = mutableSet1.union(mutableSet2); // c  GS System.out.println("union = " + jdk + ":" + guava + ":" + apache + ":" + gs); //  union = [a1, a2, a4]:[a1, a2, a4]:[a1, a2, a4]:[a1, a2, a4]
      
      









5.4



圹職 JDK guava apache gs-collections
Collections.sort(list); Ordering.natural().sortedCopy(iterable) mutableList.sortThis()
collection.removeIf((s) -> s.contains(«1»)) Iterables.removeIf(iterable, (s) -> s.contains(«1»)) CollectionUtils.filter(iterable, (s) -> !s.contains(«1»)) mutableCollection.removeIf((Predicate<String>) (s) -> s.contains(«1»))
collection.removeIf((s) -> !s.contains(«1»)) Iterables.removeIf(iterable, (s) -> !s.contains(«1»)) CollectionUtils.filter(iterable, (s) -> s.contains(«1»)) mutableCollection.removeIf((Predicate<String>) (s) -> !s.contains(«1»))
collection.stream().map((s) -> s + "_1").collect(Collectors.toList()) Iterables.transform(iterable, (s) -> s + "_1") CollectionUtils.transform(collection, (s) -> s + "_1") mutableCollection.collect((s) -> s + "_1")
collection.stream().forEach((s) -> s.append("_1")) Iterables.transform(iterable, (s) -> s.append("_1")) CollectionUtils.transform(collection, (s) -> s.append("_1")) mutableCollection.forEach((Procedure<StringBuilder>) (s) -> s.append("_1"))


1)
  List<String> jdk = Lists.newArrayList("a1", "a2", "a3", "a1"); Iterable<String> iterable = jdk; MutableList<String> gs = FastList.newList(jdk); //   Collections.sort(jdk); //   jdk List<String> guava = Ordering.natural().sortedCopy(iterable); //   guava gs.sortThis(); // c  gs System.out.println("sort = " + jdk + ":" + guava + ":" + gs); //  sort = [a1, a1, a2, a3]:[a1, a1, a2, a3]:[a1, a1, a2, a3]
      
      





2)
  Collection<String> jdk = Lists.newArrayList("a1", "a2", "a3", "a1"); Iterable<String> guava = Lists.newArrayList(jdk); Iterable<String> apache = Lists.newArrayList(jdk); MutableCollection<String> gs = FastList.newList(jdk); //      jdk.removeIf((s) -> s.contains("1")); //   jdk Iterables.removeIf(guava, (s) -> s.contains("1")); //   guava CollectionUtils.filter(apache, (s) -> !s.contains("1")); //   apache gs.removeIf((Predicate<String>) (s) -> s.contains("1")); // c  gs System.out.println("removeIf = " + jdk + ":" + guava + ":" + apache + ":" + gs); //  removeIf = [a2, a3]:[a2, a3]:[a2, a3]:[a2, a3]
      
      





3)
  Collection<String> jdk = Lists.newArrayList("a1", "a2", "a3", "a1"); Iterable<String> guava = Lists.newArrayList(jdk); Iterable<String> apache = Lists.newArrayList(jdk); MutableCollection<String> gs = FastList.newList(jdk); //       jdk.removeIf((s) -> !s.contains("1")); //   jdk Iterables.removeIf(guava, (s) -> !s.contains("1")); //   guava CollectionUtils.filter(apache, (s) -> s.contains("1")); //   apache gs.removeIf((Predicate<String>) (s) -> !s.contains("1")); // c  gs System.out.println("retainIf = " + jdk + ":" + guava + ":" + apache + ":" + gs); //  retainIf = [a1, a1]:[a1, a1]:[a1, a1]:[a1, a1]
      
      





4)
  Collection<String> collection = Lists.newArrayList("a1", "a2", "a3", "a1"); Iterable<String> iterable = collection; Collection<String> apache = Lists.newArrayList(collection); MutableCollection<String> mutableCollection = FastList.newList(collection); //        List<String> jdk = collection.stream().map((s) -> s + "_1").collect(Collectors.toList()); //   jdk Iterable<String> guava = Iterables.transform(iterable, (s) -> s + "_1"); //   guava CollectionUtils.transform(apache, (s) -> s + "_1"); //   apache MutableCollection<String> gs = mutableCollection.collect((s) -> s + "_1"); // c  gs System.out.println("transform = " + jdk + ":" + guava + ":" + apache + ":" + gs); //  transform = [a1_1, a2_1, a3_1, a1_1]:[a1_1, a2_1, a3_1, a1_1]:[a1_1, a2_1, a3_1, a1_1]:[a1_1, a2_1, a3_1, a1_1]
      
      





5)
  Collection<StringBuilder> jdk = Lists.newArrayList(new StringBuilder("a1"), new StringBuilder("a2"), new StringBuilder("a3")); Iterable<StringBuilder> iterable = Lists.newArrayList(new StringBuilder("a1"), new StringBuilder("a2"), new StringBuilder("a3"));; Collection<StringBuilder> apache = Lists.newArrayList(new StringBuilder("a1"), new StringBuilder("a2"), new StringBuilder("a3")); MutableCollection<StringBuilder> gs = FastList.newListWith(new StringBuilder("a1"), new StringBuilder("a2"), new StringBuilder("a3")); //      jdk.stream().forEach((s) -> s.append("_1")); //   jdk Iterable<StringBuilder> guava = Iterables.transform(iterable, (s) -> s.append("_1")); //   guava CollectionUtils.transform(apache, (s) -> s.append("_1")); //   apache gs.forEach((Procedure<StringBuilder>) (s) -> s.append("_1")); // c  gs System.out.println("change = " + jdk + ":" + guava + ":" + apache + ":" + gs); // changeAll = [a1_1, a2_1, a3_1]:[a1_1, a2_1, a3_1]:[a1_1, a2_1, a3_1]:[a1_1, a2_1, a3_1]
      
      









VI.





5.1



( Java, ):

1) () — , ,

— — ,

— — , ,

— — ,

, ,

— —

,

2) (Stack) — , «LIFO» (« — »).

, /.

3) (Queue) — , «FIFO» (« — »).

/.

4) (Double-ended queue) — ,

.

5) (. priority queue) — ,

. ,

— (heap) — , ,

6) (), (Associative array, Dictionary) — ,

«— »

— - (hashtable) — , ,

— - (Multimap multihash) — -,

,

— - - (bi-map) — -,

, ,

— - (hashtable) — -, ,

— - (hashtable) — -, ,

7) — ,

,

— — , ,

,

— — , , ,

— — , , ,

8) — 1 0,

9) —

,

10) — , ,

11) — ,



Java :



: , .

圹職 List Set Map Query

Dequery

.. JDK
guava apache gs-collections
1) ()

ArrayList LinkedHashSet LinkedHashMap ArrayDeque TreeList FastList
LinkedList LinkedHashSet LinkedHashMap LinkedList NodeCachingLinkedList
2) (Stack) LinkedList ArrayDeque ArrayStack
3) (Queue) LinkedList ArrayDeque CircularFifoQueue
4) LinkedList ArrayDeque
5)

(heap)
PriorityQueue
6) () HashMap HashedMap UnifiedMap
- (hashtable) HashSet HashMap HashedMap UnifiedMap
- Multimap MultiMap Multimap
- - HashBiMap BidiMap HashBiMap
- LinkedHashSet LinkedHashMap LinkedMap
- TreeSet TreeMap PatriciaTrie TreeSortedMap
7) HashSet UnifiedSet
HashMultiset HashBag HashBag
LinkedHashSet
TreeSet PatriciaTrie TreeSortedSet
8) BitSet
9) RangeSet

RangeMap
10) TreeSet TreeMap PatriciaTrie TreeSortedSet
11) LinkedHashMap

WeakHashMap
LoadingCache




VII. おわりに





, , , . , ( ) , - .



github' .



, :

1. java.util.concurrent.* tutorial

2. Trove library: using primitive collections for performance

3. Java performance tuning tips

4. Large HashMap overview

5. Memory consumption of popular Java data types

6. , , , javadoc



PPS opensource [useful-java-links](https://github.com/Vedenin/useful-java-links/tree/master/link-rus) — , Java , . [ ](https://github.com/Vedenin/useful-java-links/) opensource [Hello world](https://github.com/Vedenin/useful-java-links/tree/master/helloworlds) Java maven ( ).



''
1. JPA Hibernate

2. Java opensource github

3. Java (, guava, apache, trove, gs-collections

4. Java Stream API

5. Java

6. Java

7

7.1 InputStream

7.2 Map',

8. Json (Gson, Fastjson, LoganSquare, Jackson, JsonPath )




All Articles